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