_ Git - youtube-dl/blob - youtube_dl/extractor/common.py

   1 from __future__ import unicode_literals
   2
   3 import base64
   4 import datetime
   5 import hashlib
   6 import json
   7 import netrc
   8 import os
   9 import re
  10 import socket
  11 import sys
  12 import time
  13 import xml.etree.ElementTree
  14
  15 from ..compat import (
  16     compat_cookiejar,
  17     compat_http_client,
  18     compat_urllib_error,
  19     compat_urllib_parse_urlparse,
  20     compat_urlparse,
  21     compat_str,
  22 )
  23 from ..utils import (
  24     age_restricted,
  25     clean_html,
  26     compiled_regex_type,
  27     ExtractorError,
  28     float_or_none,
  29     int_or_none,
  30     RegexNotFoundError,
  31     sanitize_filename,
  32     unescapeHTML,
  33 )
  34 _NO_DEFAULT = object()
  35
  36
  37 class InfoExtractor(object):
  38     """Information Extractor class.
  39
  40     Information extractors are the classes that, given a URL, extract
  41     information about the video (or videos) the URL refers to. This
  42     information includes the real video URL, the video title, author and
  43     others. The information is stored in a dictionary which is then
  44     passed to the YoutubeDL. The YoutubeDL processes this
  45     information possibly downloading the video to the file system, among
  46     other possible outcomes.
  47
  48     The type field determines the the type of the result.
  49     By far the most common value (and the default if _type is missing) is
  50     "video", which indicates a single video.
  51
  52     For a video, the dictionaries must include the following fields:
  53
  54     id:             Video identifier.
  55     title:          Video title, unescaped.
  56
  57     Additionally, it must contain either a formats entry or a url one:
  58
  59     formats:        A list of dictionaries for each format available, ordered
  60                     from worst to best quality.
  61
  62                     Potential fields:
  63                     * url        Mandatory. The URL of the video file
  64                     * ext        Will be calculated from url if missing
  65                     * format     A human-readable description of the format
  66                                  ("mp4 container with h264/opus").
  67                                  Calculated from the format_id, width, height.
  68                                  and format_note fields if missing.
  69                     * format_id  A short description of the format
  70                                  ("mp4_h264_opus" or "19").
  71                                 Technically optional, but strongly recommended.
  72                     * format_note Additional info about the format
  73                                  ("3D" or "DASH video")
  74                     * width      Width of the video, if known
  75                     * height     Height of the video, if known
  76                     * resolution Textual description of width and height
  77                     * tbr        Average bitrate of audio and video in KBit/s
  78                     * abr        Average audio bitrate in KBit/s
  79                     * acodec     Name of the audio codec in use
  80                     * asr        Audio sampling rate in Hertz
  81                     * vbr        Average video bitrate in KBit/s
  82                     * fps        Frame rate
  83                     * vcodec     Name of the video codec in use
  84                     * container  Name of the container format
  85                     * filesize   The number of bytes, if known in advance
  86                     * filesize_approx  An estimate for the number of bytes
  87                     * player_url SWF Player URL (used for rtmpdump).
  88                     * protocol   The protocol that will be used for the actual
  89                                  download, lower-case.
  90                                  "http", "https", "rtsp", "rtmp", "m3u8" or so.
  91                     * preference Order number of this format. If this field is
  92                                  present and not None, the formats get sorted
  93                                  by this field, regardless of all other values.
  94                                  -1 for default (order by other properties),
  95                                  -2 or smaller for less than default.
  96                                  < -1000 to hide the format (if there is
  97                                     another one which is strictly better)
  98                     * language_preference  Is this in the correct requested
  99                                  language?
 100                                  10 if it's what the URL is about,
 101                                  -1 for default (don't know),
 102                                  -10 otherwise, other values reserved for now.
 103                     * quality    Order number of the video quality of this
 104                                  format, irrespective of the file format.
 105                                  -1 for default (order by other properties),
 106                                  -2 or smaller for less than default.
 107                     * source_preference  Order number for this video source
 108                                   (quality takes higher priority)
 109                                  -1 for default (order by other properties),
 110                                  -2 or smaller for less than default.
 111                     * http_method  HTTP method to use for the download.
 112                     * http_headers  A dictionary of additional HTTP headers
 113                                  to add to the request.
 114                     * http_post_data  Additional data to send with a POST
 115                                  request.
 116                     * stretched_ratio  If given and not 1, indicates that the
 117                                        video's pixels are not square.
 118                                        width : height ratio as float.
 119     url:            Final video URL.
 120     ext:            Video filename extension.
 121     format:         The video format, defaults to ext (used for --get-format)
 122     player_url:     SWF Player URL (used for rtmpdump).
 123
 124     The following fields are optional:
 125
 126     alt_title:      A secondary title of the video.
 127     display_id      An alternative identifier for the video, not necessarily
 128                     unique, but available before title. Typically, id is
 129                     something like "4234987", title "Dancing naked mole rats",
 130                     and display_id "dancing-naked-mole-rats"
 131     thumbnails:     A list of dictionaries, with the following entries:
 132                         * "id" (optional, string) - Thumbnail format ID
 133                         * "url"
 134                         * "preference" (optional, int) - quality of the image
 135                         * "width" (optional, int)
 136                         * "height" (optional, int)
 137                         * "resolution" (optional, string "{width}x{height"},
 138                                         deprecated)
 139     thumbnail:      Full URL to a video thumbnail image.
 140     description:    Full video description.
 141     uploader:       Full name of the video uploader.
 142     timestamp:      UNIX timestamp of the moment the video became available.
 143     upload_date:    Video upload date (YYYYMMDD).
 144                     If not explicitly set, calculated from timestamp.
 145     uploader_id:    Nickname or id of the video uploader.
 146     location:       Physical location where the video was filmed.
 147     subtitles:      The subtitle file contents as a dictionary in the format
 148                     {language: subtitles}.
 149     duration:       Length of the video in seconds, as an integer.
 150     view_count:     How many users have watched the video on the platform.
 151     like_count:     Number of positive ratings of the video
 152     dislike_count:  Number of negative ratings of the video
 153     comment_count:  Number of comments on the video
 154     comments:       A list of comments, each with one or more of the following
 155                     properties (all but one of text or html optional):
 156                         * "author" - human-readable name of the comment author
 157                         * "author_id" - user ID of the comment author
 158                         * "id" - Comment ID
 159                         * "html" - Comment as HTML
 160                         * "text" - Plain text of the comment
 161                         * "timestamp" - UNIX timestamp of comment
 162                         * "parent" - ID of the comment this one is replying to.
 163                                      Set to "root" to indicate that this is a
 164                                      comment to the original video.
 165     age_limit:      Age restriction for the video, as an integer (years)
 166     webpage_url:    The url to the video webpage, if given to youtube-dl it
 167                     should allow to get the same result again. (It will be set
 168                     by YoutubeDL if it's missing)
 169     categories:     A list of categories that the video falls in, for example
 170                     ["Sports", "Berlin"]
 171     is_live:        True, False, or None (=unknown). Whether this video is a
 172                     live stream that goes on instead of a fixed-length video.
 173
 174     Unless mentioned otherwise, the fields should be Unicode strings.
 175
 176     Unless mentioned otherwise, None is equivalent to absence of information.
 177
 178
 179     _type "playlist" indicates multiple videos.
 180     There must be a key "entries", which is a list, an iterable, or a PagedList
 181     object, each element of which is a valid dictionary by this specification.
 182
 183     Additionally, playlists can have "title" and "id" attributes with the same
 184     semantics as videos (see above).
 185
 186
 187     _type "multi_video" indicates that there are multiple videos that
 188     form a single show, for examples multiple acts of an opera or TV episode.
 189     It must have an entries key like a playlist and contain all the keys
 190     required for a video at the same time.
 191
 192
 193     _type "url" indicates that the video must be extracted from another
 194     location, possibly by a different extractor. Its only required key is:
 195     "url" - the next URL to extract.
 196     The key "ie_key" can be set to the class name (minus the trailing "IE",
 197     e.g. "Youtube") if the extractor class is known in advance.
 198     Additionally, the dictionary may have any properties of the resolved entity
 199     known in advance, for example "title" if the title of the referred video is
 200     known ahead of time.
 201
 202
 203     _type "url_transparent" entities have the same specification as "url", but
 204     indicate that the given additional information is more precise than the one
 205     associated with the resolved URL.
 206     This is useful when a site employs a video service that hosts the video and
 207     its technical metadata, but that video service does not embed a useful
 208     title, description etc.
 209
 210
 211     Subclasses of this one should re-define the _real_initialize() and
 212     _real_extract() methods and define a _VALID_URL regexp.
 213     Probably, they should also be added to the list of extractors.
 214
 215     Finally, the _WORKING attribute should be set to False for broken IEs
 216     in order to warn the users and skip the tests.
 217     """
 218
 219     _ready = False
 220     _downloader = None
 221     _WORKING = True
 222
 223     def __init__(self, downloader=None):
 224         """Constructor. Receives an optional downloader."""
 225         self._ready = False
 226         self.set_downloader(downloader)
 227
 228     @classmethod
 229     def suitable(cls, url):
 230         """Receives a URL and returns True if suitable for this IE."""
 231
 232         # This does not use has/getattr intentionally - we want to know whether
 233         # we have cached the regexp for *this* class, whereas getattr would also
 234         # match the superclass
 235         if '_VALID_URL_RE' not in cls.__dict__:
 236             cls._VALID_URL_RE = re.compile(cls._VALID_URL)
 237         return cls._VALID_URL_RE.match(url) is not None
 238
 239     @classmethod
 240     def _match_id(cls, url):
 241         if '_VALID_URL_RE' not in cls.__dict__:
 242             cls._VALID_URL_RE = re.compile(cls._VALID_URL)
 243         m = cls._VALID_URL_RE.match(url)
 244         assert m
 245         return m.group('id')
 246
 247     @classmethod
 248     def working(cls):
 249         """Getter method for _WORKING."""
 250         return cls._WORKING
 251
 252     def initialize(self):
 253         """Initializes an instance (authentication, etc)."""
 254         if not self._ready:
 255             self._real_initialize()
 256             self._ready = True
 257
 258     def extract(self, url):
 259         """Extracts URL information and returns it in list of dicts."""
 260         self.initialize()
 261         return self._real_extract(url)
 262
 263     def set_downloader(self, downloader):
 264         """Sets the downloader for this IE."""
 265         self._downloader = downloader
 266
 267     def _real_initialize(self):
 268         """Real initialization process. Redefine in subclasses."""
 269         pass
 270
 271     def _real_extract(self, url):
 272         """Real extraction process. Redefine in subclasses."""
 273         pass
 274
 275     @classmethod
 276     def ie_key(cls):
 277         """A string for getting the InfoExtractor with get_info_extractor"""
 278         return cls.__name__[:-2]
 279
 280     @property
 281     def IE_NAME(self):
 282         return type(self).__name__[:-2]
 283
 284     def _request_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True):
 285         """ Returns the response handle """
 286         if note is None:
 287             self.report_download_webpage(video_id)
 288         elif note is not False:
 289             if video_id is None:
 290                 self.to_screen('%s' % (note,))
 291             else:
 292                 self.to_screen('%s: %s' % (video_id, note))
 293         try:
 294             return self._downloader.urlopen(url_or_request)
 295         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 296             if errnote is False:
 297                 return False
 298             if errnote is None:
 299                 errnote = 'Unable to download webpage'
 300             errmsg = '%s: %s' % (errnote, compat_str(err))
 301             if fatal:
 302                 raise ExtractorError(errmsg, sys.exc_info()[2], cause=err)
 303             else:
 304                 self._downloader.report_warning(errmsg)
 305                 return False
 306
 307     def _download_webpage_handle(self, url_or_request, video_id, note=None, errnote=None, fatal=True):
 308         """ Returns a tuple (page content as string, URL handle) """
 309         # Strip hashes from the URL (#1038)
 310         if isinstance(url_or_request, (compat_str, str)):
 311             url_or_request = url_or_request.partition('#')[0]
 312
 313         urlh = self._request_webpage(url_or_request, video_id, note, errnote, fatal)
 314         if urlh is False:
 315             assert not fatal
 316             return False
 317         content = self._webpage_read_content(urlh, url_or_request, video_id, note, errnote, fatal)
 318         return (content, urlh)
 319
 320     def _webpage_read_content(self, urlh, url_or_request, video_id, note=None, errnote=None, fatal=True, prefix=None):
 321         content_type = urlh.headers.get('Content-Type', '')
 322         webpage_bytes = urlh.read()
 323         if prefix is not None:
 324             webpage_bytes = prefix + webpage_bytes
 325         m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
 326         if m:
 327             encoding = m.group(1)
 328         else:
 329             m = re.search(br'<meta[^>]+charset=[\'"]?([^\'")]+)[ /\'">]',
 330                           webpage_bytes[:1024])
 331             if m:
 332                 encoding = m.group(1).decode('ascii')
 333             elif webpage_bytes.startswith(b'\xff\xfe'):
 334                 encoding = 'utf-16'
 335             else:
 336                 encoding = 'utf-8'
 337         if self._downloader.params.get('dump_intermediate_pages', False):
 338             try:
 339                 url = url_or_request.get_full_url()
 340             except AttributeError:
 341                 url = url_or_request
 342             self.to_screen('Dumping request to ' + url)
 343             dump = base64.b64encode(webpage_bytes).decode('ascii')
 344             self._downloader.to_screen(dump)
 345         if self._downloader.params.get('write_pages', False):
 346             try:
 347                 url = url_or_request.get_full_url()
 348             except AttributeError:
 349                 url = url_or_request
 350             basen = '%s_%s' % (video_id, url)
 351             if len(basen) > 240:
 352                 h = '___' + hashlib.md5(basen.encode('utf-8')).hexdigest()
 353                 basen = basen[:240 - len(h)] + h
 354             raw_filename = basen + '.dump'
 355             filename = sanitize_filename(raw_filename, restricted=True)
 356             self.to_screen('Saving request to ' + filename)
 357             # Working around MAX_PATH limitation on Windows (see
 358             # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx)
 359             if os.name == 'nt':
 360                 absfilepath = os.path.abspath(filename)
 361                 if len(absfilepath) > 259:
 362                     filename = '\\\\?\\' + absfilepath
 363             with open(filename, 'wb') as outf:
 364                 outf.write(webpage_bytes)
 365
 366         try:
 367             content = webpage_bytes.decode(encoding, 'replace')
 368         except LookupError:
 369             content = webpage_bytes.decode('utf-8', 'replace')
 370
 371         if ('<title>Access to this site is blocked</title>' in content and
 372                 'Websense' in content[:512]):
 373             msg = 'Access to this webpage has been blocked by Websense filtering software in your network.'
 374             blocked_iframe = self._html_search_regex(
 375                 r'<iframe src="([^"]+)"', content,
 376                 'Websense information URL', default=None)
 377             if blocked_iframe:
 378                 msg += ' Visit %s for more details' % blocked_iframe
 379             raise ExtractorError(msg, expected=True)
 380
 381         return content
 382
 383     def _download_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True, tries=1, timeout=5):
 384         """ Returns the data of the page as a string """
 385         success = False
 386         try_count = 0
 387         while success is False:
 388             try:
 389                 res = self._download_webpage_handle(url_or_request, video_id, note, errnote, fatal)
 390                 success = True
 391             except compat_http_client.IncompleteRead as e:
 392                 try_count += 1
 393                 if try_count >= tries:
 394                     raise e
 395                 self._sleep(timeout, video_id)
 396         if res is False:
 397             return res
 398         else:
 399             content, _ = res
 400             return content
 401
 402     def _download_xml(self, url_or_request, video_id,
 403                       note='Downloading XML', errnote='Unable to download XML',
 404                       transform_source=None, fatal=True):
 405         """Return the xml as an xml.etree.ElementTree.Element"""
 406         xml_string = self._download_webpage(
 407             url_or_request, video_id, note, errnote, fatal=fatal)
 408         if xml_string is False:
 409             return xml_string
 410         if transform_source:
 411             xml_string = transform_source(xml_string)
 412         return xml.etree.ElementTree.fromstring(xml_string.encode('utf-8'))
 413
 414     def _download_json(self, url_or_request, video_id,
 415                        note='Downloading JSON metadata',
 416                        errnote='Unable to download JSON metadata',
 417                        transform_source=None,
 418                        fatal=True):
 419         json_string = self._download_webpage(
 420             url_or_request, video_id, note, errnote, fatal=fatal)
 421         if (not fatal) and json_string is False:
 422             return None
 423         return self._parse_json(
 424             json_string, video_id, transform_source=transform_source, fatal=fatal)
 425
 426     def _parse_json(self, json_string, video_id, transform_source=None, fatal=True):
 427         if transform_source:
 428             json_string = transform_source(json_string)
 429         try:
 430             return json.loads(json_string)
 431         except ValueError as ve:
 432             errmsg = '%s: Failed to parse JSON ' % video_id
 433             if fatal:
 434                 raise ExtractorError(errmsg, cause=ve)
 435             else:
 436                 self.report_warning(errmsg + str(ve))
 437
 438     def report_warning(self, msg, video_id=None):
 439         idstr = '' if video_id is None else '%s: ' % video_id
 440         self._downloader.report_warning(
 441             '[%s] %s%s' % (self.IE_NAME, idstr, msg))
 442
 443     def to_screen(self, msg):
 444         """Print msg to screen, prefixing it with '[ie_name]'"""
 445         self._downloader.to_screen('[%s] %s' % (self.IE_NAME, msg))
 446
 447     def report_extraction(self, id_or_name):
 448         """Report information extraction."""
 449         self.to_screen('%s: Extracting information' % id_or_name)
 450
 451     def report_download_webpage(self, video_id):
 452         """Report webpage download."""
 453         self.to_screen('%s: Downloading webpage' % video_id)
 454
 455     def report_age_confirmation(self):
 456         """Report attempt to confirm age."""
 457         self.to_screen('Confirming age')
 458
 459     def report_login(self):
 460         """Report attempt to log in."""
 461         self.to_screen('Logging in')
 462
 463     # Methods for following #608
 464     @staticmethod
 465     def url_result(url, ie=None, video_id=None):
 466         """Returns a url that points to a page that should be processed"""
 467         # TODO: ie should be the class used for getting the info
 468         video_info = {'_type': 'url',
 469                       'url': url,
 470                       'ie_key': ie}
 471         if video_id is not None:
 472             video_info['id'] = video_id
 473         return video_info
 474
 475     @staticmethod
 476     def playlist_result(entries, playlist_id=None, playlist_title=None, playlist_description=None):
 477         """Returns a playlist"""
 478         video_info = {'_type': 'playlist',
 479                       'entries': entries}
 480         if playlist_id:
 481             video_info['id'] = playlist_id
 482         if playlist_title:
 483             video_info['title'] = playlist_title
 484         if playlist_description:
 485             video_info['description'] = playlist_description
 486         return video_info
 487
 488     def _search_regex(self, pattern, string, name, default=_NO_DEFAULT, fatal=True, flags=0, group=None):
 489         """
 490         Perform a regex search on the given string, using a single or a list of
 491         patterns returning the first matching group.
 492         In case of failure return a default value or raise a WARNING or a
 493         RegexNotFoundError, depending on fatal, specifying the field name.
 494         """
 495         if isinstance(pattern, (str, compat_str, compiled_regex_type)):
 496             mobj = re.search(pattern, string, flags)
 497         else:
 498             for p in pattern:
 499                 mobj = re.search(p, string, flags)
 500                 if mobj:
 501                     break
 502
 503         if os.name != 'nt' and sys.stderr.isatty():
 504             _name = '\033[0;34m%s\033[0m' % name
 505         else:
 506             _name = name
 507
 508         if mobj:
 509             if group is None:
 510                 # return the first matching group
 511                 return next(g for g in mobj.groups() if g is not None)
 512             else:
 513                 return mobj.group(group)
 514         elif default is not _NO_DEFAULT:
 515             return default
 516         elif fatal:
 517             raise RegexNotFoundError('Unable to extract %s' % _name)
 518         else:
 519             self._downloader.report_warning('unable to extract %s; '
 520                                             'please report this issue on http://yt-dl.org/bug' % _name)
 521             return None
 522
 523     def _html_search_regex(self, pattern, string, name, default=_NO_DEFAULT, fatal=True, flags=0, group=None):
 524         """
 525         Like _search_regex, but strips HTML tags and unescapes entities.
 526         """
 527         res = self._search_regex(pattern, string, name, default, fatal, flags, group)
 528         if res:
 529             return clean_html(res).strip()
 530         else:
 531             return res
 532
 533     def _get_login_info(self):
 534         """
 535         Get the the login info as (username, password)
 536         It will look in the netrc file using the _NETRC_MACHINE value
 537         If there's no info available, return (None, None)
 538         """
 539         if self._downloader is None:
 540             return (None, None)
 541
 542         username = None
 543         password = None
 544         downloader_params = self._downloader.params
 545
 546         # Attempt to use provided username and password or .netrc data
 547         if downloader_params.get('username', None) is not None:
 548             username = downloader_params['username']
 549             password = downloader_params['password']
 550         elif downloader_params.get('usenetrc', False):
 551             try:
 552                 info = netrc.netrc().authenticators(self._NETRC_MACHINE)
 553                 if info is not None:
 554                     username = info[0]
 555                     password = info[2]
 556                 else:
 557                     raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
 558             except (IOError, netrc.NetrcParseError) as err:
 559                 self._downloader.report_warning('parsing .netrc: %s' % compat_str(err))
 560
 561         return (username, password)
 562
 563     def _get_tfa_info(self):
 564         """
 565         Get the two-factor authentication info
 566         TODO - asking the user will be required for sms/phone verify
 567         currently just uses the command line option
 568         If there's no info available, return None
 569         """
 570         if self._downloader is None:
 571             return None
 572         downloader_params = self._downloader.params
 573
 574         if downloader_params.get('twofactor', None) is not None:
 575             return downloader_params['twofactor']
 576
 577         return None
 578
 579     # Helper functions for extracting OpenGraph info
 580     @staticmethod
 581     def _og_regexes(prop):
 582         content_re = r'content=(?:"([^>]+?)"|\'([^>]+?)\')'
 583         property_re = r'(?:name|property)=[\'"]og:%s[\'"]' % re.escape(prop)
 584         template = r'<meta[^>]+?%s[^>]+?%s'
 585         return [
 586             template % (property_re, content_re),
 587             template % (content_re, property_re),
 588         ]
 589
 590     def _og_search_property(self, prop, html, name=None, **kargs):
 591         if name is None:
 592             name = 'OpenGraph %s' % prop
 593         escaped = self._search_regex(self._og_regexes(prop), html, name, flags=re.DOTALL, **kargs)
 594         if escaped is None:
 595             return None
 596         return unescapeHTML(escaped)
 597
 598     def _og_search_thumbnail(self, html, **kargs):
 599         return self._og_search_property('image', html, 'thumbnail url', fatal=False, **kargs)
 600
 601     def _og_search_description(self, html, **kargs):
 602         return self._og_search_property('description', html, fatal=False, **kargs)
 603
 604     def _og_search_title(self, html, **kargs):
 605         return self._og_search_property('title', html, **kargs)
 606
 607     def _og_search_video_url(self, html, name='video url', secure=True, **kargs):
 608         regexes = self._og_regexes('video') + self._og_regexes('video:url')
 609         if secure:
 610             regexes = self._og_regexes('video:secure_url') + regexes
 611         return self._html_search_regex(regexes, html, name, **kargs)
 612
 613     def _og_search_url(self, html, **kargs):
 614         return self._og_search_property('url', html, **kargs)
 615
 616     def _html_search_meta(self, name, html, display_name=None, fatal=False, **kwargs):
 617         if display_name is None:
 618             display_name = name
 619         return self._html_search_regex(
 620             r'''(?isx)<meta
 621                     (?=[^>]+(?:itemprop|name|property)=(["\']?)%s\1)
 622                     [^>]+?content=(["\'])(?P<content>.*?)\2''' % re.escape(name),
 623             html, display_name, fatal=fatal, group='content', **kwargs)
 624
 625     def _dc_search_uploader(self, html):
 626         return self._html_search_meta('dc.creator', html, 'uploader')
 627
 628     def _rta_search(self, html):
 629         # See http://www.rtalabel.org/index.php?content=howtofaq#single
 630         if re.search(r'(?ix)<meta\s+name="rating"\s+'
 631                      r'     content="RTA-5042-1996-1400-1577-RTA"',
 632                      html):
 633             return 18
 634         return 0
 635
 636     def _media_rating_search(self, html):
 637         # See http://www.tjg-designs.com/WP/metadata-code-examples-adding-metadata-to-your-web-pages/
 638         rating = self._html_search_meta('rating', html)
 639
 640         if not rating:
 641             return None
 642
 643         RATING_TABLE = {
 644             'safe for kids': 0,
 645             'general': 8,
 646             '14 years': 14,
 647             'mature': 17,
 648             'restricted': 19,
 649         }
 650         return RATING_TABLE.get(rating.lower(), None)
 651
 652     def _twitter_search_player(self, html):
 653         return self._html_search_meta('twitter:player', html,
 654                                       'twitter card player')
 655
 656     def _sort_formats(self, formats):
 657         if not formats:
 658             raise ExtractorError('No video formats found')
 659
 660         def _formats_key(f):
 661             # TODO remove the following workaround
 662             from ..utils import determine_ext
 663             if not f.get('ext') and 'url' in f:
 664                 f['ext'] = determine_ext(f['url'])
 665
 666             preference = f.get('preference')
 667             if preference is None:
 668                 proto = f.get('protocol')
 669                 if proto is None:
 670                     proto = compat_urllib_parse_urlparse(f.get('url', '')).scheme
 671
 672                 preference = 0 if proto in ['http', 'https'] else -0.1
 673                 if f.get('ext') in ['f4f', 'f4m']:  # Not yet supported
 674                     preference -= 0.5
 675
 676             if f.get('vcodec') == 'none':  # audio only
 677                 if self._downloader.params.get('prefer_free_formats'):
 678                     ORDER = ['aac', 'mp3', 'm4a', 'webm', 'ogg', 'opus']
 679                 else:
 680                     ORDER = ['webm', 'opus', 'ogg', 'mp3', 'aac', 'm4a']
 681                 ext_preference = 0
 682                 try:
 683                     audio_ext_preference = ORDER.index(f['ext'])
 684                 except ValueError:
 685                     audio_ext_preference = -1
 686             else:
 687                 if self._downloader.params.get('prefer_free_formats'):
 688                     ORDER = ['flv', 'mp4', 'webm']
 689                 else:
 690                     ORDER = ['webm', 'flv', 'mp4']
 691                 try:
 692                     ext_preference = ORDER.index(f['ext'])
 693                 except ValueError:
 694                     ext_preference = -1
 695                 audio_ext_preference = 0
 696
 697             return (
 698                 preference,
 699                 f.get('language_preference') if f.get('language_preference') is not None else -1,
 700                 f.get('quality') if f.get('quality') is not None else -1,
 701                 f.get('height') if f.get('height') is not None else -1,
 702                 f.get('width') if f.get('width') is not None else -1,
 703                 ext_preference,
 704                 f.get('tbr') if f.get('tbr') is not None else -1,
 705                 f.get('vbr') if f.get('vbr') is not None else -1,
 706                 f.get('abr') if f.get('abr') is not None else -1,
 707                 audio_ext_preference,
 708                 f.get('fps') if f.get('fps') is not None else -1,
 709                 f.get('filesize') if f.get('filesize') is not None else -1,
 710                 f.get('filesize_approx') if f.get('filesize_approx') is not None else -1,
 711                 f.get('source_preference') if f.get('source_preference') is not None else -1,
 712                 f.get('format_id'),
 713             )
 714         formats.sort(key=_formats_key)
 715
 716     def http_scheme(self):
 717         """ Either "http:" or "https:", depending on the user's preferences """
 718         return (
 719             'http:'
 720             if self._downloader.params.get('prefer_insecure', False)
 721             else 'https:')
 722
 723     def _proto_relative_url(self, url, scheme=None):
 724         if url is None:
 725             return url
 726         if url.startswith('//'):
 727             if scheme is None:
 728                 scheme = self.http_scheme()
 729             return scheme + url
 730         else:
 731             return url
 732
 733     def _sleep(self, timeout, video_id, msg_template=None):
 734         if msg_template is None:
 735             msg_template = '%(video_id)s: Waiting for %(timeout)s seconds'
 736         msg = msg_template % {'video_id': video_id, 'timeout': timeout}
 737         self.to_screen(msg)
 738         time.sleep(timeout)
 739
 740     def _extract_f4m_formats(self, manifest_url, video_id):
 741         manifest = self._download_xml(
 742             manifest_url, video_id, 'Downloading f4m manifest',
 743             'Unable to download f4m manifest')
 744
 745         formats = []
 746         manifest_version = '1.0'
 747         media_nodes = manifest.findall('{http://ns.adobe.com/f4m/1.0}media')
 748         if not media_nodes:
 749             manifest_version = '2.0'
 750             media_nodes = manifest.findall('{http://ns.adobe.com/f4m/2.0}media')
 751         for i, media_el in enumerate(media_nodes):
 752             if manifest_version == '2.0':
 753                 manifest_url = '/'.join(manifest_url.split('/')[:-1]) + '/' + media_el.attrib.get('href')
 754             tbr = int_or_none(media_el.attrib.get('bitrate'))
 755             format_id = 'f4m-%d' % (i if tbr is None else tbr)
 756             formats.append({
 757                 'format_id': format_id,
 758                 'url': manifest_url,
 759                 'ext': 'flv',
 760                 'tbr': tbr,
 761                 'width': int_or_none(media_el.attrib.get('width')),
 762                 'height': int_or_none(media_el.attrib.get('height')),
 763             })
 764         self._sort_formats(formats)
 765
 766         return formats
 767
 768     def _extract_m3u8_formats(self, m3u8_url, video_id, ext=None,
 769                               entry_protocol='m3u8', preference=None):
 770
 771         formats = [{
 772             'format_id': 'm3u8-meta',
 773             'url': m3u8_url,
 774             'ext': ext,
 775             'protocol': 'm3u8',
 776             'preference': -1,
 777             'resolution': 'multiple',
 778             'format_note': 'Quality selection URL',
 779         }]
 780
 781         format_url = lambda u: (
 782             u
 783             if re.match(r'^https?://', u)
 784             else compat_urlparse.urljoin(m3u8_url, u))
 785
 786         m3u8_doc = self._download_webpage(
 787             m3u8_url, video_id,
 788             note='Downloading m3u8 information',
 789             errnote='Failed to download m3u8 information')
 790         last_info = None
 791         kv_rex = re.compile(
 792             r'(?P<key>[a-zA-Z_-]+)=(?P<val>"[^"]+"|[^",]+)(?:,|$)')
 793         for line in m3u8_doc.splitlines():
 794             if line.startswith('#EXT-X-STREAM-INF:'):
 795                 last_info = {}
 796                 for m in kv_rex.finditer(line):
 797                     v = m.group('val')
 798                     if v.startswith('"'):
 799                         v = v[1:-1]
 800                     last_info[m.group('key')] = v
 801             elif line.startswith('#') or not line.strip():
 802                 continue
 803             else:
 804                 if last_info is None:
 805                     formats.append({'url': format_url(line)})
 806                     continue
 807                 tbr = int_or_none(last_info.get('BANDWIDTH'), scale=1000)
 808
 809                 f = {
 810                     'format_id': 'm3u8-%d' % (tbr if tbr else len(formats)),
 811                     'url': format_url(line.strip()),
 812                     'tbr': tbr,
 813                     'ext': ext,
 814                     'protocol': entry_protocol,
 815                     'preference': preference,
 816                 }
 817                 codecs = last_info.get('CODECS')
 818                 if codecs:
 819                     # TODO: looks like video codec is not always necessarily goes first
 820                     va_codecs = codecs.split(',')
 821                     if va_codecs[0]:
 822                         f['vcodec'] = va_codecs[0].partition('.')[0]
 823                     if len(va_codecs) > 1 and va_codecs[1]:
 824                         f['acodec'] = va_codecs[1].partition('.')[0]
 825                 resolution = last_info.get('RESOLUTION')
 826                 if resolution:
 827                     width_str, height_str = resolution.split('x')
 828                     f['width'] = int(width_str)
 829                     f['height'] = int(height_str)
 830                 formats.append(f)
 831                 last_info = {}
 832         self._sort_formats(formats)
 833         return formats
 834
 835     # TODO: improve extraction
 836     def _extract_smil_formats(self, smil_url, video_id):
 837         smil = self._download_xml(
 838             smil_url, video_id, 'Downloading SMIL file',
 839             'Unable to download SMIL file')
 840
 841         base = smil.find('./head/meta').get('base')
 842
 843         formats = []
 844         rtmp_count = 0
 845         for video in smil.findall('./body/switch/video'):
 846             src = video.get('src')
 847             if not src:
 848                 continue
 849             bitrate = int_or_none(video.get('system-bitrate') or video.get('systemBitrate'), 1000)
 850             width = int_or_none(video.get('width'))
 851             height = int_or_none(video.get('height'))
 852             proto = video.get('proto')
 853             if not proto:
 854                 if base:
 855                     if base.startswith('rtmp'):
 856                         proto = 'rtmp'
 857                     elif base.startswith('http'):
 858                         proto = 'http'
 859             ext = video.get('ext')
 860             if proto == 'm3u8':
 861                 formats.extend(self._extract_m3u8_formats(src, video_id, ext))
 862             elif proto == 'rtmp':
 863                 rtmp_count += 1
 864                 streamer = video.get('streamer') or base
 865                 formats.append({
 866                     'url': streamer,
 867                     'play_path': src,
 868                     'ext': 'flv',
 869                     'format_id': 'rtmp-%d' % (rtmp_count if bitrate is None else bitrate),
 870                     'tbr': bitrate,
 871                     'width': width,
 872                     'height': height,
 873                 })
 874         self._sort_formats(formats)
 875
 876         return formats
 877
 878     def _live_title(self, name):
 879         """ Generate the title for a live video """
 880         now = datetime.datetime.now()
 881         now_str = now.strftime("%Y-%m-%d %H:%M")
 882         return name + ' ' + now_str
 883
 884     def _int(self, v, name, fatal=False, **kwargs):
 885         res = int_or_none(v, **kwargs)
 886         if 'get_attr' in kwargs:
 887             print(getattr(v, kwargs['get_attr']))
 888         if res is None:
 889             msg = 'Failed to extract %s: Could not parse value %r' % (name, v)
 890             if fatal:
 891                 raise ExtractorError(msg)
 892             else:
 893                 self._downloader.report_warning(msg)
 894         return res
 895
 896     def _float(self, v, name, fatal=False, **kwargs):
 897         res = float_or_none(v, **kwargs)
 898         if res is None:
 899             msg = 'Failed to extract %s: Could not parse value %r' % (name, v)
 900             if fatal:
 901                 raise ExtractorError(msg)
 902             else:
 903                 self._downloader.report_warning(msg)
 904         return res
 905
 906     def _set_cookie(self, domain, name, value, expire_time=None):
 907         cookie = compat_cookiejar.Cookie(
 908             0, name, value, None, None, domain, None,
 909             None, '/', True, False, expire_time, '', None, None, None)
 910         self._downloader.cookiejar.set_cookie(cookie)
 911
 912     def get_testcases(self, include_onlymatching=False):
 913         t = getattr(self, '_TEST', None)
 914         if t:
 915             assert not hasattr(self, '_TESTS'), \
 916                 '%s has _TEST and _TESTS' % type(self).__name__
 917             tests = [t]
 918         else:
 919             tests = getattr(self, '_TESTS', [])
 920         for t in tests:
 921             if not include_onlymatching and t.get('only_matching', False):
 922                 continue
 923             t['name'] = type(self).__name__[:-len('IE')]
 924             yield t
 925
 926     def is_suitable(self, age_limit):
 927         """ Test whether the extractor is generally suitable for the given
 928         age limit (i.e. pornographic sites are not, all others usually are) """
 929
 930         any_restricted = False
 931         for tc in self.get_testcases(include_onlymatching=False):
 932             if 'playlist' in tc:
 933                 tc = tc['playlist'][0]
 934             is_restricted = age_restricted(
 935                 tc.get('info_dict', {}).get('age_limit'), age_limit)
 936             if not is_restricted:
 937                 return True
 938             any_restricted = any_restricted or is_restricted
 939         return not any_restricted
 940
 941
 942 class SearchInfoExtractor(InfoExtractor):
 943     """
 944     Base class for paged search queries extractors.
 945     They accept urls in the format _SEARCH_KEY(|all|[0-9]):{query}
 946     Instances should define _SEARCH_KEY and _MAX_RESULTS.
 947     """
 948
 949     @classmethod
 950     def _make_valid_url(cls):
 951         return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
 952
 953     @classmethod
 954     def suitable(cls, url):
 955         return re.match(cls._make_valid_url(), url) is not None
 956
 957     def _real_extract(self, query):
 958         mobj = re.match(self._make_valid_url(), query)
 959         if mobj is None:
 960             raise ExtractorError('Invalid search query "%s"' % query)
 961
 962         prefix = mobj.group('prefix')
 963         query = mobj.group('query')
 964         if prefix == '':
 965             return self._get_n_results(query, 1)
 966         elif prefix == 'all':
 967             return self._get_n_results(query, self._MAX_RESULTS)
 968         else:
 969             n = int(prefix)
 970             if n <= 0:
 971                 raise ExtractorError('invalid download number %s for query "%s"' % (n, query))
 972             elif n > self._MAX_RESULTS:
 973                 self._downloader.report_warning('%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
 974                 n = self._MAX_RESULTS
 975             return self._get_n_results(query, n)
 976
 977     def _get_n_results(self, query, n):
 978         """Get a specified number of results for a query"""
 979         raise NotImplementedError("This method must be implemented by subclasses")
 980
 981     @property
 982     def SEARCH_KEY(self):
 983         return self._SEARCH_KEY