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

   1 from __future__ import absolute_import
   2
   3 import base64
   4 import os
   5 import re
   6 import socket
   7 import sys
   8
   9 from ..utils import (
  10     compat_http_client,
  11     compat_urllib_error,
  12     compat_urllib_request,
  13     compat_str,
  14
  15     clean_html,
  16     compiled_regex_type,
  17     ExtractorError,
  18 )
  19
  20 class InfoExtractor(object):
  21     """Information Extractor class.
  22
  23     Information extractors are the classes that, given a URL, extract
  24     information about the video (or videos) the URL refers to. This
  25     information includes the real video URL, the video title, author and
  26     others. The information is stored in a dictionary which is then
  27     passed to the FileDownloader. The FileDownloader processes this
  28     information possibly downloading the video to the file system, among
  29     other possible outcomes.
  30
  31     The dictionaries must include the following fields:
  32
  33     id:             Video identifier.
  34     url:            Final video URL.
  35     title:          Video title, unescaped.
  36     ext:            Video filename extension.
  37
  38     The following fields are optional:
  39
  40     format:         The video format, defaults to ext (used for --get-format)
  41     thumbnail:      Full URL to a video thumbnail image.
  42     description:    One-line video description.
  43     uploader:       Full name of the video uploader.
  44     upload_date:    Video upload date (YYYYMMDD).
  45     uploader_id:    Nickname or id of the video uploader.
  46     location:       Physical location of the video.
  47     player_url:     SWF Player URL (used for rtmpdump).
  48     subtitles:      The subtitle file contents.
  49     urlhandle:      [internal] The urlHandle to be used to download the file,
  50                     like returned by urllib.request.urlopen
  51
  52     The fields should all be Unicode strings.
  53
  54     Subclasses of this one should re-define the _real_initialize() and
  55     _real_extract() methods and define a _VALID_URL regexp.
  56     Probably, they should also be added to the list of extractors.
  57
  58     _real_extract() must return a *list* of information dictionaries as
  59     described above.
  60
  61     Finally, the _WORKING attribute should be set to False for broken IEs
  62     in order to warn the users and skip the tests.
  63     """
  64
  65     _ready = False
  66     _downloader = None
  67     _WORKING = True
  68
  69     def __init__(self, downloader=None):
  70         """Constructor. Receives an optional downloader."""
  71         self._ready = False
  72         self.set_downloader(downloader)
  73
  74     @classmethod
  75     def suitable(cls, url):
  76         """Receives a URL and returns True if suitable for this IE."""
  77         return re.match(cls._VALID_URL, url) is not None
  78
  79     @classmethod
  80     def working(cls):
  81         """Getter method for _WORKING."""
  82         return cls._WORKING
  83
  84     def initialize(self):
  85         """Initializes an instance (authentication, etc)."""
  86         if not self._ready:
  87             self._real_initialize()
  88             self._ready = True
  89
  90     def extract(self, url):
  91         """Extracts URL information and returns it in list of dicts."""
  92         self.initialize()
  93         return self._real_extract(url)
  94
  95     def set_downloader(self, downloader):
  96         """Sets the downloader for this IE."""
  97         self._downloader = downloader
  98
  99     def _real_initialize(self):
 100         """Real initialization process. Redefine in subclasses."""
 101         pass
 102
 103     def _real_extract(self, url):
 104         """Real extraction process. Redefine in subclasses."""
 105         pass
 106
 107     @property
 108     def IE_NAME(self):
 109         return type(self).__name__[:-2]
 110
 111     def _request_webpage(self, url_or_request, video_id, note=None, errnote=None):
 112         """ Returns the response handle """
 113         if note is None:
 114             self.report_download_webpage(video_id)
 115         elif note is not False:
 116             self.to_screen(u'%s: %s' % (video_id, note))
 117         try:
 118             return compat_urllib_request.urlopen(url_or_request)
 119         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 120             if errnote is None:
 121                 errnote = u'Unable to download webpage'
 122             raise ExtractorError(u'%s: %s' % (errnote, compat_str(err)), sys.exc_info()[2])
 123
 124     def _download_webpage_handle(self, url_or_request, video_id, note=None, errnote=None):
 125         """ Returns a tuple (page content as string, URL handle) """
 126         urlh = self._request_webpage(url_or_request, video_id, note, errnote)
 127         content_type = urlh.headers.get('Content-Type', '')
 128         m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
 129         if m:
 130             encoding = m.group(1)
 131         else:
 132             encoding = 'utf-8'
 133         webpage_bytes = urlh.read()
 134         if self._downloader.params.get('dump_intermediate_pages', False):
 135             try:
 136                 url = url_or_request.get_full_url()
 137             except AttributeError:
 138                 url = url_or_request
 139             self.to_screen(u'Dumping request to ' + url)
 140             dump = base64.b64encode(webpage_bytes).decode('ascii')
 141             self._downloader.to_screen(dump)
 142         content = webpage_bytes.decode(encoding, 'replace')
 143         return (content, urlh)
 144
 145     def _download_webpage(self, url_or_request, video_id, note=None, errnote=None):
 146         """ Returns the data of the page as a string """
 147         return self._download_webpage_handle(url_or_request, video_id, note, errnote)[0]
 148
 149     def to_screen(self, msg):
 150         """Print msg to screen, prefixing it with '[ie_name]'"""
 151         self._downloader.to_screen(u'[%s] %s' % (self.IE_NAME, msg))
 152
 153     def report_extraction(self, id_or_name):
 154         """Report information extraction."""
 155         self.to_screen(u'%s: Extracting information' % id_or_name)
 156
 157     def report_download_webpage(self, video_id):
 158         """Report webpage download."""
 159         self.to_screen(u'%s: Downloading webpage' % video_id)
 160
 161     def report_age_confirmation(self):
 162         """Report attempt to confirm age."""
 163         self.to_screen(u'Confirming age')
 164
 165     #Methods for following #608
 166     #They set the correct value of the '_type' key
 167     def video_result(self, video_info):
 168         """Returns a video"""
 169         video_info['_type'] = 'video'
 170         return video_info
 171     def url_result(self, url, ie=None):
 172         """Returns a url that points to a page that should be processed"""
 173         #TODO: ie should be the class used for getting the info
 174         video_info = {'_type': 'url',
 175                       'url': url,
 176                       'ie_key': ie}
 177         return video_info
 178     def playlist_result(self, entries, playlist_id=None, playlist_title=None):
 179         """Returns a playlist"""
 180         video_info = {'_type': 'playlist',
 181                       'entries': entries}
 182         if playlist_id:
 183             video_info['id'] = playlist_id
 184         if playlist_title:
 185             video_info['title'] = playlist_title
 186         return video_info
 187
 188     def _search_regex(self, pattern, string, name, default=None, fatal=True, flags=0):
 189         """
 190         Perform a regex search on the given string, using a single or a list of
 191         patterns returning the first matching group.
 192         In case of failure return a default value or raise a WARNING or a
 193         ExtractorError, depending on fatal, specifying the field name.
 194         """
 195         if isinstance(pattern, (str, compat_str, compiled_regex_type)):
 196             mobj = re.search(pattern, string, flags)
 197         else:
 198             for p in pattern:
 199                 mobj = re.search(p, string, flags)
 200                 if mobj: break
 201
 202         if sys.stderr.isatty() and os.name != 'nt':
 203             _name = u'\033[0;34m%s\033[0m' % name
 204         else:
 205             _name = name
 206
 207         if mobj:
 208             # return the first matching group
 209             return next(g for g in mobj.groups() if g is not None)
 210         elif default is not None:
 211             return default
 212         elif fatal:
 213             raise ExtractorError(u'Unable to extract %s' % _name)
 214         else:
 215             self._downloader.report_warning(u'unable to extract %s; '
 216                 u'please report this issue on GitHub.' % _name)
 217             return None
 218
 219     def _html_search_regex(self, pattern, string, name, default=None, fatal=True, flags=0):
 220         """
 221         Like _search_regex, but strips HTML tags and unescapes entities.
 222         """
 223         res = self._search_regex(pattern, string, name, default, fatal, flags)
 224         if res:
 225             return clean_html(res).strip()
 226         else:
 227             return res
 228
 229 class SearchInfoExtractor(InfoExtractor):
 230     """
 231     Base class for paged search queries extractors.
 232     They accept urls in the format _SEARCH_KEY(|all|[0-9]):{query}
 233     Instances should define _SEARCH_KEY and _MAX_RESULTS.
 234     """
 235
 236     @classmethod
 237     def _make_valid_url(cls):
 238         return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
 239
 240     @classmethod
 241     def suitable(cls, url):
 242         return re.match(cls._make_valid_url(), url) is not None
 243
 244     def _real_extract(self, query):
 245         mobj = re.match(self._make_valid_url(), query)
 246         if mobj is None:
 247             raise ExtractorError(u'Invalid search query "%s"' % query)
 248
 249         prefix = mobj.group('prefix')
 250         query = mobj.group('query')
 251         if prefix == '':
 252             return self._get_n_results(query, 1)
 253         elif prefix == 'all':
 254             return self._get_n_results(query, self._MAX_RESULTS)
 255         else:
 256             n = int(prefix)
 257             if n <= 0:
 258                 raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
 259             elif n > self._MAX_RESULTS:
 260                 self._downloader.report_warning(u'%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
 261                 n = self._MAX_RESULTS
 262             return self._get_n_results(query, n)
 263
 264     def _get_n_results(self, query, n):
 265         """Get a specified number of results for a query"""
 266         raise NotImplementedError("This method must be implemented by sublclasses")