From dd82ffea0c3a0dcf67f8e9fca7226de3a2899425 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?= Date: Tue, 2 Jul 2013 10:08:58 +0200 Subject: [PATCH 01/14] Implement format selection in YoutubeDL Now the IEs can set a formats field in the info_dict, with the formats ordered from worst to best quality. It's a list of dicts with the following fields: * Mandatory: url and ext * Optional: format and format_id The format_id is used for choosing which formats have to be downloaded. Now a video result is processed by the method process_video_result. --- youtube_dl/YoutubeDL.py | 80 +++++++++++++++++++++++++++++++++++++---- youtube_dl/__init__.py | 2 +- 2 files changed, 74 insertions(+), 8 deletions(-) diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index e85e03fa4..feb105861 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -385,13 +385,7 @@ class YoutubeDL(object): result_type = ie_result.get('_type', 'video') # If not given we suppose it's a video, support the default old system if result_type == 'video': ie_result.update(extra_info) - if 'playlist' not in ie_result: - # It isn't part of a playlist - ie_result['playlist'] = None - ie_result['playlist_index'] = None - if download: - self.process_info(ie_result) - return ie_result + return self.process_video_result(ie_result) elif result_type == 'url': # We have to add extra_info to the results because it may be # contained in a playlist @@ -449,6 +443,64 @@ class YoutubeDL(object): else: raise Exception('Invalid result type: %s' % result_type) + def process_video_result(self, info_dict, download=True): + assert info_dict.get('_type', 'video') == 'video' + + if 'playlist' not in info_dict: + # It isn't part of a playlist + info_dict['playlist'] = None + info_dict['playlist_index'] = None + + # We now pick which formats have to be downloaded + if info_dict.get('formats') is None: + # There's only one format available + formats = [info_dict] + else: + formats = info_dict['formats'] + + # We check that all the formats have the format and format_id fields + for (i, format) in enumerate(formats): + if format.get('format') is None: + format['format'] = compat_str(i) + if format.get('format_id') is None: + format['format_id'] = compat_str(i) + + if self.params.get('listformats', None): + self.list_formats(info_dict) + return + + req_format = self.params.get('format', 'best') + formats_to_download = [] + if req_format == 'best' or req_format is None: + formats_to_download = [formats[-1]] + elif req_format == 'worst': + formats_to_download = [formats[0]] + # The -1 is for supporting YoutubeIE + elif req_format in ('-1', 'all'): + formats_to_download = formats + else: + # We can accept formats requestd in the format: 34/10/5, we pick + # the first that is availble, starting from left + req_formats = req_format.split('/') + for rf in req_formats: + matches = filter(lambda f:f['format_id'] == rf ,formats) + if matches: + formats_to_download = [matches[0]] + break + if not formats_to_download: + raise ExtractorError(u'requested format not available') + + if download: + if len(formats_to_download) > 1: + self.to_screen(u'[info] %s: downloading video in %s formats' % (info_dict['id'], len(formats_to_download))) + for format in formats_to_download: + new_info = dict(info_dict) + new_info.update(format) + self.process_info(new_info) + # We update the info dict with the best quality format (backwards compatibility) + info_dict.update(formats_to_download[-1]) + return info_dict + def process_info(self, info_dict): """Process a single resolved IE result.""" @@ -655,3 +707,17 @@ class YoutubeDL(object): vid_id = info_dict['extractor'] + u' ' + info_dict['id'] with locked_file(fn, 'a', encoding='utf-8') as archive_file: archive_file.write(vid_id + u'\n') + + def list_formats(self, info_dict): + formats_s = [] + for format in info_dict.get('formats', [info_dict]): + formats_s.append("%s\t:\t%s\t[%s]" % (format['format_id'], + format['ext'], + format.get('format', '???'), + ) + ) + if len(formats_s) != 1: + formats_s[0] += ' (worst)' + formats_s[-1] += ' (best)' + formats_s = "\n".join(formats_s) + self.to_screen(u"[info] Available formats for %s:\nformat code\textension\n%s" % (info_dict['id'], formats_s)) diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py index 3513d719f..bc8e97250 100644 --- a/youtube_dl/__init__.py +++ b/youtube_dl/__init__.py @@ -208,7 +208,7 @@ def parseOpts(overrideArguments=None): video_format.add_option('-f', '--format', - action='store', dest='format', metavar='FORMAT', + action='store', dest='format', metavar='FORMAT', default='best', help='video format code, specifiy the order of preference using slashes: "-f 22/17/18". "-f mp4" and "-f flv" are also supported') video_format.add_option('--all-formats', action='store_const', dest='format', help='download all available video formats', const='all') From 99e206d508646b183ef315da162147ed6fd75442 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?= Date: Mon, 8 Jul 2013 12:10:47 +0200 Subject: [PATCH 02/14] Implement the max quality option in YoutubeDL --- youtube_dl/YoutubeDL.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index feb105861..d88378dda 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -469,6 +469,10 @@ class YoutubeDL(object): self.list_formats(info_dict) return + format_limit = self.params.get('format_limit', None) + if format_limit: + formats = [f for f in formats if f['format_id'] <= format_limit] + req_format = self.params.get('format', 'best') formats_to_download = [] if req_format == 'best' or req_format is None: From 6ff000b888a3da702a894addd9f9824139fd8c8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?= Date: Sat, 13 Jul 2013 17:51:26 +0200 Subject: [PATCH 03/14] Do not handle format selection for IEs that already handle it --- youtube_dl/YoutubeDL.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index d88378dda..c6235abd3 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -451,6 +451,11 @@ class YoutubeDL(object): info_dict['playlist'] = None info_dict['playlist_index'] = None + # This extractors handle format selection themselves + if info_dict['extractor'] in [u'youtube', u'Youku', u'YouPorn', u'mixcloud']: + self.process_info(info_dict) + return info_dict + # We now pick which formats have to be downloaded if info_dict.get('formats') is None: # There's only one format available From 79819f58f2328cdb08272c55d01965cd8c6624ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?= Date: Sat, 13 Jul 2013 18:19:37 +0200 Subject: [PATCH 04/14] Default 'format' field to {width}x{height} If width is None, use {height}p and if height is None, '???' --- youtube_dl/YoutubeDL.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index c6235abd3..829a70ec9 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -466,9 +466,16 @@ class YoutubeDL(object): # We check that all the formats have the format and format_id fields for (i, format) in enumerate(formats): if format.get('format') is None: - format['format'] = compat_str(i) + if format.get('height') is not None: + if format.get('width') is not None: + format_desc = u'%sx%s' % (format['width'], format['height']) + else: + format_desc = u'%sp' % format['height'] + else: + format_desc = compat_str(i) + format['format'] = format_desc if format.get('format_id') is None: - format['format_id'] = compat_str(i) + format['format_id'] = '???' if self.params.get('listformats', None): self.list_formats(info_dict) From e028d0d1e3ffed0a323b41431dbbfc804aa9553e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?= Date: Sun, 14 Jul 2013 17:24:18 +0200 Subject: [PATCH 05/14] Implement the prefer_free_formats in YoutubeDL --- test/test_YoutubeDL.py | 49 +++++++++++++++++++++++++++++++++++++++++ youtube_dl/YoutubeDL.py | 9 ++++++++ 2 files changed, 58 insertions(+) create mode 100644 test/test_YoutubeDL.py diff --git a/test/test_YoutubeDL.py b/test/test_YoutubeDL.py new file mode 100644 index 000000000..2b9fb92ee --- /dev/null +++ b/test/test_YoutubeDL.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python + +import sys +import unittest + +# Allow direct execution +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from helper import FakeYDL, parameters + +class YDL(FakeYDL): + def __init__(self): + super(YDL, self).__init__() + self.downloaded_info_dicts = [] + def process_info(self, info_dict): + self.downloaded_info_dicts.append(info_dict) + +class TestFormatSelection(unittest.TestCase): + def test_prefer_free_formats(self): + # Same resolution => download webm + ydl = YDL() + ydl.params['prefer_free_formats'] = True + formats = [{u'ext': u'webm', u'height': 460},{u'ext': u'mp4', u'height': 460}] + info_dict = {u'formats': formats, u'extractor': u'test'} + ydl.process_ie_result(info_dict) + downloaded = ydl.downloaded_info_dicts[0] + self.assertEqual(downloaded[u'ext'], u'webm') + + # Different resolution => download best quality (mp4) + ydl = YDL() + ydl.params['prefer_free_formats'] = True + formats = [{u'ext': u'webm', u'height': 720},{u'ext': u'mp4',u'height': 1080}] + info_dict[u'formats'] = formats + ydl.process_ie_result(info_dict) + downloaded = ydl.downloaded_info_dicts[0] + self.assertEqual(downloaded[u'ext'], u'mp4') + + # No prefer_free_formats => keep original formats order + ydl = YDL() + ydl.params['prefer_free_formats'] = False + formats = [{u'ext': u'webm', u'height': 720},{u'ext': u'flv',u'height': 720}] + info_dict[u'formats'] = formats + ydl.process_ie_result(info_dict) + downloaded = ydl.downloaded_info_dicts[0] + self.assertEqual(downloaded[u'ext'], u'flv') + +if __name__ == '__main__': + unittest.main() diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index 829a70ec9..e159aa336 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -484,6 +484,15 @@ class YoutubeDL(object): format_limit = self.params.get('format_limit', None) if format_limit: formats = [f for f in formats if f['format_id'] <= format_limit] + if self.params.get('prefer_free_formats'): + def _free_formats_key(f): + try: + ext_ord = [u'flv', u'mp4', u'webm'].index(f['ext']) + except ValueError: + ext_ord = -1 + # We only compare the extension if they have the same height and width + return (f.get('height'), f.get('width'), ext_ord) + formats = sorted(formats, key=_free_formats_key) req_format = self.params.get('format', 'best') formats_to_download = [] From 8016c9229718080f5211b9f9da176992622b30e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaime=20Marqui=CC=81nez=20Ferra=CC=81ndiz?= Date: Sun, 14 Jul 2013 17:31:52 +0200 Subject: [PATCH 06/14] Fix the default values of format_id and format --- youtube_dl/YoutubeDL.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index e159aa336..a32e50772 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -472,10 +472,10 @@ class YoutubeDL(object): else: format_desc = u'%sp' % format['height'] else: - format_desc = compat_str(i) + format_desc = '???' format['format'] = format_desc if format.get('format_id') is None: - format['format_id'] = '???' + format['format_id'] = compat_str(i) if self.params.get('listformats', None): self.list_formats(info_dict) From 5d254f776a4d306961b6d22d8f7615844ef64390 Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 00:27:51 +0200 Subject: [PATCH 07/14] Fix test --- test/test_YoutubeDL.py | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/test/test_YoutubeDL.py b/test/test_YoutubeDL.py index 2b9fb92ee..ee210ed23 100644 --- a/test/test_YoutubeDL.py +++ b/test/test_YoutubeDL.py @@ -1,27 +1,32 @@ #!/usr/bin/env python -import sys -import unittest - # Allow direct execution import os -sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +import sys +import unittest +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from test.helper import FakeYDL -from helper import FakeYDL, parameters class YDL(FakeYDL): def __init__(self): super(YDL, self).__init__() self.downloaded_info_dicts = [] + def process_info(self, info_dict): self.downloaded_info_dicts.append(info_dict) + class TestFormatSelection(unittest.TestCase): def test_prefer_free_formats(self): # Same resolution => download webm ydl = YDL() ydl.params['prefer_free_formats'] = True - formats = [{u'ext': u'webm', u'height': 460},{u'ext': u'mp4', u'height': 460}] + formats = [ + {u'ext': u'webm', u'height': 460}, + {u'ext': u'mp4', u'height': 460}, + ] info_dict = {u'formats': formats, u'extractor': u'test'} ydl.process_ie_result(info_dict) downloaded = ydl.downloaded_info_dicts[0] @@ -30,7 +35,10 @@ class TestFormatSelection(unittest.TestCase): # Different resolution => download best quality (mp4) ydl = YDL() ydl.params['prefer_free_formats'] = True - formats = [{u'ext': u'webm', u'height': 720},{u'ext': u'mp4',u'height': 1080}] + formats = [ + {u'ext': u'webm', u'height': 720}, + {u'ext': u'mp4', u'height': 1080}, + ] info_dict[u'formats'] = formats ydl.process_ie_result(info_dict) downloaded = ydl.downloaded_info_dicts[0] @@ -39,7 +47,10 @@ class TestFormatSelection(unittest.TestCase): # No prefer_free_formats => keep original formats order ydl = YDL() ydl.params['prefer_free_formats'] = False - formats = [{u'ext': u'webm', u'height': 720},{u'ext': u'flv',u'height': 720}] + formats = [ + {u'ext': u'webm', u'height': 720}, + {u'ext': u'flv', u'height': 720}, + ] info_dict[u'formats'] = formats ydl.process_ie_result(info_dict) downloaded = ydl.downloaded_info_dicts[0] From f4d96df0f1e978d580197fafb8dacade4b611ef3 Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 00:46:35 +0200 Subject: [PATCH 08/14] Extend #980 with --max-quality support --- test/helper.py | 4 ++-- test/test_YoutubeDL.py | 43 +++++++++++++++++++++++++++++++++++++++-- youtube_dl/YoutubeDL.py | 4 +++- youtube_dl/utils.py | 9 +++++++++ 4 files changed, 55 insertions(+), 5 deletions(-) diff --git a/test/helper.py b/test/helper.py index 79a0ede48..777119ea5 100644 --- a/test/helper.py +++ b/test/helper.py @@ -34,10 +34,10 @@ def try_rm(filename): class FakeYDL(YoutubeDL): - def __init__(self): + def __init__(self, override=None): # Different instances of the downloader can't share the same dictionary # some test set the "sublang" parameter, which would break the md5 checks. - params = get_params() + params = get_params(override=override) super(FakeYDL, self).__init__(params) self.result = [] diff --git a/test/test_YoutubeDL.py b/test/test_YoutubeDL.py index ee210ed23..ba6dc05bc 100644 --- a/test/test_YoutubeDL.py +++ b/test/test_YoutubeDL.py @@ -10,13 +10,17 @@ from test.helper import FakeYDL class YDL(FakeYDL): - def __init__(self): - super(YDL, self).__init__() + def __init__(self, *args, **kwargs): + super(YDL, self).__init__(*args, **kwargs) self.downloaded_info_dicts = [] + self.msgs = [] def process_info(self, info_dict): self.downloaded_info_dicts.append(info_dict) + def to_screen(self, msg): + self.msgs.append(msg) + class TestFormatSelection(unittest.TestCase): def test_prefer_free_formats(self): @@ -56,5 +60,40 @@ class TestFormatSelection(unittest.TestCase): downloaded = ydl.downloaded_info_dicts[0] self.assertEqual(downloaded[u'ext'], u'flv') + def test_format_limit(self): + formats = [ + {u'format_id': u'meh'}, + {u'format_id': u'good'}, + {u'format_id': u'great'}, + {u'format_id': u'excellent'}, + ] + info_dict = { + u'formats': formats, u'extractor': u'test', 'id': 'testvid'} + + ydl = YDL() + ydl.process_ie_result(info_dict) + downloaded = ydl.downloaded_info_dicts[0] + self.assertEqual(downloaded[u'format_id'], u'excellent') + + ydl = YDL({'format_limit': 'good'}) + assert ydl.params['format_limit'] == 'good' + ydl.process_ie_result(info_dict) + downloaded = ydl.downloaded_info_dicts[0] + self.assertEqual(downloaded[u'format_id'], u'good') + + ydl = YDL({'format_limit': 'great', 'format': 'all'}) + ydl.process_ie_result(info_dict) + self.assertEqual(ydl.downloaded_info_dicts[0][u'format_id'], u'meh') + self.assertEqual(ydl.downloaded_info_dicts[1][u'format_id'], u'good') + self.assertEqual(ydl.downloaded_info_dicts[2][u'format_id'], u'great') + self.assertTrue('3' in ydl.msgs[0]) + + ydl = YDL() + ydl.params['format_limit'] = 'excellent' + ydl.process_ie_result(info_dict) + downloaded = ydl.downloaded_info_dicts[0] + self.assertEqual(downloaded[u'format_id'], u'excellent') + + if __name__ == '__main__': unittest.main() diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index f22a8bd0e..fd98321f1 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -488,7 +488,9 @@ class YoutubeDL(object): format_limit = self.params.get('format_limit', None) if format_limit: - formats = [f for f in formats if f['format_id'] <= format_limit] + formats = list(takewhile_inclusive( + lambda f: f['format_id'] != format_limit, formats + )) if self.params.get('prefer_free_formats'): def _free_formats_key(f): try: diff --git a/youtube_dl/utils.py b/youtube_dl/utils.py index 833f981f2..bfb8f6bcd 100644 --- a/youtube_dl/utils.py +++ b/youtube_dl/utils.py @@ -947,6 +947,15 @@ def shell_quote(args): return ' '.join(map(pipes.quote, args)) +def takewhile_inclusive(pred, seq): + """ Like itertools.takewhile, but include the latest evaluated element + (the first element so that Not pred(e)) """ + for e in seq: + yield e + if not pred(e): + return + + def smuggle_url(url, data): """ Pass additional data in a URL for internal use. """ From 416a5efce7f70a6a3ef88ac902100fa5211e181e Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 00:49:45 +0200 Subject: [PATCH 09/14] fix typos --- youtube_dl/YoutubeDL.py | 2 +- youtube_dl/extractor/common.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/youtube_dl/YoutubeDL.py b/youtube_dl/YoutubeDL.py index fd98321f1..296c0f992 100644 --- a/youtube_dl/YoutubeDL.py +++ b/youtube_dl/YoutubeDL.py @@ -512,7 +512,7 @@ class YoutubeDL(object): formats_to_download = formats else: # We can accept formats requestd in the format: 34/10/5, we pick - # the first that is availble, starting from left + # the first that is available, starting from left req_formats = req_format.split('/') for rf in req_formats: matches = filter(lambda f:f['format_id'] == rf ,formats) diff --git a/youtube_dl/extractor/common.py b/youtube_dl/extractor/common.py index 2a5a85dc6..d4af3b5eb 100644 --- a/youtube_dl/extractor/common.py +++ b/youtube_dl/extractor/common.py @@ -365,7 +365,7 @@ class SearchInfoExtractor(InfoExtractor): def _get_n_results(self, query, n): """Get a specified number of results for a query""" - raise NotImplementedError("This method must be implemented by sublclasses") + raise NotImplementedError("This method must be implemented by subclasses") @property def SEARCH_KEY(self): From 7c58ef3275a2463728528b395fe584815aa6b16a Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 11:16:11 +0200 Subject: [PATCH 10/14] [tudou] Fix title regex (Fixes #1614) --- youtube_dl/extractor/tudou.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/youtube_dl/extractor/tudou.py b/youtube_dl/extractor/tudou.py index 79679a14a..7a3891b89 100644 --- a/youtube_dl/extractor/tudou.py +++ b/youtube_dl/extractor/tudou.py @@ -48,7 +48,8 @@ class TudouIE(InfoExtractor): 'ie_key': 'Youku' } - title = self._search_regex(r",kw:['\"](.+?)[\"']", webpage, u'title') + title = self._search_regex( + r",kw:\s*['\"](.+?)[\"']", webpage, u'title') thumbnail_url = self._search_regex( r",pic:\s*[\"'](.+?)[\"']", webpage, u'thumbnail URL', fatal=False) From 8e55e9abfc4aec5369161e05789b3eacf1865246 Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 11:17:21 +0200 Subject: [PATCH 11/14] release 2013.10.18 --- youtube_dl/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/youtube_dl/version.py b/youtube_dl/version.py index 22a51ffe6..ddef5fa50 100644 --- a/youtube_dl/version.py +++ b/youtube_dl/version.py @@ -1,2 +1,2 @@ -__version__ = '2013.10.17' +__version__ = '2013.10.18' From 53c1d3ef4992c7682e56819e0a4079d7bbd9d44a Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 11:44:57 +0200 Subject: [PATCH 12/14] Check for embedded YouTube player (Fixes #1616) --- youtube_dl/extractor/generic.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/youtube_dl/extractor/generic.py b/youtube_dl/extractor/generic.py index 89805250c..69e0a7bd2 100644 --- a/youtube_dl/extractor/generic.py +++ b/youtube_dl/extractor/generic.py @@ -142,12 +142,19 @@ class GenericIE(InfoExtractor): # Look for embedded Vimeo player mobj = re.search( - r']+?src="(https?://player.vimeo.com/video/.+?)"', webpage) if mobj: player_url = unescapeHTML(mobj.group(1)) surl = smuggle_url(player_url, {'Referer': url}) return self.url_result(surl, 'Vimeo') + # Look for embedded YouTube player + mobj = re.search( + r']+?src="(https?://(?:www\.)?youtube.com/embed/.+?)"', webpage) + if mobj: + surl = unescapeHTML(mobj.group(1)) + return self.url_result(surl, 'Youtube') + # Start with something easy: JW Player in SWFObject mobj = re.search(r'flashvars: [\'"](?:.*&)?file=(http[^\'"&]*)', webpage) if mobj is None: From 82697fb2ab9524b426f9e0e5bc7c49aa3f86b47c Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 11:45:30 +0200 Subject: [PATCH 13/14] release 2013.10.18.1 --- youtube_dl/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/youtube_dl/version.py b/youtube_dl/version.py index ddef5fa50..971530f8b 100644 --- a/youtube_dl/version.py +++ b/youtube_dl/version.py @@ -1,2 +1,2 @@ -__version__ = '2013.10.18' +__version__ = '2013.10.18.1' From cce722b79ccbe0883a1fdda4f13fe7a3f9465462 Mon Sep 17 00:00:00 2001 From: Philipp Hagemeister Date: Fri, 18 Oct 2013 11:50:48 +0200 Subject: [PATCH 14/14] Add metavar to --cache-dir --- youtube_dl/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/youtube_dl/__init__.py b/youtube_dl/__init__.py index cd642ce3b..47acb4320 100644 --- a/youtube_dl/__init__.py +++ b/youtube_dl/__init__.py @@ -196,7 +196,7 @@ def parseOpts(overrideArguments=None): general.add_option('--proxy', dest='proxy', default=None, help='Use the specified HTTP/HTTPS proxy', metavar='URL') general.add_option('--no-check-certificate', action='store_true', dest='no_check_certificate', default=False, help='Suppress HTTPS certificate validation.') general.add_option( - '--cache-dir', dest='cachedir', default=get_cachedir(), + '--cache-dir', dest='cachedir', default=get_cachedir(), metavar='DIR', help='Location in the filesystem where youtube-dl can store downloaded information permanently. By default $XDG_CACHE_HOME/youtube-dl or ~/.cache/youtube-dl .') general.add_option( '--no-cache-dir', action='store_const', const=None, dest='cachedir',