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

   1 import base64
   2 import os
   3 import re
   4 import socket
   5 import sys
   6 import netrc
   7
   8 from ..utils import (
   9     compat_http_client,
  10     compat_urllib_error,
  11     compat_urllib_request,
  12     compat_str,
  13
  14     clean_html,
  15     compiled_regex_type,
  16     ExtractorError,
  17 )
  18
  19 class InfoExtractor(object):
  20     """Information Extractor class.
  21
  22     Information extractors are the classes that, given a URL, extract
  23     information about the video (or videos) the URL refers to. This
  24     information includes the real video URL, the video title, author and
  25     others. The information is stored in a dictionary which is then
  26     passed to the FileDownloader. The FileDownloader processes this
  27     information possibly downloading the video to the file system, among
  28     other possible outcomes.
  29
  30     The dictionaries must include the following fields:
  31
  32     id:             Video identifier.
  33     url:            Final video URL.
  34     title:          Video title, unescaped.
  35     ext:            Video filename extension.
  36
  37     The following fields are optional:
  38
  39     format:         The video format, defaults to ext (used for --get-format)
  40     thumbnail:      Full URL to a video thumbnail image.
  41     description:    One-line video description.
  42     uploader:       Full name of the video uploader.
  43     upload_date:    Video upload date (YYYYMMDD).
  44     uploader_id:    Nickname or id of the video uploader.
  45     location:       Physical location of the video.
  46     player_url:     SWF Player URL (used for rtmpdump).
  47     subtitles:      The subtitle file contents.
  48     view_count:     How many users have watched the video on the platform.
  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     def report_login(self):
 166         """Report attempt to log in."""
 167         self.to_screen(u'Logging in')
 168
 169     #Methods for following #608
 170     #They set the correct value of the '_type' key
 171     def video_result(self, video_info):
 172         """Returns a video"""
 173         video_info['_type'] = 'video'
 174         return video_info
 175     def url_result(self, url, ie=None):
 176         """Returns a url that points to a page that should be processed"""
 177         #TODO: ie should be the class used for getting the info
 178         video_info = {'_type': 'url',
 179                       'url': url,
 180                       'ie_key': ie}
 181         return video_info
 182     def playlist_result(self, entries, playlist_id=None, playlist_title=None):
 183         """Returns a playlist"""
 184         video_info = {'_type': 'playlist',
 185                       'entries': entries}
 186         if playlist_id:
 187             video_info['id'] = playlist_id
 188         if playlist_title:
 189             video_info['title'] = playlist_title
 190         return video_info
 191
 192     def _search_regex(self, pattern, string, name, default=None, fatal=True, flags=0):
 193         """
 194         Perform a regex search on the given string, using a single or a list of
 195         patterns returning the first matching group.
 196         In case of failure return a default value or raise a WARNING or a
 197         ExtractorError, depending on fatal, specifying the field name.
 198         """
 199         if isinstance(pattern, (str, compat_str, compiled_regex_type)):
 200             mobj = re.search(pattern, string, flags)
 201         else:
 202             for p in pattern:
 203                 mobj = re.search(p, string, flags)
 204                 if mobj: break
 205
 206         if sys.stderr.isatty() and os.name != 'nt':
 207             _name = u'\033[0;34m%s\033[0m' % name
 208         else:
 209             _name = name
 210
 211         if mobj:
 212             # return the first matching group
 213             return next(g for g in mobj.groups() if g is not None)
 214         elif default is not None:
 215             return default
 216         elif fatal:
 217             raise ExtractorError(u'Unable to extract %s' % _name)
 218         else:
 219             self._downloader.report_warning(u'unable to extract %s; '
 220                 u'please report this issue on http://yt-dl.org/bug' % _name)
 221             return None
 222
 223     def _html_search_regex(self, pattern, string, name, default=None, fatal=True, flags=0):
 224         """
 225         Like _search_regex, but strips HTML tags and unescapes entities.
 226         """
 227         res = self._search_regex(pattern, string, name, default, fatal, flags)
 228         if res:
 229             return clean_html(res).strip()
 230         else:
 231             return res
 232
 233     def _get_login_info(self):
 234         """
 235         Get the the login info as (username, password)
 236         It will look in the netrc file using the _NETRC_MACHINE value
 237         If there's no info available, return (None, None)
 238         """
 239         if self._downloader is None:
 240             return (None, None)
 241
 242         username = None
 243         password = None
 244         downloader_params = self._downloader.params
 245
 246         # Attempt to use provided username and password or .netrc data
 247         if downloader_params.get('username', None) is not None:
 248             username = downloader_params['username']
 249             password = downloader_params['password']
 250         elif downloader_params.get('usenetrc', False):
 251             try:
 252                 info = netrc.netrc().authenticators(self._NETRC_MACHINE)
 253                 if info is not None:
 254                     username = info[0]
 255                     password = info[2]
 256                 else:
 257                     raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
 258             except (IOError, netrc.NetrcParseError) as err:
 259                 self._downloader.report_warning(u'parsing .netrc: %s' % compat_str(err))
 260
 261         return (username, password)
 262
 263 class SearchInfoExtractor(InfoExtractor):
 264     """
 265     Base class for paged search queries extractors.
 266     They accept urls in the format _SEARCH_KEY(|all|[0-9]):{query}
 267     Instances should define _SEARCH_KEY and _MAX_RESULTS.
 268     """
 269
 270     @classmethod
 271     def _make_valid_url(cls):
 272         return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
 273
 274     @classmethod
 275     def suitable(cls, url):
 276         return re.match(cls._make_valid_url(), url) is not None
 277
 278     def _real_extract(self, query):
 279         mobj = re.match(self._make_valid_url(), query)
 280         if mobj is None:
 281             raise ExtractorError(u'Invalid search query "%s"' % query)
 282
 283         prefix = mobj.group('prefix')
 284         query = mobj.group('query')
 285         if prefix == '':
 286             return self._get_n_results(query, 1)
 287         elif prefix == 'all':
 288             return self._get_n_results(query, self._MAX_RESULTS)
 289         else:
 290             n = int(prefix)
 291             if n <= 0:
 292                 raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
 293             elif n > self._MAX_RESULTS:
 294                 self._downloader.report_warning(u'%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
 295                 n = self._MAX_RESULTS
 296             return self._get_n_results(query, n)
 297
 298     def _get_n_results(self, query, n):
 299         """Get a specified number of results for a query"""
 300         raise NotImplementedError("This method must be implemented by sublclasses")
 301
 302     @property
 303     def SEARCH_KEY(self):
 304         return self._SEARCH_KEY