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

   1 import base64
   2 import hashlib
   3 import json
   4 import os
   5 import re
   6 import socket
   7 import sys
   8 import netrc
   9 import xml.etree.ElementTree
  10
  11 from ..utils import (
  12     compat_http_client,
  13     compat_urllib_error,
  14     compat_urllib_parse_urlparse,
  15     compat_str,
  16
  17     clean_html,
  18     compiled_regex_type,
  19     ExtractorError,
  20     RegexNotFoundError,
  21     sanitize_filename,
  22     unescapeHTML,
  23 )
  24 _NO_DEFAULT = object()
  25
  26
  27 class InfoExtractor(object):
  28     """Information Extractor class.
  29
  30     Information extractors are the classes that, given a URL, extract
  31     information about the video (or videos) the URL refers to. This
  32     information includes the real video URL, the video title, author and
  33     others. The information is stored in a dictionary which is then
  34     passed to the FileDownloader. The FileDownloader processes this
  35     information possibly downloading the video to the file system, among
  36     other possible outcomes.
  37
  38     The dictionaries must include the following fields:
  39
  40     id:             Video identifier.
  41     title:          Video title, unescaped.
  42
  43     Additionally, it must contain either a formats entry or a url one:
  44
  45     formats:        A list of dictionaries for each format available, ordered
  46                     from worst to best quality.
  47
  48                     Potential fields:
  49                     * url        Mandatory. The URL of the video file
  50                     * ext        Will be calculated from url if missing
  51                     * format     A human-readable description of the format
  52                                  ("mp4 container with h264/opus").
  53                                  Calculated from the format_id, width, height.
  54                                  and format_note fields if missing.
  55                     * format_id  A short description of the format
  56                                  ("mp4_h264_opus" or "19").
  57                                 Technically optional, but strongly recommended.
  58                     * format_note Additional info about the format
  59                                  ("3D" or "DASH video")
  60                     * width      Width of the video, if known
  61                     * height     Height of the video, if known
  62                     * resolution Textual description of width and height
  63                     * tbr        Average bitrate of audio and video in KBit/s
  64                     * abr        Average audio bitrate in KBit/s
  65                     * acodec     Name of the audio codec in use
  66                     * vbr        Average video bitrate in KBit/s
  67                     * vcodec     Name of the video codec in use
  68                     * filesize   The number of bytes, if known in advance
  69                     * player_url SWF Player URL (used for rtmpdump).
  70                     * protocol   The protocol that will be used for the actual
  71                                  download, lower-case.
  72                                  "http", "https", "rtsp", "rtmp" or so.
  73                     * preference Order number of this format. If this field is
  74                                  present and not None, the formats get sorted
  75                                  by this field.
  76                                  -1 for default (order by other properties),
  77                                  -2 or smaller for less than default.
  78                     * quality    Order number of the video quality of this
  79                                  format, irrespective of the file format.
  80                                  -1 for default (order by other properties),
  81                                  -2 or smaller for less than default.
  82     url:            Final video URL.
  83     ext:            Video filename extension.
  84     format:         The video format, defaults to ext (used for --get-format)
  85     player_url:     SWF Player URL (used for rtmpdump).
  86
  87     The following fields are optional:
  88
  89     thumbnails:     A list of dictionaries (with the entries "resolution" and
  90                     "url") for the varying thumbnails
  91     thumbnail:      Full URL to a video thumbnail image.
  92     description:    One-line video description.
  93     uploader:       Full name of the video uploader.
  94     upload_date:    Video upload date (YYYYMMDD).
  95     uploader_id:    Nickname or id of the video uploader.
  96     location:       Physical location of the video.
  97     subtitles:      The subtitle file contents as a dictionary in the format
  98                     {language: subtitles}.
  99     duration:       Length of the video in seconds, as an integer.
 100     view_count:     How many users have watched the video on the platform.
 101     like_count:     Number of positive ratings of the video
 102     dislike_count:  Number of negative ratings of the video
 103     comment_count:  Number of comments on the video
 104     age_limit:      Age restriction for the video, as an integer (years)
 105     webpage_url:    The url to the video webpage, if given to youtube-dl it
 106                     should allow to get the same result again. (It will be set
 107                     by YoutubeDL if it's missing)
 108
 109     Unless mentioned otherwise, the fields should be Unicode strings.
 110
 111     Subclasses of this one should re-define the _real_initialize() and
 112     _real_extract() methods and define a _VALID_URL regexp.
 113     Probably, they should also be added to the list of extractors.
 114
 115     _real_extract() must return a *list* of information dictionaries as
 116     described above.
 117
 118     Finally, the _WORKING attribute should be set to False for broken IEs
 119     in order to warn the users and skip the tests.
 120     """
 121
 122     _ready = False
 123     _downloader = None
 124     _WORKING = True
 125
 126     def __init__(self, downloader=None):
 127         """Constructor. Receives an optional downloader."""
 128         self._ready = False
 129         self.set_downloader(downloader)
 130
 131     @classmethod
 132     def suitable(cls, url):
 133         """Receives a URL and returns True if suitable for this IE."""
 134
 135         # This does not use has/getattr intentionally - we want to know whether
 136         # we have cached the regexp for *this* class, whereas getattr would also
 137         # match the superclass
 138         if '_VALID_URL_RE' not in cls.__dict__:
 139             cls._VALID_URL_RE = re.compile(cls._VALID_URL)
 140         return cls._VALID_URL_RE.match(url) is not None
 141
 142     @classmethod
 143     def working(cls):
 144         """Getter method for _WORKING."""
 145         return cls._WORKING
 146
 147     def initialize(self):
 148         """Initializes an instance (authentication, etc)."""
 149         if not self._ready:
 150             self._real_initialize()
 151             self._ready = True
 152
 153     def extract(self, url):
 154         """Extracts URL information and returns it in list of dicts."""
 155         self.initialize()
 156         return self._real_extract(url)
 157
 158     def set_downloader(self, downloader):
 159         """Sets the downloader for this IE."""
 160         self._downloader = downloader
 161
 162     def _real_initialize(self):
 163         """Real initialization process. Redefine in subclasses."""
 164         pass
 165
 166     def _real_extract(self, url):
 167         """Real extraction process. Redefine in subclasses."""
 168         pass
 169
 170     @classmethod
 171     def ie_key(cls):
 172         """A string for getting the InfoExtractor with get_info_extractor"""
 173         return cls.__name__[:-2]
 174
 175     @property
 176     def IE_NAME(self):
 177         return type(self).__name__[:-2]
 178
 179     def _request_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True):
 180         """ Returns the response handle """
 181         if note is None:
 182             self.report_download_webpage(video_id)
 183         elif note is not False:
 184             if video_id is None:
 185                 self.to_screen(u'%s' % (note,))
 186             else:
 187                 self.to_screen(u'%s: %s' % (video_id, note))
 188         try:
 189             return self._downloader.urlopen(url_or_request)
 190         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 191             if errnote is False:
 192                 return False
 193             if errnote is None:
 194                 errnote = u'Unable to download webpage'
 195             errmsg = u'%s: %s' % (errnote, compat_str(err))
 196             if fatal:
 197                 raise ExtractorError(errmsg, sys.exc_info()[2], cause=err)
 198             else:
 199                 self._downloader.report_warning(errmsg)
 200                 return False
 201
 202     def _download_webpage_handle(self, url_or_request, video_id, note=None, errnote=None, fatal=True):
 203         """ Returns a tuple (page content as string, URL handle) """
 204
 205         # Strip hashes from the URL (#1038)
 206         if isinstance(url_or_request, (compat_str, str)):
 207             url_or_request = url_or_request.partition('#')[0]
 208
 209         urlh = self._request_webpage(url_or_request, video_id, note, errnote, fatal)
 210         if urlh is False:
 211             assert not fatal
 212             return False
 213         content_type = urlh.headers.get('Content-Type', '')
 214         webpage_bytes = urlh.read()
 215         m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
 216         if m:
 217             encoding = m.group(1)
 218         else:
 219             m = re.search(br'<meta[^>]+charset=[\'"]?([^\'")]+)[ /\'">]',
 220                           webpage_bytes[:1024])
 221             if m:
 222                 encoding = m.group(1).decode('ascii')
 223             elif webpage_bytes.startswith(b'\xff\xfe'):
 224                 encoding = 'utf-16'
 225             else:
 226                 encoding = 'utf-8'
 227         if self._downloader.params.get('dump_intermediate_pages', False):
 228             try:
 229                 url = url_or_request.get_full_url()
 230             except AttributeError:
 231                 url = url_or_request
 232             self.to_screen(u'Dumping request to ' + url)
 233             dump = base64.b64encode(webpage_bytes).decode('ascii')
 234             self._downloader.to_screen(dump)
 235         if self._downloader.params.get('write_pages', False):
 236             try:
 237                 url = url_or_request.get_full_url()
 238             except AttributeError:
 239                 url = url_or_request
 240             if len(url) > 200:
 241                 h = u'___' + hashlib.md5(url).hexdigest()
 242                 url = url[:200 - len(h)] + h
 243             raw_filename = ('%s_%s.dump' % (video_id, url))
 244             filename = sanitize_filename(raw_filename, restricted=True)
 245             self.to_screen(u'Saving request to ' + filename)
 246             with open(filename, 'wb') as outf:
 247                 outf.write(webpage_bytes)
 248
 249         content = webpage_bytes.decode(encoding, 'replace')
 250         return (content, urlh)
 251
 252     def _download_webpage(self, url_or_request, video_id, note=None, errnote=None, fatal=True):
 253         """ Returns the data of the page as a string """
 254         res = self._download_webpage_handle(url_or_request, video_id, note, errnote, fatal)
 255         if res is False:
 256             return res
 257         else:
 258             content, _ = res
 259             return content
 260
 261     def _download_xml(self, url_or_request, video_id,
 262                       note=u'Downloading XML', errnote=u'Unable to download XML',
 263                       transform_source=None):
 264         """Return the xml as an xml.etree.ElementTree.Element"""
 265         xml_string = self._download_webpage(url_or_request, video_id, note, errnote)
 266         if transform_source:
 267             xml_string = transform_source(xml_string)
 268         return xml.etree.ElementTree.fromstring(xml_string.encode('utf-8'))
 269
 270     def _download_json(self, url_or_request, video_id,
 271                        note=u'Downloading JSON metadata',
 272                        errnote=u'Unable to download JSON metadata'):
 273         json_string = self._download_webpage(url_or_request, video_id, note, errnote)
 274         try:
 275             return json.loads(json_string)
 276         except ValueError as ve:
 277             raise ExtractorError('Failed to download JSON', cause=ve)
 278
 279     def report_warning(self, msg, video_id=None):
 280         idstr = u'' if video_id is None else u'%s: ' % video_id
 281         self._downloader.report_warning(
 282             u'[%s] %s%s' % (self.IE_NAME, idstr, msg))
 283
 284     def to_screen(self, msg):
 285         """Print msg to screen, prefixing it with '[ie_name]'"""
 286         self._downloader.to_screen(u'[%s] %s' % (self.IE_NAME, msg))
 287
 288     def report_extraction(self, id_or_name):
 289         """Report information extraction."""
 290         self.to_screen(u'%s: Extracting information' % id_or_name)
 291
 292     def report_download_webpage(self, video_id):
 293         """Report webpage download."""
 294         self.to_screen(u'%s: Downloading webpage' % video_id)
 295
 296     def report_age_confirmation(self):
 297         """Report attempt to confirm age."""
 298         self.to_screen(u'Confirming age')
 299
 300     def report_login(self):
 301         """Report attempt to log in."""
 302         self.to_screen(u'Logging in')
 303
 304     #Methods for following #608
 305     @staticmethod
 306     def url_result(url, ie=None, video_id=None):
 307         """Returns a url that points to a page that should be processed"""
 308         #TODO: ie should be the class used for getting the info
 309         video_info = {'_type': 'url',
 310                       'url': url,
 311                       'ie_key': ie}
 312         if video_id is not None:
 313             video_info['id'] = video_id
 314         return video_info
 315     @staticmethod
 316     def playlist_result(entries, playlist_id=None, playlist_title=None):
 317         """Returns a playlist"""
 318         video_info = {'_type': 'playlist',
 319                       'entries': entries}
 320         if playlist_id:
 321             video_info['id'] = playlist_id
 322         if playlist_title:
 323             video_info['title'] = playlist_title
 324         return video_info
 325
 326     def _search_regex(self, pattern, string, name, default=_NO_DEFAULT, fatal=True, flags=0):
 327         """
 328         Perform a regex search on the given string, using a single or a list of
 329         patterns returning the first matching group.
 330         In case of failure return a default value or raise a WARNING or a
 331         RegexNotFoundError, depending on fatal, specifying the field name.
 332         """
 333         if isinstance(pattern, (str, compat_str, compiled_regex_type)):
 334             mobj = re.search(pattern, string, flags)
 335         else:
 336             for p in pattern:
 337                 mobj = re.search(p, string, flags)
 338                 if mobj: break
 339
 340         if os.name != 'nt' and sys.stderr.isatty():
 341             _name = u'\033[0;34m%s\033[0m' % name
 342         else:
 343             _name = name
 344
 345         if mobj:
 346             # return the first matching group
 347             return next(g for g in mobj.groups() if g is not None)
 348         elif default is not _NO_DEFAULT:
 349             return default
 350         elif fatal:
 351             raise RegexNotFoundError(u'Unable to extract %s' % _name)
 352         else:
 353             self._downloader.report_warning(u'unable to extract %s; '
 354                 u'please report this issue on http://yt-dl.org/bug' % _name)
 355             return None
 356
 357     def _html_search_regex(self, pattern, string, name, default=_NO_DEFAULT, fatal=True, flags=0):
 358         """
 359         Like _search_regex, but strips HTML tags and unescapes entities.
 360         """
 361         res = self._search_regex(pattern, string, name, default, fatal, flags)
 362         if res:
 363             return clean_html(res).strip()
 364         else:
 365             return res
 366
 367     def _get_login_info(self):
 368         """
 369         Get the the login info as (username, password)
 370         It will look in the netrc file using the _NETRC_MACHINE value
 371         If there's no info available, return (None, None)
 372         """
 373         if self._downloader is None:
 374             return (None, None)
 375
 376         username = None
 377         password = None
 378         downloader_params = self._downloader.params
 379
 380         # Attempt to use provided username and password or .netrc data
 381         if downloader_params.get('username', None) is not None:
 382             username = downloader_params['username']
 383             password = downloader_params['password']
 384         elif downloader_params.get('usenetrc', False):
 385             try:
 386                 info = netrc.netrc().authenticators(self._NETRC_MACHINE)
 387                 if info is not None:
 388                     username = info[0]
 389                     password = info[2]
 390                 else:
 391                     raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
 392             except (IOError, netrc.NetrcParseError) as err:
 393                 self._downloader.report_warning(u'parsing .netrc: %s' % compat_str(err))
 394
 395         return (username, password)
 396
 397     # Helper functions for extracting OpenGraph info
 398     @staticmethod
 399     def _og_regexes(prop):
 400         content_re = r'content=(?:"([^>]+?)"|\'(.+?)\')'
 401         property_re = r'(?:name|property)=[\'"]og:%s[\'"]' % re.escape(prop)
 402         template = r'<meta[^>]+?%s[^>]+?%s'
 403         return [
 404             template % (property_re, content_re),
 405             template % (content_re, property_re),
 406         ]
 407
 408     def _og_search_property(self, prop, html, name=None, **kargs):
 409         if name is None:
 410             name = 'OpenGraph %s' % prop
 411         escaped = self._search_regex(self._og_regexes(prop), html, name, flags=re.DOTALL, **kargs)
 412         if escaped is None:
 413             return None
 414         return unescapeHTML(escaped)
 415
 416     def _og_search_thumbnail(self, html, **kargs):
 417         return self._og_search_property('image', html, u'thumbnail url', fatal=False, **kargs)
 418
 419     def _og_search_description(self, html, **kargs):
 420         return self._og_search_property('description', html, fatal=False, **kargs)
 421
 422     def _og_search_title(self, html, **kargs):
 423         return self._og_search_property('title', html, **kargs)
 424
 425     def _og_search_video_url(self, html, name='video url', secure=True, **kargs):
 426         regexes = self._og_regexes('video')
 427         if secure: regexes = self._og_regexes('video:secure_url') + regexes
 428         return self._html_search_regex(regexes, html, name, **kargs)
 429
 430     def _html_search_meta(self, name, html, display_name=None):
 431         if display_name is None:
 432             display_name = name
 433         return self._html_search_regex(
 434             r'''(?ix)<meta
 435                     (?=[^>]+(?:itemprop|name|property)=["\']%s["\'])
 436                     [^>]+content=["\']([^"\']+)["\']''' % re.escape(name),
 437             html, display_name, fatal=False)
 438
 439     def _dc_search_uploader(self, html):
 440         return self._html_search_meta('dc.creator', html, 'uploader')
 441
 442     def _rta_search(self, html):
 443         # See http://www.rtalabel.org/index.php?content=howtofaq#single
 444         if re.search(r'(?ix)<meta\s+name="rating"\s+'
 445                      r'     content="RTA-5042-1996-1400-1577-RTA"',
 446                      html):
 447             return 18
 448         return 0
 449
 450     def _media_rating_search(self, html):
 451         # See http://www.tjg-designs.com/WP/metadata-code-examples-adding-metadata-to-your-web-pages/
 452         rating = self._html_search_meta('rating', html)
 453
 454         if not rating:
 455             return None
 456
 457         RATING_TABLE = {
 458             'safe for kids': 0,
 459             'general': 8,
 460             '14 years': 14,
 461             'mature': 17,
 462             'restricted': 19,
 463         }
 464         return RATING_TABLE.get(rating.lower(), None)
 465
 466     def _sort_formats(self, formats):
 467         def _formats_key(f):
 468             # TODO remove the following workaround
 469             from ..utils import determine_ext
 470             if not f.get('ext') and 'url' in f:
 471                 f['ext'] = determine_ext(f['url'])
 472
 473             preference = f.get('preference')
 474             if preference is None:
 475                 proto = f.get('protocol')
 476                 if proto is None:
 477                     proto = compat_urllib_parse_urlparse(f.get('url', '')).scheme
 478
 479                 preference = 0 if proto in ['http', 'https'] else -0.1
 480                 if f.get('ext') in ['f4f', 'f4m']:  # Not yet supported
 481                     preference -= 0.5
 482
 483             if f.get('vcodec') == 'none':  # audio only
 484                 if self._downloader.params.get('prefer_free_formats'):
 485                     ORDER = [u'aac', u'mp3', u'm4a', u'webm', u'ogg', u'opus']
 486                 else:
 487                     ORDER = [u'webm', u'opus', u'ogg', u'mp3', u'aac', u'm4a']
 488                 ext_preference = 0
 489                 try:
 490                     audio_ext_preference = ORDER.index(f['ext'])
 491                 except ValueError:
 492                     audio_ext_preference = -1
 493             else:
 494                 if self._downloader.params.get('prefer_free_formats'):
 495                     ORDER = [u'flv', u'mp4', u'webm']
 496                 else:
 497                     ORDER = [u'webm', u'flv', u'mp4']
 498                 try:
 499                     ext_preference = ORDER.index(f['ext'])
 500                 except ValueError:
 501                     ext_preference = -1
 502                 audio_ext_preference = 0
 503
 504             return (
 505                 preference,
 506                 f.get('quality') if f.get('quality') is not None else -1,
 507                 f.get('height') if f.get('height') is not None else -1,
 508                 f.get('width') if f.get('width') is not None else -1,
 509                 ext_preference,
 510                 f.get('tbr') if f.get('tbr') is not None else -1,
 511                 f.get('vbr') if f.get('vbr') is not None else -1,
 512                 f.get('abr') if f.get('abr') is not None else -1,
 513                 audio_ext_preference,
 514                 f.get('filesize') if f.get('filesize') is not None else -1,
 515                 f.get('format_id'),
 516             )
 517         formats.sort(key=_formats_key)
 518
 519
 520 class SearchInfoExtractor(InfoExtractor):
 521     """
 522     Base class for paged search queries extractors.
 523     They accept urls in the format _SEARCH_KEY(|all|[0-9]):{query}
 524     Instances should define _SEARCH_KEY and _MAX_RESULTS.
 525     """
 526
 527     @classmethod
 528     def _make_valid_url(cls):
 529         return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
 530
 531     @classmethod
 532     def suitable(cls, url):
 533         return re.match(cls._make_valid_url(), url) is not None
 534
 535     def _real_extract(self, query):
 536         mobj = re.match(self._make_valid_url(), query)
 537         if mobj is None:
 538             raise ExtractorError(u'Invalid search query "%s"' % query)
 539
 540         prefix = mobj.group('prefix')
 541         query = mobj.group('query')
 542         if prefix == '':
 543             return self._get_n_results(query, 1)
 544         elif prefix == 'all':
 545             return self._get_n_results(query, self._MAX_RESULTS)
 546         else:
 547             n = int(prefix)
 548             if n <= 0:
 549                 raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
 550             elif n > self._MAX_RESULTS:
 551                 self._downloader.report_warning(u'%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
 552                 n = self._MAX_RESULTS
 553             return self._get_n_results(query, n)
 554
 555     def _get_n_results(self, query, n):
 556         """Get a specified number of results for a query"""
 557         raise NotImplementedError("This method must be implemented by subclasses")
 558
 559     @property
 560     def SEARCH_KEY(self):
 561         return self._SEARCH_KEY