_ 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_cookies,
  18     compat_getpass,
  19     compat_HTTPError,
  20     compat_http_client,
  21     compat_urllib_error,
  22     compat_urllib_parse,
  23     compat_urllib_parse_urlparse,
  24     compat_urllib_request,
  25     compat_urlparse,
  26     compat_str,
  27 )
  28 from ..utils import (
  29     NO_DEFAULT,
  30     age_restricted,
  31     bug_reports_message,
  32     clean_html,
  33     compiled_regex_type,
  34     determine_ext,
  35     ExtractorError,
  36     fix_xml_ampersands,
  37     float_or_none,
  38     int_or_none,
  39     RegexNotFoundError,
  40     sanitize_filename,
  41     unescapeHTML,
  42     unified_strdate,
  43     url_basename,
  44     xpath_text,
  45     xpath_with_ns,
  46 )
  47
  48
  49 class InfoExtractor(object):
  50     """Information Extractor class.
  51
  52     Information extractors are the classes that, given a URL, extract
  53     information about the video (or videos) the URL refers to. This
  54     information includes the real video URL, the video title, author and
  55     others. The information is stored in a dictionary which is then
  56     passed to the YoutubeDL. The YoutubeDL processes this
  57     information possibly downloading the video to the file system, among
  58     other possible outcomes.
  59
  60     The type field determines the type of the result.
  61     By far the most common value (and the default if _type is missing) is
  62     "video", which indicates a single video.
  63
  64     For a video, the dictionaries must include the following fields:
  65
  66     id:             Video identifier.
  67     title:          Video title, unescaped.
  68
  69     Additionally, it must contain either a formats entry or a url one:
  70
  71     formats:        A list of dictionaries for each format available, ordered
  72                     from worst to best quality.
  73
  74                     Potential fields:
  75                     * url        Mandatory. The URL of the video file
  76                     * ext        Will be calculated from URL if missing
  77                     * format     A human-readable description of the format
  78                                  ("mp4 container with h264/opus").
  79                                  Calculated from the format_id, width, height.
  80                                  and format_note fields if missing.
  81                     * format_id  A short description of the format
  82                                  ("mp4_h264_opus" or "19").
  83                                 Technically optional, but strongly recommended.
  84                     * format_note Additional info about the format
  85                                  ("3D" or "DASH video")
  86                     * width      Width of the video, if known
  87                     * height     Height of the video, if known
  88                     * resolution Textual description of width and height
  89                     * tbr        Average bitrate of audio and video in KBit/s
  90                     * abr        Average audio bitrate in KBit/s
  91                     * acodec     Name of the audio codec in use
  92                     * asr        Audio sampling rate in Hertz
  93                     * vbr        Average video bitrate in KBit/s
  94                     * fps        Frame rate
  95                     * vcodec     Name of the video codec in use
  96                     * container  Name of the container format
  97                     * filesize   The number of bytes, if known in advance
  98                     * filesize_approx  An estimate for the number of bytes
  99                     * player_url SWF Player URL (used for rtmpdump).
 100                     * protocol   The protocol that will be used for the actual
 101                                  download, lower-case.
 102                                  "http", "https", "rtsp", "rtmp", "rtmpe",
 103                                  "m3u8", or "m3u8_native".
 104                     * preference Order number of this format. If this field is
 105                                  present and not None, the formats get sorted
 106                                  by this field, regardless of all other values.
 107                                  -1 for default (order by other properties),
 108                                  -2 or smaller for less than default.
 109                                  < -1000 to hide the format (if there is
 110                                     another one which is strictly better)
 111                     * language_preference  Is this in the correct requested
 112                                  language?
 113                                  10 if it's what the URL is about,
 114                                  -1 for default (don't know),
 115                                  -10 otherwise, other values reserved for now.
 116                     * quality    Order number of the video quality of this
 117                                  format, irrespective of the file format.
 118                                  -1 for default (order by other properties),
 119                                  -2 or smaller for less than default.
 120                     * source_preference  Order number for this video source
 121                                   (quality takes higher priority)
 122                                  -1 for default (order by other properties),
 123                                  -2 or smaller for less than default.
 124                     * http_headers  A dictionary of additional HTTP headers
 125                                  to add to the request.
 126                     * stretched_ratio  If given and not 1, indicates that the
 127                                  video's pixels are not square.
 128                                  width : height ratio as float.
 129                     * no_resume  The server does not support resuming the
 130                                  (HTTP or RTMP) download. Boolean.
 131
 132     url:            Final video URL.
 133     ext:            Video filename extension.
 134     format:         The video format, defaults to ext (used for --get-format)
 135     player_url:     SWF Player URL (used for rtmpdump).
 136
 137     The following fields are optional:
 138
 139     alt_title:      A secondary title of the video.
 140     display_id      An alternative identifier for the video, not necessarily
 141                     unique, but available before title. Typically, id is
 142                     something like "4234987", title "Dancing naked mole rats",
 143                     and display_id "dancing-naked-mole-rats"
 144     thumbnails:     A list of dictionaries, with the following entries:
 145                         * "id" (optional, string) - Thumbnail format ID
 146                         * "url"
 147                         * "preference" (optional, int) - quality of the image
 148                         * "width" (optional, int)
 149                         * "height" (optional, int)
 150                         * "resolution" (optional, string "{width}x{height"},
 151                                         deprecated)
 152     thumbnail:      Full URL to a video thumbnail image.
 153     description:    Full video description.
 154     uploader:       Full name of the video uploader.
 155     creator:        The main artist who created the video.
 156     release_date:   The date (YYYYMMDD) when the video was released.
 157     timestamp:      UNIX timestamp of the moment the video became available.
 158     upload_date:    Video upload date (YYYYMMDD).
 159                     If not explicitly set, calculated from timestamp.
 160     uploader_id:    Nickname or id of the video uploader.
 161     location:       Physical location where the video was filmed.
 162     subtitles:      The available subtitles as a dictionary in the format
 163                     {language: subformats}. "subformats" is a list sorted from
 164                     lower to higher preference, each element is a dictionary
 165                     with the "ext" entry and one of:
 166                         * "data": The subtitles file contents
 167                         * "url": A URL pointing to the subtitles file
 168                     "ext" will be calculated from URL if missing
 169     automatic_captions: Like 'subtitles', used by the YoutubeIE for
 170                     automatically generated captions
 171     duration:       Length of the video in seconds, as an integer.
 172     view_count:     How many users have watched the video on the platform.
 173     like_count:     Number of positive ratings of the video
 174     dislike_count:  Number of negative ratings of the video
 175     average_rating: Average rating give by users, the scale used depends on the webpage
 176     comment_count:  Number of comments on the video
 177     comments:       A list of comments, each with one or more of the following
 178                     properties (all but one of text or html optional):
 179                         * "author" - human-readable name of the comment author
 180                         * "author_id" - user ID of the comment author
 181                         * "id" - Comment ID
 182                         * "html" - Comment as HTML
 183                         * "text" - Plain text of the comment
 184                         * "timestamp" - UNIX timestamp of comment
 185                         * "parent" - ID of the comment this one is replying to.
 186                                      Set to "root" to indicate that this is a
 187                                      comment to the original video.
 188     age_limit:      Age restriction for the video, as an integer (years)
 189     webpage_url:    The URL to the video webpage, if given to youtube-dl it
 190                     should allow to get the same result again. (It will be set
 191                     by YoutubeDL if it's missing)
 192     categories:     A list of categories that the video falls in, for example
 193                     ["Sports", "Berlin"]
 194     tags:           A list of tags assigned to the video, e.g. ["sweden", "pop music"]
 195     is_live:        True, False, or None (=unknown). Whether this video is a
 196                     live stream that goes on instead of a fixed-length video.
 197     start_time:     Time in seconds where the reproduction should start, as
 198                     specified in the URL.
 199     end_time:       Time in seconds where the reproduction should end, as
 200                     specified in the URL.
 201
 202     Unless mentioned otherwise, the fields should be Unicode strings.
 203
 204     Unless mentioned otherwise, None is equivalent to absence of information.
 205
 206
 207     _type "playlist" indicates multiple videos.
 208     There must be a key "entries", which is a list, an iterable, or a PagedList
 209     object, each element of which is a valid dictionary by this specification.
 210
 211     Additionally, playlists can have "title", "description" and "id" attributes
 212     with the same semantics as videos (see above).
 213
 214
 215     _type "multi_video" indicates that there are multiple videos that
 216     form a single show, for examples multiple acts of an opera or TV episode.
 217     It must have an entries key like a playlist and contain all the keys
 218     required for a video at the same time.
 219
 220
 221     _type "url" indicates that the video must be extracted from another
 222     location, possibly by a different extractor. Its only required key is:
 223     "url" - the next URL to extract.
 224     The key "ie_key" can be set to the class name (minus the trailing "IE",
 225     e.g. "Youtube") if the extractor class is known in advance.
 226     Additionally, the dictionary may have any properties of the resolved entity
 227     known in advance, for example "title" if the title of the referred video is
 228     known ahead of time.
 229
 230
 231     _type "url_transparent" entities have the same specification as "url", but
 232     indicate that the given additional information is more precise than the one
 233     associated with the resolved URL.
 234     This is useful when a site employs a video service that hosts the video and
 235     its technical metadata, but that video service does not embed a useful
 236     title, description etc.
 237
 238
 239     Subclasses of this one should re-define the _real_initialize() and
 240     _real_extract() methods and define a _VALID_URL regexp.
 241     Probably, they should also be added to the list of extractors.
 242
 243     Finally, the _WORKING attribute should be set to False for broken IEs
 244     in order to warn the users and skip the tests.
 245     """
 246
 247     _ready = False
 248     _downloader = None
 249     _WORKING = True
 250
 251     def __init__(self, downloader=None):
 252         """Constructor. Receives an optional downloader."""
 253         self._ready = False
 254         self.set_downloader(downloader)
 255
 256     @classmethod
 257     def suitable(cls, url):
 258         """Receives a URL and returns True if suitable for this IE."""
 259
 260         # This does not use has/getattr intentionally - we want to know whether
 261         # we have cached the regexp for *this* class, whereas getattr would also
 262         # match the superclass
 263         if '_VALID_URL_RE' not in cls.__dict__:
 264             cls._VALID_URL_RE = re.compile(cls._VALID_URL)
 265         return cls._VALID_URL_RE.match(url) is not None
 266
 267     @classmethod
 268     def _match_id(cls, url):
 269         if '_VALID_URL_RE' not in cls.__dict__:
 270             cls._VALID_URL_RE = re.compile(cls._VALID_URL)
 271         m = cls._VALID_URL_RE.match(url)
 272         assert m
 273         return m.group('id')
 274
 275     @classmethod
 276     def working(cls):
 277         """Getter method for _WORKING."""
 278         return cls._WORKING
 279
 280     def initialize(self):
 281         """Initializes an instance (authentication, etc)."""
 282         if not self._ready:
 283             self._real_initialize()
 284             self._ready = True
 285
 286     def extract(self, url):
 287         """Extracts URL information and returns it in list of dicts."""
 288         try:
 289             self.initialize()
 290             return self._real_extract(url)
 291         except ExtractorError:
 292             raise
 293         except compat_http_client.IncompleteRead as e:
 294             raise ExtractorError('A network error has occured.', cause=e, expected=True)
 295         except (KeyError, StopIteration) as e:
 296             raise ExtractorError('An extractor error has occured.', cause=e)
 297
 298     def set_downloader(self, downloader):
 299         """Sets the downloader for this IE."""
 300         self._downloader = downloader
 301
 302     def _real_initialize(self):
 303         """Real initialization process. Redefine in subclasses."""
 304         pass
 305
 306     def _real_extract(self, url):
 307         """Real extraction process. Redefine in subclasses."""
 308         pass
 309
 310     @classmethod
 311     def ie_key(cls):
 312         """A string for getting the InfoExtractor with get_info_extractor"""
 313         return cls.__name__[:-2]
 314
 315     @property
 316     def IE_NAME(self):
 317         return type(self).__name__[:-2]
 318
 319     def _request_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True):
 320         """ Returns the response handle """
 321         if note is None:
 322             self.report_download_webpage(video_id)
 323         elif note is not False:
 324             if video_id is None:
 325                 self.to_screen('%s' % (note,))
 326             else:
 327                 self.to_screen('%s: %s' % (video_id, note))
 328         try:
 329             return self._downloader.urlopen(url_or_request)
 330         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 331             if errnote is False:
 332                 return False
 333             if errnote is None:
 334                 errnote = 'Unable to download webpage'
 335             errmsg = '%s: %s' % (errnote, compat_str(err))
 336             if fatal:
 337                 raise ExtractorError(errmsg, sys.exc_info()[2], cause=err)
 338             else:
 339                 self._downloader.report_warning(errmsg)
 340                 return False
 341
 342     def _download_webpage_handle(self, url_or_request, video_id, note=None, errnote=None, fatal=True, encoding=None):
 343         """ Returns a tuple (page content as string, URL handle) """
 344         # Strip hashes from the URL (#1038)
 345         if isinstance(url_or_request, (compat_str, str)):
 346             url_or_request = url_or_request.partition('#')[0]
 347
 348         urlh = self._request_webpage(url_or_request, video_id, note, errnote, fatal)
 349         if urlh is False:
 350             assert not fatal
 351             return False
 352         content = self._webpage_read_content(urlh, url_or_request, video_id, note, errnote, fatal, encoding=encoding)
 353         return (content, urlh)
 354
 355     @staticmethod
 356     def _guess_encoding_from_content(content_type, webpage_bytes):
 357         m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
 358         if m:
 359             encoding = m.group(1)
 360         else:
 361             m = re.search(br'<meta[^>]+charset=[\'"]?([^\'")]+)[ /\'">]',
 362                           webpage_bytes[:1024])
 363             if m:
 364                 encoding = m.group(1).decode('ascii')
 365             elif webpage_bytes.startswith(b'\xff\xfe'):
 366                 encoding = 'utf-16'
 367             else:
 368                 encoding = 'utf-8'
 369
 370         return encoding
 371
 372     def _webpage_read_content(self, urlh, url_or_request, video_id, note=None, errnote=None, fatal=True, prefix=None, encoding=None):
 373         content_type = urlh.headers.get('Content-Type', '')
 374         webpage_bytes = urlh.read()
 375         if prefix is not None:
 376             webpage_bytes = prefix + webpage_bytes
 377         if not encoding:
 378             encoding = self._guess_encoding_from_content(content_type, webpage_bytes)
 379         if self._downloader.params.get('dump_intermediate_pages', False):
 380             try:
 381                 url = url_or_request.get_full_url()
 382             except AttributeError:
 383                 url = url_or_request
 384             self.to_screen('Dumping request to ' + url)
 385             dump = base64.b64encode(webpage_bytes).decode('ascii')
 386             self._downloader.to_screen(dump)
 387         if self._downloader.params.get('write_pages', False):
 388             try:
 389                 url = url_or_request.get_full_url()
 390             except AttributeError:
 391                 url = url_or_request
 392             basen = '%s_%s' % (video_id, url)
 393             if len(basen) > 240:
 394                 h = '___' + hashlib.md5(basen.encode('utf-8')).hexdigest()
 395                 basen = basen[:240 - len(h)] + h
 396             raw_filename = basen + '.dump'
 397             filename = sanitize_filename(raw_filename, restricted=True)
 398             self.to_screen('Saving request to ' + filename)
 399             # Working around MAX_PATH limitation on Windows (see
 400             # http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx)
 401             if os.name == 'nt':
 402                 absfilepath = os.path.abspath(filename)
 403                 if len(absfilepath) > 259:
 404                     filename = '\\\\?\\' + absfilepath
 405             with open(filename, 'wb') as outf:
 406                 outf.write(webpage_bytes)
 407
 408         try:
 409             content = webpage_bytes.decode(encoding, 'replace')
 410         except LookupError:
 411             content = webpage_bytes.decode('utf-8', 'replace')
 412
 413         if ('<title>Access to this site is blocked</title>' in content and
 414                 'Websense' in content[:512]):
 415             msg = 'Access to this webpage has been blocked by Websense filtering software in your network.'
 416             blocked_iframe = self._html_search_regex(
 417                 r'<iframe src="([^"]+)"', content,
 418                 'Websense information URL', default=None)
 419             if blocked_iframe:
 420                 msg += ' Visit %s for more details' % blocked_iframe
 421             raise ExtractorError(msg, expected=True)
 422         if '<title>The URL you requested has been blocked</title>' in content[:512]:
 423             msg = (
 424                 'Access to this webpage has been blocked by Indian censorship. '
 425                 'Use a VPN or proxy server (with --proxy) to route around it.')
 426             block_msg = self._html_search_regex(
 427                 r'</h1><p>(.*?)</p>',
 428                 content, 'block message', default=None)
 429             if block_msg:
 430                 msg += ' (Message: "%s")' % block_msg.replace('\n', ' ')
 431             raise ExtractorError(msg, expected=True)
 432
 433         return content
 434
 435     def _download_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True, tries=1, timeout=5, encoding=None):
 436         """ Returns the data of the page as a string """
 437         success = False
 438         try_count = 0
 439         while success is False:
 440             try:
 441                 res = self._download_webpage_handle(url_or_request, video_id, note, errnote, fatal, encoding=encoding)
 442                 success = True
 443             except compat_http_client.IncompleteRead as e:
 444                 try_count += 1
 445                 if try_count >= tries:
 446                     raise e
 447                 self._sleep(timeout, video_id)
 448         if res is False:
 449             return res
 450         else:
 451             content, _ = res
 452             return content
 453
 454     def _download_xml(self, url_or_request, video_id,
 455                       note='Downloading XML', errnote='Unable to download XML',
 456                       transform_source=None, fatal=True, encoding=None):
 457         """Return the xml as an xml.etree.ElementTree.Element"""
 458         xml_string = self._download_webpage(
 459             url_or_request, video_id, note, errnote, fatal=fatal, encoding=encoding)
 460         if xml_string is False:
 461             return xml_string
 462         if transform_source:
 463             xml_string = transform_source(xml_string)
 464         return xml.etree.ElementTree.fromstring(xml_string.encode('utf-8'))
 465
 466     def _download_json(self, url_or_request, video_id,
 467                        note='Downloading JSON metadata',
 468                        errnote='Unable to download JSON metadata',
 469                        transform_source=None,
 470                        fatal=True, encoding=None):
 471         json_string = self._download_webpage(
 472             url_or_request, video_id, note, errnote, fatal=fatal,
 473             encoding=encoding)
 474         if (not fatal) and json_string is False:
 475             return None
 476         return self._parse_json(
 477             json_string, video_id, transform_source=transform_source, fatal=fatal)
 478
 479     def _parse_json(self, json_string, video_id, transform_source=None, fatal=True):
 480         if transform_source:
 481             json_string = transform_source(json_string)
 482         try:
 483             return json.loads(json_string)
 484         except ValueError as ve:
 485             errmsg = '%s: Failed to parse JSON ' % video_id
 486             if fatal:
 487                 raise ExtractorError(errmsg, cause=ve)
 488             else:
 489                 self.report_warning(errmsg + str(ve))
 490
 491     def report_warning(self, msg, video_id=None):
 492         idstr = '' if video_id is None else '%s: ' % video_id
 493         self._downloader.report_warning(
 494             '[%s] %s%s' % (self.IE_NAME, idstr, msg))
 495
 496     def to_screen(self, msg):
 497         """Print msg to screen, prefixing it with '[ie_name]'"""
 498         self._downloader.to_screen('[%s] %s' % (self.IE_NAME, msg))
 499
 500     def report_extraction(self, id_or_name):
 501         """Report information extraction."""
 502         self.to_screen('%s: Extracting information' % id_or_name)
 503
 504     def report_download_webpage(self, video_id):
 505         """Report webpage download."""
 506         self.to_screen('%s: Downloading webpage' % video_id)
 507
 508     def report_age_confirmation(self):
 509         """Report attempt to confirm age."""
 510         self.to_screen('Confirming age')
 511
 512     def report_login(self):
 513         """Report attempt to log in."""
 514         self.to_screen('Logging in')
 515
 516     @staticmethod
 517     def raise_login_required(msg='This video is only available for registered users'):
 518         raise ExtractorError(
 519             '%s. Use --username and --password or --netrc to provide account credentials.' % msg,
 520             expected=True)
 521
 522     @staticmethod
 523     def raise_geo_restricted(msg='This video is not available from your location due to geo restriction'):
 524         raise ExtractorError(
 525             '%s. You might want to use --proxy to workaround.' % msg,
 526             expected=True)
 527
 528     # Methods for following #608
 529     @staticmethod
 530     def url_result(url, ie=None, video_id=None, video_title=None):
 531         """Returns a URL that points to a page that should be processed"""
 532         # TODO: ie should be the class used for getting the info
 533         video_info = {'_type': 'url',
 534                       'url': url,
 535                       'ie_key': ie}
 536         if video_id is not None:
 537             video_info['id'] = video_id
 538         if video_title is not None:
 539             video_info['title'] = video_title
 540         return video_info
 541
 542     @staticmethod
 543     def playlist_result(entries, playlist_id=None, playlist_title=None, playlist_description=None):
 544         """Returns a playlist"""
 545         video_info = {'_type': 'playlist',
 546                       'entries': entries}
 547         if playlist_id:
 548             video_info['id'] = playlist_id
 549         if playlist_title:
 550             video_info['title'] = playlist_title
 551         if playlist_description:
 552             video_info['description'] = playlist_description
 553         return video_info
 554
 555     def _search_regex(self, pattern, string, name, default=NO_DEFAULT, fatal=True, flags=0, group=None):
 556         """
 557         Perform a regex search on the given string, using a single or a list of
 558         patterns returning the first matching group.
 559         In case of failure return a default value or raise a WARNING or a
 560         RegexNotFoundError, depending on fatal, specifying the field name.
 561         """
 562         if isinstance(pattern, (str, compat_str, compiled_regex_type)):
 563             mobj = re.search(pattern, string, flags)
 564         else:
 565             for p in pattern:
 566                 mobj = re.search(p, string, flags)
 567                 if mobj:
 568                     break
 569
 570         if not self._downloader.params.get('no_color') and os.name != 'nt' and sys.stderr.isatty():
 571             _name = '\033[0;34m%s\033[0m' % name
 572         else:
 573             _name = name
 574
 575         if mobj:
 576             if group is None:
 577                 # return the first matching group
 578                 return next(g for g in mobj.groups() if g is not None)
 579             else:
 580                 return mobj.group(group)
 581         elif default is not NO_DEFAULT:
 582             return default
 583         elif fatal:
 584             raise RegexNotFoundError('Unable to extract %s' % _name)
 585         else:
 586             self._downloader.report_warning('unable to extract %s' % _name + bug_reports_message())
 587             return None
 588
 589     def _html_search_regex(self, pattern, string, name, default=NO_DEFAULT, fatal=True, flags=0, group=None):
 590         """
 591         Like _search_regex, but strips HTML tags and unescapes entities.
 592         """
 593         res = self._search_regex(pattern, string, name, default, fatal, flags, group)
 594         if res:
 595             return clean_html(res).strip()
 596         else:
 597             return res
 598
 599     def _get_login_info(self):
 600         """
 601         Get the login info as (username, password)
 602         It will look in the netrc file using the _NETRC_MACHINE value
 603         If there's no info available, return (None, None)
 604         """
 605         if self._downloader is None:
 606             return (None, None)
 607
 608         username = None
 609         password = None
 610         downloader_params = self._downloader.params
 611
 612         # Attempt to use provided username and password or .netrc data
 613         if downloader_params.get('username', None) is not None:
 614             username = downloader_params['username']
 615             password = downloader_params['password']
 616         elif downloader_params.get('usenetrc', False):
 617             try:
 618                 info = netrc.netrc().authenticators(self._NETRC_MACHINE)
 619                 if info is not None:
 620                     username = info[0]
 621                     password = info[2]
 622                 else:
 623                     raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
 624             except (IOError, netrc.NetrcParseError) as err:
 625                 self._downloader.report_warning('parsing .netrc: %s' % compat_str(err))
 626
 627         return (username, password)
 628
 629     def _get_tfa_info(self, note='two-factor verification code'):
 630         """
 631         Get the two-factor authentication info
 632         TODO - asking the user will be required for sms/phone verify
 633         currently just uses the command line option
 634         If there's no info available, return None
 635         """
 636         if self._downloader is None:
 637             return None
 638         downloader_params = self._downloader.params
 639
 640         if downloader_params.get('twofactor', None) is not None:
 641             return downloader_params['twofactor']
 642
 643         return compat_getpass('Type %s and press [Return]: ' % note)
 644
 645     # Helper functions for extracting OpenGraph info
 646     @staticmethod
 647     def _og_regexes(prop):
 648         content_re = r'content=(?:"([^>]+?)"|\'([^>]+?)\')'
 649         property_re = r'(?:name|property)=[\'"]?og:%s[\'"]?' % re.escape(prop)
 650         template = r'<meta[^>]+?%s[^>]+?%s'
 651         return [
 652             template % (property_re, content_re),
 653             template % (content_re, property_re),
 654         ]
 655
 656     @staticmethod
 657     def _meta_regex(prop):
 658         return r'''(?isx)<meta
 659                     (?=[^>]+(?:itemprop|name|property|id|http-equiv)=(["\']?)%s\1)
 660                     [^>]+?content=(["\'])(?P<content>.*?)\2''' % re.escape(prop)
 661
 662     def _og_search_property(self, prop, html, name=None, **kargs):
 663         if name is None:
 664             name = 'OpenGraph %s' % prop
 665         escaped = self._search_regex(self._og_regexes(prop), html, name, flags=re.DOTALL, **kargs)
 666         if escaped is None:
 667             return None
 668         return unescapeHTML(escaped)
 669
 670     def _og_search_thumbnail(self, html, **kargs):
 671         return self._og_search_property('image', html, 'thumbnail URL', fatal=False, **kargs)
 672
 673     def _og_search_description(self, html, **kargs):
 674         return self._og_search_property('description', html, fatal=False, **kargs)
 675
 676     def _og_search_title(self, html, **kargs):
 677         return self._og_search_property('title', html, **kargs)
 678
 679     def _og_search_video_url(self, html, name='video url', secure=True, **kargs):
 680         regexes = self._og_regexes('video') + self._og_regexes('video:url')
 681         if secure:
 682             regexes = self._og_regexes('video:secure_url') + regexes
 683         return self._html_search_regex(regexes, html, name, **kargs)
 684
 685     def _og_search_url(self, html, **kargs):
 686         return self._og_search_property('url', html, **kargs)
 687
 688     def _html_search_meta(self, name, html, display_name=None, fatal=False, **kwargs):
 689         if display_name is None:
 690             display_name = name
 691         return self._html_search_regex(
 692             self._meta_regex(name),
 693             html, display_name, fatal=fatal, group='content', **kwargs)
 694
 695     def _dc_search_uploader(self, html):
 696         return self._html_search_meta('dc.creator', html, 'uploader')
 697
 698     def _rta_search(self, html):
 699         # See http://www.rtalabel.org/index.php?content=howtofaq#single
 700         if re.search(r'(?ix)<meta\s+name="rating"\s+'
 701                      r'     content="RTA-5042-1996-1400-1577-RTA"',
 702                      html):
 703             return 18
 704         return 0
 705
 706     def _media_rating_search(self, html):
 707         # See http://www.tjg-designs.com/WP/metadata-code-examples-adding-metadata-to-your-web-pages/
 708         rating = self._html_search_meta('rating', html)
 709
 710         if not rating:
 711             return None
 712
 713         RATING_TABLE = {
 714             'safe for kids': 0,
 715             'general': 8,
 716             '14 years': 14,
 717             'mature': 17,
 718             'restricted': 19,
 719         }
 720         return RATING_TABLE.get(rating.lower(), None)
 721
 722     def _family_friendly_search(self, html):
 723         # See http://schema.org/VideoObject
 724         family_friendly = self._html_search_meta('isFamilyFriendly', html)
 725
 726         if not family_friendly:
 727             return None
 728
 729         RATING_TABLE = {
 730             '1': 0,
 731             'true': 0,
 732             '0': 18,
 733             'false': 18,
 734         }
 735         return RATING_TABLE.get(family_friendly.lower(), None)
 736
 737     def _twitter_search_player(self, html):
 738         return self._html_search_meta('twitter:player', html,
 739                                       'twitter card player')
 740
 741     @staticmethod
 742     def _hidden_inputs(html):
 743         html = re.sub(r'<!--(?:(?!<!--).)*-->', '', html)
 744         hidden_inputs = {}
 745         for input in re.findall(r'(?i)<input([^>]+)>', html):
 746             if not re.search(r'type=(["\'])(?:hidden|submit)\1', input):
 747                 continue
 748             name = re.search(r'name=(["\'])(?P<value>.+?)\1', input)
 749             if not name:
 750                 continue
 751             value = re.search(r'value=(["\'])(?P<value>.*?)\1', input)
 752             if not value:
 753                 continue
 754             hidden_inputs[name.group('value')] = value.group('value')
 755         return hidden_inputs
 756
 757     def _form_hidden_inputs(self, form_id, html):
 758         form = self._search_regex(
 759             r'(?is)<form[^>]+?id=(["\'])%s\1[^>]*>(?P<form>.+?)</form>' % form_id,
 760             html, '%s form' % form_id, group='form')
 761         return self._hidden_inputs(form)
 762
 763     def _sort_formats(self, formats, field_preference=None):
 764         if not formats:
 765             raise ExtractorError('No video formats found')
 766
 767         def _formats_key(f):
 768             # TODO remove the following workaround
 769             from ..utils import determine_ext
 770             if not f.get('ext') and 'url' in f:
 771                 f['ext'] = determine_ext(f['url'])
 772
 773             if isinstance(field_preference, (list, tuple)):
 774                 return tuple(f.get(field) if f.get(field) is not None else -1 for field in field_preference)
 775
 776             preference = f.get('preference')
 777             if preference is None:
 778                 proto = f.get('protocol')
 779                 if proto is None:
 780                     proto = compat_urllib_parse_urlparse(f.get('url', '')).scheme
 781
 782                 preference = 0 if proto in ['http', 'https'] else -0.1
 783                 if f.get('ext') in ['f4f', 'f4m']:  # Not yet supported
 784                     preference -= 0.5
 785
 786             if f.get('vcodec') == 'none':  # audio only
 787                 if self._downloader.params.get('prefer_free_formats'):
 788                     ORDER = ['aac', 'mp3', 'm4a', 'webm', 'ogg', 'opus']
 789                 else:
 790                     ORDER = ['webm', 'opus', 'ogg', 'mp3', 'aac', 'm4a']
 791                 ext_preference = 0
 792                 try:
 793                     audio_ext_preference = ORDER.index(f['ext'])
 794                 except ValueError:
 795                     audio_ext_preference = -1
 796             else:
 797                 if self._downloader.params.get('prefer_free_formats'):
 798                     ORDER = ['flv', 'mp4', 'webm']
 799                 else:
 800                     ORDER = ['webm', 'flv', 'mp4']
 801                 try:
 802                     ext_preference = ORDER.index(f['ext'])
 803                 except ValueError:
 804                     ext_preference = -1
 805                 audio_ext_preference = 0
 806
 807             return (
 808                 preference,
 809                 f.get('language_preference') if f.get('language_preference') is not None else -1,
 810                 f.get('quality') if f.get('quality') is not None else -1,
 811                 f.get('tbr') if f.get('tbr') is not None else -1,
 812                 f.get('filesize') if f.get('filesize') is not None else -1,
 813                 f.get('vbr') if f.get('vbr') is not None else -1,
 814                 f.get('height') if f.get('height') is not None else -1,
 815                 f.get('width') if f.get('width') is not None else -1,
 816                 ext_preference,
 817                 f.get('abr') if f.get('abr') is not None else -1,
 818                 audio_ext_preference,
 819                 f.get('fps') if f.get('fps') is not None else -1,
 820                 f.get('filesize_approx') if f.get('filesize_approx') is not None else -1,
 821                 f.get('source_preference') if f.get('source_preference') is not None else -1,
 822                 f.get('format_id') if f.get('format_id') is not None else '',
 823             )
 824         formats.sort(key=_formats_key)
 825
 826     def _check_formats(self, formats, video_id):
 827         if formats:
 828             formats[:] = filter(
 829                 lambda f: self._is_valid_url(
 830                     f['url'], video_id,
 831                     item='%s video format' % f.get('format_id') if f.get('format_id') else 'video'),
 832                 formats)
 833
 834     def _is_valid_url(self, url, video_id, item='video'):
 835         url = self._proto_relative_url(url, scheme='http:')
 836         # For now assume non HTTP(S) URLs always valid
 837         if not (url.startswith('http://') or url.startswith('https://')):
 838             return True
 839         try:
 840             self._request_webpage(url, video_id, 'Checking %s URL' % item)
 841             return True
 842         except ExtractorError as e:
 843             if isinstance(e.cause, compat_HTTPError):
 844                 self.to_screen(
 845                     '%s: %s URL is invalid, skipping' % (video_id, item))
 846                 return False
 847             raise
 848
 849     def http_scheme(self):
 850         """ Either "http:" or "https:", depending on the user's preferences """
 851         return (
 852             'http:'
 853             if self._downloader.params.get('prefer_insecure', False)
 854             else 'https:')
 855
 856     def _proto_relative_url(self, url, scheme=None):
 857         if url is None:
 858             return url
 859         if url.startswith('//'):
 860             if scheme is None:
 861                 scheme = self.http_scheme()
 862             return scheme + url
 863         else:
 864             return url
 865
 866     def _sleep(self, timeout, video_id, msg_template=None):
 867         if msg_template is None:
 868             msg_template = '%(video_id)s: Waiting for %(timeout)s seconds'
 869         msg = msg_template % {'video_id': video_id, 'timeout': timeout}
 870         self.to_screen(msg)
 871         time.sleep(timeout)
 872
 873     def _extract_f4m_formats(self, manifest_url, video_id, preference=None, f4m_id=None,
 874                              transform_source=lambda s: fix_xml_ampersands(s).strip(),
 875                              fatal=True):
 876         manifest = self._download_xml(
 877             manifest_url, video_id, 'Downloading f4m manifest',
 878             'Unable to download f4m manifest',
 879             # Some manifests may be malformed, e.g. prosiebensat1 generated manifests
 880             # (see https://github.com/rg3/youtube-dl/issues/6215#issuecomment-121704244)
 881             transform_source=transform_source,
 882             fatal=fatal)
 883
 884         if manifest is False:
 885             return manifest
 886
 887         formats = []
 888         manifest_version = '1.0'
 889         media_nodes = manifest.findall('{http://ns.adobe.com/f4m/1.0}media')
 890         if not media_nodes:
 891             manifest_version = '2.0'
 892             media_nodes = manifest.findall('{http://ns.adobe.com/f4m/2.0}media')
 893         for i, media_el in enumerate(media_nodes):
 894             if manifest_version == '2.0':
 895                 media_url = media_el.attrib.get('href') or media_el.attrib.get('url')
 896                 if not media_url:
 897                     continue
 898                 manifest_url = (
 899                     media_url if media_url.startswith('http://') or media_url.startswith('https://')
 900                     else ('/'.join(manifest_url.split('/')[:-1]) + '/' + media_url))
 901                 # If media_url is itself a f4m manifest do the recursive extraction
 902                 # since bitrates in parent manifest (this one) and media_url manifest
 903                 # may differ leading to inability to resolve the format by requested
 904                 # bitrate in f4m downloader
 905                 if determine_ext(manifest_url) == 'f4m':
 906                     f4m_formats = self._extract_f4m_formats(
 907                         manifest_url, video_id, preference, f4m_id, fatal=fatal)
 908                     if f4m_formats:
 909                         formats.extend(f4m_formats)
 910                     continue
 911             tbr = int_or_none(media_el.attrib.get('bitrate'))
 912             formats.append({
 913                 'format_id': '-'.join(filter(None, [f4m_id, compat_str(i if tbr is None else tbr)])),
 914                 'url': manifest_url,
 915                 'ext': 'flv',
 916                 'tbr': tbr,
 917                 'width': int_or_none(media_el.attrib.get('width')),
 918                 'height': int_or_none(media_el.attrib.get('height')),
 919                 'preference': preference,
 920             })
 921         self._sort_formats(formats)
 922
 923         return formats
 924
 925     def _extract_m3u8_formats(self, m3u8_url, video_id, ext=None,
 926                               entry_protocol='m3u8', preference=None,
 927                               m3u8_id=None, note=None, errnote=None,
 928                               fatal=True):
 929
 930         formats = [{
 931             'format_id': '-'.join(filter(None, [m3u8_id, 'meta'])),
 932             'url': m3u8_url,
 933             'ext': ext,
 934             'protocol': 'm3u8',
 935             'preference': preference - 1 if preference else -1,
 936             'resolution': 'multiple',
 937             'format_note': 'Quality selection URL',
 938         }]
 939
 940         format_url = lambda u: (
 941             u
 942             if re.match(r'^https?://', u)
 943             else compat_urlparse.urljoin(m3u8_url, u))
 944
 945         m3u8_doc = self._download_webpage(
 946             m3u8_url, video_id,
 947             note=note or 'Downloading m3u8 information',
 948             errnote=errnote or 'Failed to download m3u8 information',
 949             fatal=fatal)
 950         if m3u8_doc is False:
 951             return m3u8_doc
 952         last_info = None
 953         last_media = None
 954         kv_rex = re.compile(
 955             r'(?P<key>[a-zA-Z_-]+)=(?P<val>"[^"]+"|[^",]+)(?:,|$)')
 956         for line in m3u8_doc.splitlines():
 957             if line.startswith('#EXT-X-STREAM-INF:'):
 958                 last_info = {}
 959                 for m in kv_rex.finditer(line):
 960                     v = m.group('val')
 961                     if v.startswith('"'):
 962                         v = v[1:-1]
 963                     last_info[m.group('key')] = v
 964             elif line.startswith('#EXT-X-MEDIA:'):
 965                 last_media = {}
 966                 for m in kv_rex.finditer(line):
 967                     v = m.group('val')
 968                     if v.startswith('"'):
 969                         v = v[1:-1]
 970                     last_media[m.group('key')] = v
 971             elif line.startswith('#') or not line.strip():
 972                 continue
 973             else:
 974                 if last_info is None:
 975                     formats.append({'url': format_url(line)})
 976                     continue
 977                 tbr = int_or_none(last_info.get('BANDWIDTH'), scale=1000)
 978                 format_id = []
 979                 if m3u8_id:
 980                     format_id.append(m3u8_id)
 981                 last_media_name = last_media.get('NAME') if last_media and last_media.get('TYPE') != 'SUBTITLES' else None
 982                 format_id.append(last_media_name if last_media_name else '%d' % (tbr if tbr else len(formats)))
 983                 f = {
 984                     'format_id': '-'.join(format_id),
 985                     'url': format_url(line.strip()),
 986                     'tbr': tbr,
 987                     'ext': ext,
 988                     'protocol': entry_protocol,
 989                     'preference': preference,
 990                 }
 991                 codecs = last_info.get('CODECS')
 992                 if codecs:
 993                     # TODO: looks like video codec is not always necessarily goes first
 994                     va_codecs = codecs.split(',')
 995                     if va_codecs[0]:
 996                         f['vcodec'] = va_codecs[0].partition('.')[0]
 997                     if len(va_codecs) > 1 and va_codecs[1]:
 998                         f['acodec'] = va_codecs[1].partition('.')[0]
 999                 resolution = last_info.get('RESOLUTION')
