6 from .common import InfoExtractor
10 compat_urllib_request,
17 from .brightcove import BrightcoveIE
20 class GenericIE(InfoExtractor):
21 IE_DESC = u'Generic downloader that works on some sites'
26 u'url': u'http://www.hodiho.fr/2013/02/regis-plante-sa-jeep.html',
27 u'file': u'13601338388002.mp4',
28 u'md5': u'6e15c93721d7ec9e9ca3fdbf07982cfd',
30 u"uploader": u"www.hodiho.fr",
31 u"title": u"R\u00e9gis plante sa Jeep"
34 # embedded vimeo video
37 u'url': u'http://skillsmatter.com/podcast/home/move-semanticsperfect-forwarding-and-rvalue-references',
38 u'file': u'22444065.mp4',
39 u'md5': u'2903896e23df39722c33f015af0666e2',
41 u'title': u'ACCU 2011: Move Semantics,Perfect Forwarding, and Rvalue references- Scott Meyers- 13/04/2011',
42 u"uploader_id": u"skillsmatter",
43 u"uploader": u"Skills Matter",
46 # bandcamp page with custom domain
48 u'add_ie': ['Bandcamp'],
49 u'url': u'http://bronyrock.com/track/the-pony-mash',
50 u'file': u'3235767654.mp3',
52 u'title': u'The Pony Mash',
53 u'uploader': u'M_Pallante',
55 u'skip': u'There is a limit of 200 free downloads / month for the test song',
57 # embedded brightcove video
59 u'add_ie': ['Brightcove'],
60 u'url': u'http://www.scientificamerican.com/article.cfm?id=soap-bubble-physics',
62 u'id': u'2365799484001',
64 u'title': u'Bubble Simulation',
65 u'description': u'A visualization from a new computer model of foam behavior.',
66 u'uploader': u'Scientific American',
69 u'skip_download': True,
74 def report_download_webpage(self, video_id):
75 """Report webpage download."""
76 if not self._downloader.params.get('test', False):
77 self._downloader.report_warning(u'Falling back on generic information extractor.')
78 super(GenericIE, self).report_download_webpage(video_id)
80 def report_following_redirect(self, new_url):
81 """Report information extraction."""
82 self._downloader.to_screen(u'[redirect] Following redirect to %s' % new_url)
84 def _test_redirect(self, url):
85 """Check if it is a redirect, like url shorteners, in case return the new url."""
86 class HeadRequest(compat_urllib_request.Request):
90 class HEADRedirectHandler(compat_urllib_request.HTTPRedirectHandler):
92 Subclass the HTTPRedirectHandler to make it use our
93 HeadRequest also on the redirected URL
95 def redirect_request(self, req, fp, code, msg, headers, newurl):
96 if code in (301, 302, 303, 307):
97 newurl = newurl.replace(' ', '%20')
98 newheaders = dict((k,v) for k,v in req.headers.items()
99 if k.lower() not in ("content-length", "content-type"))
100 return HeadRequest(newurl,
102 origin_req_host=req.get_origin_req_host(),
105 raise compat_urllib_error.HTTPError(req.get_full_url(), code, msg, headers, fp)
107 class HTTPMethodFallback(compat_urllib_request.BaseHandler):
109 Fallback to GET if HEAD is not allowed (405 HTTP error)
111 def http_error_405(self, req, fp, code, msg, headers):
115 newheaders = dict((k,v) for k,v in req.headers.items()
116 if k.lower() not in ("content-length", "content-type"))
117 return self.parent.open(compat_urllib_request.Request(req.get_full_url(),
119 origin_req_host=req.get_origin_req_host(),
123 opener = compat_urllib_request.OpenerDirector()
124 for handler in [compat_urllib_request.HTTPHandler, compat_urllib_request.HTTPDefaultErrorHandler,
125 HTTPMethodFallback, HEADRedirectHandler,
126 compat_urllib_request.HTTPErrorProcessor, compat_urllib_request.HTTPSHandler]:
127 opener.add_handler(handler())
129 response = opener.open(HeadRequest(url))
131 raise ExtractorError(u'Invalid URL protocol')
132 new_url = response.geturl()
137 self.report_following_redirect(new_url)
140 def _real_extract(self, url):
141 parsed_url = compat_urlparse.urlparse(url)
142 if not parsed_url.scheme:
143 self._downloader.report_warning('The url doesn\'t specify the protocol, trying with http')
144 return self.url_result('http://' + url)
147 new_url = self._test_redirect(url)
149 return [self.url_result(new_url)]
150 except compat_urllib_error.HTTPError:
151 # This may be a stupid server that doesn't like HEAD, our UA, or so
154 video_id = url.split('/')[-1]
156 webpage = self._download_webpage(url, video_id)
158 # since this is the last-resort InfoExtractor, if
159 # this error is thrown, it'll be thrown here
160 raise ExtractorError(u'Failed to download URL: %s' % url)
162 self.report_extraction(video_id)
163 # Look for BrightCove:
164 bc_url = BrightcoveIE._extract_brightcove_url(webpage)
165 if bc_url is not None:
166 self.to_screen(u'Brightcove video detected.')
167 return self.url_result(bc_url, 'Brightcove')
169 # Look for embedded Vimeo player
171 r'<iframe[^>]+?src="(https?://player.vimeo.com/video/.+?)"', webpage)
173 player_url = unescapeHTML(mobj.group(1))
174 surl = smuggle_url(player_url, {'Referer': url})
175 return self.url_result(surl, 'Vimeo')
177 # Look for embedded YouTube player
179 r'<iframe[^>]+?src=(["\'])(?P<url>https?://(?:www\.)?youtube.com/embed/.+?)\1', webpage)
181 surl = unescapeHTML(mobj.group(u'url'))
182 return self.url_result(surl, 'Youtube')
184 # Look for Bandcamp pages with custom domain
185 mobj = re.search(r'<meta property="og:url"[^>]*?content="(.*?bandcamp\.com.*?)"', webpage)
187 burl = unescapeHTML(mobj.group(1))
188 return self.url_result(burl, 'Bandcamp')
190 # Start with something easy: JW Player in SWFObject
191 mobj = re.search(r'flashvars: [\'"](?:.*&)?file=(http[^\'"&]*)', webpage)
193 # Broaden the search a little bit
194 mobj = re.search(r'[^A-Za-z0-9]?(?:file|source)=(http[^\'"&]*)', webpage)
196 # Broaden the search a little bit: JWPlayer JS loader
197 mobj = re.search(r'[^A-Za-z0-9]?file["\']?:\s*["\'](http[^\'"&]*)', webpage)
199 # Try to find twitter cards info
200 mobj = re.search(r'<meta (?:property|name)="twitter:player:stream" (?:content|value)="(.+?)"', webpage)
202 # We look for Open Graph info:
203 # We have to match any number spaces between elements, some sites try to align them (eg.: statigr.am)
204 m_video_type = re.search(r'<meta.*?property="og:video:type".*?content="video/(.*?)"', webpage)
205 # We only look in og:video if the MIME type is a video, don't try if it's a Flash player:
206 if m_video_type is not None:
207 mobj = re.search(r'<meta.*?property="og:video".*?content="(.*?)"', webpage)
210 mobj = re.search(r'<video[^<]*(?:>.*?<source.*?)? src="([^"]+)"', webpage, flags=re.DOTALL)
212 raise ExtractorError(u'Unsupported URL: %s' % url)
214 # It's possible that one of the regexes
215 # matched, but returned an empty group:
216 if mobj.group(1) is None:
217 raise ExtractorError(u'Did not find a valid video URL at %s' % url)
219 video_url = mobj.group(1)
220 video_url = compat_urlparse.urljoin(url, video_url)
221 video_id = compat_urllib_parse.unquote(os.path.basename(video_url))
223 # here's a fun little line of code for you:
224 video_extension = os.path.splitext(video_id)[1][1:]
225 video_id = os.path.splitext(video_id)[0]
227 # it's tempting to parse this further, but you would
228 # have to take into account all the variations like
229 # Video Title - Site Name
230 # Site Name | Video Title
231 # Video Title - Tagline | Site Name
232 # and so on and so forth; it's just not practical
233 video_title = self._html_search_regex(r'<title>(.*)</title>',
234 webpage, u'video title', default=u'video', flags=re.DOTALL)
236 # video uploader is domain name
237 video_uploader = self._search_regex(r'(?:https?://)?([^/]*)/.*',
238 url, u'video uploader')
243 'uploader': video_uploader,
245 'title': video_title,
246 'ext': video_extension,