1000                 if resolution:
1001                     width_str, height_str = resolution.split('x')
1002                     f['width'] = int(width_str)
1003                     f['height'] = int(height_str)
1004                 if last_media is not None:
1005                     f['m3u8_media'] = last_media
1006                     last_media = None
1007                 formats.append(f)
1008                 last_info = {}
1009         self._sort_formats(formats)
1010         return formats
1011
1012     @staticmethod
1013     def _xpath_ns(path, namespace=None):
1014         if not namespace:
1015             return path
1016         out = []
1017         for c in path.split('/'):
1018             if not c or c == '.':
1019                 out.append(c)
1020             else:
1021                 out.append('{%s}%s' % (namespace, c))
1022         return '/'.join(out)
1023
1024     def _extract_smil_formats(self, smil_url, video_id, fatal=True, f4m_params=None):
1025         smil = self._download_smil(smil_url, video_id, fatal=fatal)
1026
1027         if smil is False:
1028             assert not fatal
1029             return []
1030
1031         namespace = self._parse_smil_namespace(smil)
1032
1033         return self._parse_smil_formats(
1034             smil, smil_url, video_id, namespace=namespace, f4m_params=f4m_params)
1035
1036     def _extract_smil_info(self, smil_url, video_id, fatal=True, f4m_params=None):
1037         smil = self._download_smil(smil_url, video_id, fatal=fatal)
1038         if smil is False:
1039             return {}
1040         return self._parse_smil(smil, smil_url, video_id, f4m_params=f4m_params)
1041
1042     def _download_smil(self, smil_url, video_id, fatal=True):
1043         return self._download_xml(
1044             smil_url, video_id, 'Downloading SMIL file',
1045             'Unable to download SMIL file', fatal=fatal)
1046
1047     def _parse_smil(self, smil, smil_url, video_id, f4m_params=None):
1048         namespace = self._parse_smil_namespace(smil)
1049
1050         formats = self._parse_smil_formats(
1051             smil, smil_url, video_id, namespace=namespace, f4m_params=f4m_params)
1052         subtitles = self._parse_smil_subtitles(smil, namespace=namespace)
1053
1054         video_id = os.path.splitext(url_basename(smil_url))[0]
1055         title = None
1056         description = None
1057         upload_date = None
1058         for meta in smil.findall(self._xpath_ns('./head/meta', namespace)):
1059             name = meta.attrib.get('name')
1060             content = meta.attrib.get('content')
1061             if not name or not content:
1062                 continue
1063             if not title and name == 'title':
1064                 title = content
1065             elif not description and name in ('description', 'abstract'):
1066                 description = content
1067             elif not upload_date and name == 'date':
1068                 upload_date = unified_strdate(content)
1069
1070         thumbnails = [{
1071             'id': image.get('type'),
1072             'url': image.get('src'),
1073             'width': int_or_none(image.get('width')),
1074             'height': int_or_none(image.get('height')),
1075         } for image in smil.findall(self._xpath_ns('.//image', namespace)) if image.get('src')]
1076
1077         return {
1078             'id': video_id,
1079             'title': title or video_id,
1080             'description': description,
1081             'upload_date': upload_date,
1082             'thumbnails': thumbnails,
1083             'formats': formats,
1084             'subtitles': subtitles,
1085         }
1086
1087     def _parse_smil_namespace(self, smil):
1088         return self._search_regex(
1089             r'(?i)^{([^}]+)?}smil$', smil.tag, 'namespace', default=None)
1090
1091     def _parse_smil_formats(self, smil, smil_url, video_id, namespace=None, f4m_params=None, transform_rtmp_url=None):
1092         base = smil_url
1093         for meta in smil.findall(self._xpath_ns('./head/meta', namespace)):
1094             b = meta.get('base') or meta.get('httpBase')
1095             if b:
1096                 base = b
1097                 break
1098
1099         formats = []
1100         rtmp_count = 0
1101         http_count = 0
1102
1103         videos = smil.findall(self._xpath_ns('.//video', namespace))
1104         for video in videos:
1105             src = video.get('src')
1106             if not src:
1107                 continue
1108
1109             bitrate = float_or_none(video.get('system-bitrate') or video.get('systemBitrate'), 1000)
1110             filesize = int_or_none(video.get('size') or video.get('fileSize'))
1111             width = int_or_none(video.get('width'))
1112             height = int_or_none(video.get('height'))
1113             proto = video.get('proto')
1114             ext = video.get('ext')
1115             src_ext = determine_ext(src)
1116             streamer = video.get('streamer') or base
1117
1118             if proto == 'rtmp' or streamer.startswith('rtmp'):
1119                 rtmp_count += 1
1120                 formats.append({
1121                     'url': streamer,
1122                     'play_path': src,
1123                     'ext': 'flv',
1124                     'format_id': 'rtmp-%d' % (rtmp_count if bitrate is None else bitrate),
1125                     'tbr': bitrate,
1126                     'filesize': filesize,
1127                     'width': width,
1128                     'height': height,
1129                 })
1130                 if transform_rtmp_url:
1131                     streamer, src = transform_rtmp_url(streamer, src)
1132                     formats[-1].update({
1133                         'url': streamer,
1134                         'play_path': src,
1135                     })
1136                 continue
1137
1138             src_url = src if src.startswith('http') else compat_urlparse.urljoin(base, src)
1139
1140             if proto == 'm3u8' or src_ext == 'm3u8':
1141                 m3u8_formats = self._extract_m3u8_formats(
1142                     src_url, video_id, ext or 'mp4', m3u8_id='hls', fatal=False)
1143                 if m3u8_formats:
1144                     formats.extend(m3u8_formats)
1145                 continue
1146
1147             if src_ext == 'f4m':
1148                 f4m_url = src_url
1149                 if not f4m_params:
1150                     f4m_params = {
1151                         'hdcore': '3.2.0',
1152                         'plugin': 'flowplayer-3.2.0.1',
1153                     }
1154                 f4m_url += '&' if '?' in f4m_url else '?'
1155                 f4m_url += compat_urllib_parse.urlencode(f4m_params)
1156                 f4m_formats = self._extract_f4m_formats(f4m_url, video_id, f4m_id='hds', fatal=False)
1157                 if f4m_formats:
1158                     formats.extend(f4m_formats)
1159                 continue
1160
1161             if src_url.startswith('http') and self._is_valid_url(src, video_id):
1162                 http_count += 1
1163                 formats.append({
1164                     'url': src_url,
1165                     'ext': ext or src_ext or 'flv',
1166                     'format_id': 'http-%d' % (bitrate or http_count),
1167                     'tbr': bitrate,
1168                     'filesize': filesize,
1169                     'width': width,
1170                     'height': height,
1171                 })
1172                 continue
1173
1174         self._sort_formats(formats)
1175
1176         return formats
1177
1178     def _parse_smil_subtitles(self, smil, namespace=None, subtitles_lang='en'):
1179         subtitles = {}
1180         for num, textstream in enumerate(smil.findall(self._xpath_ns('.//textstream', namespace))):
1181             src = textstream.get('src')
1182             if not src:
1183                 continue
1184             ext = textstream.get('ext') or determine_ext(src)
1185             if not ext:
1186                 type_ = textstream.get('type')
1187                 SUBTITLES_TYPES = {
1188                     'text/vtt': 'vtt',
1189                     'text/srt': 'srt',
1190                     'application/smptett+xml': 'tt',
1191                 }
1192                 if type_ in SUBTITLES_TYPES:
1193                     ext = SUBTITLES_TYPES[type_]
1194             lang = textstream.get('systemLanguage') or textstream.get('systemLanguageName') or textstream.get('lang') or subtitles_lang
1195             subtitles.setdefault(lang, []).append({
1196                 'url': src,
1197                 'ext': ext,
1198             })
1199         return subtitles
1200
1201     def _extract_xspf_playlist(self, playlist_url, playlist_id, fatal=True):
1202         xspf = self._download_xml(
1203             playlist_url, playlist_id, 'Downloading xpsf playlist',
1204             'Unable to download xspf manifest', fatal=fatal)
1205         if xspf is False:
1206             return []
1207         return self._parse_xspf(xspf, playlist_id)
1208
1209     def _parse_xspf(self, playlist, playlist_id):
1210         NS_MAP = {
1211             'xspf': 'http://xspf.org/ns/0/',
1212             's1': 'http://static.streamone.nl/player/ns/0',
1213         }
1214
1215         entries = []
1216         for track in playlist.findall(xpath_with_ns('./xspf:trackList/xspf:track', NS_MAP)):
1217             title = xpath_text(
1218                 track, xpath_with_ns('./xspf:title', NS_MAP), 'title', default=playlist_id)
1219             description = xpath_text(
1220                 track, xpath_with_ns('./xspf:annotation', NS_MAP), 'description')
1221             thumbnail = xpath_text(
1222                 track, xpath_with_ns('./xspf:image', NS_MAP), 'thumbnail')
1223             duration = float_or_none(
1224                 xpath_text(track, xpath_with_ns('./xspf:duration', NS_MAP), 'duration'), 1000)
1225
1226             formats = [{
1227                 'url': location.text,
1228                 'format_id': location.get(xpath_with_ns('s1:label', NS_MAP)),
1229                 'width': int_or_none(location.get(xpath_with_ns('s1:width', NS_MAP))),
1230                 'height': int_or_none(location.get(xpath_with_ns('s1:height', NS_MAP))),
1231             } for location in track.findall(xpath_with_ns('./xspf:location', NS_MAP))]
1232             self._sort_formats(formats)
1233
1234             entries.append({
1235                 'id': playlist_id,
1236                 'title': title,
1237                 'description': description,
1238                 'thumbnail': thumbnail,
1239                 'duration': duration,
1240                 'formats': formats,
1241             })
1242         return entries
1243
1244     def _live_title(self, name):
1245         """ Generate the title for a live video """
1246         now = datetime.datetime.now()
1247         now_str = now.strftime("%Y-%m-%d %H:%M")
1248         return name + ' ' + now_str
1249
1250     def _int(self, v, name, fatal=False, **kwargs):
1251         res = int_or_none(v, **kwargs)
1252         if 'get_attr' in kwargs:
1253             print(getattr(v, kwargs['get_attr']))
1254         if res is None:
1255             msg = 'Failed to extract %s: Could not parse value %r' % (name, v)
1256             if fatal:
1257                 raise ExtractorError(msg)
1258             else:
1259                 self._downloader.report_warning(msg)
1260         return res
1261
1262     def _float(self, v, name, fatal=False, **kwargs):
1263         res = float_or_none(v, **kwargs)
1264         if res is None:
1265             msg = 'Failed to extract %s: Could not parse value %r' % (name, v)
1266             if fatal:
1267                 raise ExtractorError(msg)
1268             else:
1269                 self._downloader.report_warning(msg)
1270         return res
1271
1272     def _set_cookie(self, domain, name, value, expire_time=None):
1273         cookie = compat_cookiejar.Cookie(
1274             0, name, value, None, None, domain, None,
1275             None, '/', True, False, expire_time, '', None, None, None)
1276         self._downloader.cookiejar.set_cookie(cookie)
1277
1278     def _get_cookies(self, url):
1279         """ Return a compat_cookies.SimpleCookie with the cookies for the url """
1280         req = compat_urllib_request.Request(url)
1281         self._downloader.cookiejar.add_cookie_header(req)
1282         return compat_cookies.SimpleCookie(req.get_header('Cookie'))
1283
1284     def get_testcases(self, include_onlymatching=False):
1285         t = getattr(self, '_TEST', None)
1286         if t:
1287             assert not hasattr(self, '_TESTS'), \
1288                 '%s has _TEST and _TESTS' % type(self).__name__
1289             tests = [t]
1290         else:
1291             tests = getattr(self, '_TESTS', [])
1292         for t in tests:
1293             if not include_onlymatching and t.get('only_matching', False):
1294                 continue
1295             t['name'] = type(self).__name__[:-len('IE')]
1296             yield t
1297
1298     def is_suitable(self, age_limit):
1299         """ Test whether the extractor is generally suitable for the given
1300         age limit (i.e. pornographic sites are not, all others usually are) """
1301
1302         any_restricted = False
1303         for tc in self.get_testcases(include_onlymatching=False):
1304             if 'playlist' in tc:
1305                 tc = tc['playlist'][0]
1306             is_restricted = age_restricted(
1307                 tc.get('info_dict', {}).get('age_limit'), age_limit)
1308             if not is_restricted:
1309                 return True
1310             any_restricted = any_restricted or is_restricted
1311         return not any_restricted
1312
1313     def extract_subtitles(self, *args, **kwargs):
1314         if (self._downloader.params.get('writesubtitles', False) or
1315                 self._downloader.params.get('listsubtitles')):
1316             return self._get_subtitles(*args, **kwargs)
1317         return {}
1318
1319     def _get_subtitles(self, *args, **kwargs):
1320         raise NotImplementedError("This method must be implemented by subclasses")
1321
1322     @staticmethod
1323     def _merge_subtitle_items(subtitle_list1, subtitle_list2):
1324         """ Merge subtitle items for one language. Items with duplicated URLs
1325         will be dropped. """
1326         list1_urls = set([item['url'] for item in subtitle_list1])
1327         ret = list(subtitle_list1)
1328         ret.extend([item for item in subtitle_list2 if item['url'] not in list1_urls])
1329         return ret
1330
1331     @classmethod
1332     def _merge_subtitles(cls, subtitle_dict1, subtitle_dict2):
1333         """ Merge two subtitle dictionaries, language by language. """
1334         ret = dict(subtitle_dict1)
1335         for lang in subtitle_dict2:
1336             ret[lang] = cls._merge_subtitle_items(subtitle_dict1.get(lang, []), subtitle_dict2[lang])
1337         return ret
1338
1339     def extract_automatic_captions(self, *args, **kwargs):
1340         if (self._downloader.params.get('writeautomaticsub', False) or
1341                 self._downloader.params.get('listsubtitles')):
1342             return self._get_automatic_captions(*args, **kwargs)
1343         return {}
1344
1345     def _get_automatic_captions(self, *args, **kwargs):
1346         raise NotImplementedError("This method must be implemented by subclasses")
1347
1348
1349 class SearchInfoExtractor(InfoExtractor):
1350     """
1351     Base class for paged search queries extractors.
1352     They accept URLs in the format _SEARCH_KEY(|all|[0-9]):{query}
1353     Instances should define _SEARCH_KEY and _MAX_RESULTS.
1354     """
1355
1356     @classmethod
1357     def _make_valid_url(cls):
1358         return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
1359
1360     @classmethod
1361     def suitable(cls, url):
1362         return re.match(cls._make_valid_url(), url) is not None
1363
1364     def _real_extract(self, query):
1365         mobj = re.match(self._make_valid_url(), query)
1366         if mobj is None:
1367             raise ExtractorError('Invalid search query "%s"' % query)
1368
1369         prefix = mobj.group('prefix')
1370         query = mobj.group('query')
1371         if prefix == '':
1372             return self._get_n_results(query, 1)
1373         elif prefix == 'all':
1374             return self._get_n_results(query, self._MAX_RESULTS)
1375         else:
1376             n = int(prefix)
1377             if n <= 0:
1378                 raise ExtractorError('invalid download number %s for query "%s"' % (n, query))
1379             elif n > self._MAX_RESULTS:
1380                 self._downloader.report_warning('%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
1381                 n = self._MAX_RESULTS
1382             return self._get_n_results(query, n)
1383
1384     def _get_n_results(self, query, n):
1385         """Get a specified number of results for a query"""
1386         raise NotImplementedError("This method must be implemented by subclasses")
1387
1388     @property
1389     def SEARCH_KEY(self):
1390         return self._SEARCH_KEY