_ 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     thumbnails:     A list of dictionaries (with the entries "resolution" and
  41                     "url") for the varying thumbnails
  42     thumbnail:      Full URL to a video thumbnail image.
  43     description:    One-line video description.
  44     uploader:       Full name of the video uploader.
  45     upload_date:    Video upload date (YYYYMMDD).
  46     uploader_id:    Nickname or id of the video uploader.
  47     location:       Physical location of the video.
  48     player_url:     SWF Player URL (used for rtmpdump).
  49     subtitles:      The subtitle file contents.
  50     view_count:     How many users have watched the video on the platform.
  51     urlhandle:      [internal] The urlHandle to be used to download the file,
  52                     like returned by urllib.request.urlopen
  53
  54     The fields should all be Unicode strings.
  55
  56     Subclasses of this one should re-define the _real_initialize() and
  57     _real_extract() methods and define a _VALID_URL regexp.
  58     Probably, they should also be added to the list of extractors.
  59
  60     _real_extract() must return a *list* of information dictionaries as
  61     described above.
  62
  63     Finally, the _WORKING attribute should be set to False for broken IEs
  64     in order to warn the users and skip the tests.
  65     """
  66
  67     _ready = False
  68     _downloader = None
  69     _WORKING = True
  70
  71     def __init__(self, downloader=None):
  72         """Constructor. Receives an optional downloader."""
  73         self._ready = False
  74         self.set_downloader(downloader)
  75
  76     @classmethod
  77     def suitable(cls, url):
  78         """Receives a URL and returns True if suitable for this IE."""
  79         return re.match(cls._VALID_URL, url) is not None
  80
  81     @classmethod
  82     def working(cls):
  83         """Getter method for _WORKING."""
  84         return cls._WORKING
  85
  86     def initialize(self):
  87         """Initializes an instance (authentication, etc)."""
  88         if not self._ready:
  89             self._real_initialize()
  90             self._ready = True
  91
  92     def extract(self, url):
  93         """Extracts URL information and returns it in list of dicts."""
  94         self.initialize()
  95         return self._real_extract(url)
  96
  97     def set_downloader(self, downloader):
  98         """Sets the downloader for this IE."""
  99         self._downloader = downloader
 100
 101     def _real_initialize(self):
 102         """Real initialization process. Redefine in subclasses."""
 103         pass
 104
 105     def _real_extract(self, url):
 106         """Real extraction process. Redefine in subclasses."""
 107         pass
 108
 109     @property
 110     def IE_NAME(self):
 111         return type(self).__name__[:-2]
 112
 113     def _request_webpage(self, url_or_request, video_id, note=None, errnote=None):
 114         """ Returns the response handle """
 115         if note is None:
 116             self.report_download_webpage(video_id)
 117         elif note is not False:
 118             self.to_screen(u'%s: %s' % (video_id, note))
 119         try:
 120             return compat_urllib_request.urlopen(url_or_request)
 121         except (compat_urllib_error.URLError, compat_http_client.HTTPException, socket.error) as err:
 122             if errnote is None:
 123                 errnote = u'Unable to download webpage'
 124             raise ExtractorError(u'%s: %s' % (errnote, compat_str(err)), sys.exc_info()[2])
 125
 126     def _download_webpage_handle(self, url_or_request, video_id, note=None, errnote=None):
 127         """ Returns a tuple (page content as string, URL handle) """
 128         urlh = self._request_webpage(url_or_request, video_id, note, errnote)
 129         content_type = urlh.headers.get('Content-Type', '')
 130         m = re.match(r'[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+\s*;\s*charset=(.+)', content_type)
 131         if m:
 132             encoding = m.group(1)
 133         else:
 134             encoding = 'utf-8'
 135         webpage_bytes = urlh.read()
 136         if self._downloader.params.get('dump_intermediate_pages', False):
 137             try:
 138                 url = url_or_request.get_full_url()
 139             except AttributeError:
 140                 url = url_or_request
 141             self.to_screen(u'Dumping request to ' + url)
 142             dump = base64.b64encode(webpage_bytes).decode('ascii')
 143             self._downloader.to_screen(dump)
 144         content = webpage_bytes.decode(encoding, 'replace')
 145         return (content, urlh)
 146
 147     def _download_webpage(self, url_or_request, video_id, note=None, errnote=None):
 148         """ Returns the data of the page as a string """
 149         return self._download_webpage_handle(url_or_request, video_id, note, errnote)[0]
 150
 151     def to_screen(self, msg):
 152         """Print msg to screen, prefixing it with '[ie_name]'"""
 153         self._downloader.to_screen(u'[%s] %s' % (self.IE_NAME, msg))
 154
 155     def report_extraction(self, id_or_name):
 156         """Report information extraction."""
 157         self.to_screen(u'%s: Extracting information' % id_or_name)
 158
 159     def report_download_webpage(self, video_id):
 160         """Report webpage download."""
 161         self.to_screen(u'%s: Downloading webpage' % video_id)
 162
 163     def report_age_confirmation(self):
 164         """Report attempt to confirm age."""
 165         self.to_screen(u'Confirming age')
 166
 167     def report_login(self):
 168         """Report attempt to log in."""
 169         self.to_screen(u'Logging in')
 170
 171     #Methods for following #608
 172     def url_result(self, url, ie=None):
 173         """Returns a url that points to a page that should be processed"""
 174         #TODO: ie should be the class used for getting the info
 175         video_info = {'_type': 'url',
 176                       'url': url,
 177                       'ie_key': ie}
 178         return video_info
 179     def playlist_result(self, entries, playlist_id=None, playlist_title=None):
 180         """Returns a playlist"""
 181         video_info = {'_type': 'playlist',
 182                       'entries': entries}
 183         if playlist_id:
 184             video_info['id'] = playlist_id
 185         if playlist_title:
 186             video_info['title'] = playlist_title
 187         return video_info
 188
 189     def _search_regex(self, pattern, string, name, default=None, fatal=True, flags=0):
 190         """
 191         Perform a regex search on the given string, using a single or a list of
 192         patterns returning the first matching group.
 193         In case of failure return a default value or raise a WARNING or a
 194         ExtractorError, depending on fatal, specifying the field name.
 195         """
 196         if isinstance(pattern, (str, compat_str, compiled_regex_type)):
 197             mobj = re.search(pattern, string, flags)
 198         else:
 199             for p in pattern:
 200                 mobj = re.search(p, string, flags)
 201                 if mobj: break
 202
 203         if sys.stderr.isatty() and os.name != 'nt':
 204             _name = u'\033[0;34m%s\033[0m' % name
 205         else:
 206             _name = name
 207
 208         if mobj:
 209             # return the first matching group
 210             return next(g for g in mobj.groups() if g is not None)
 211         elif default is not None:
 212             return default
 213         elif fatal:
 214             raise ExtractorError(u'Unable to extract %s' % _name)
 215         else:
 216             self._downloader.report_warning(u'unable to extract %s; '
 217                 u'please report this issue on http://yt-dl.org/bug' % _name)
 218             return None
 219
 220     def _html_search_regex(self, pattern, string, name, default=None, fatal=True, flags=0):
 221         """
 222         Like _search_regex, but strips HTML tags and unescapes entities.
 223         """
 224         res = self._search_regex(pattern, string, name, default, fatal, flags)
 225         if res:
 226             return clean_html(res).strip()
 227         else:
 228             return res
 229
 230     def _get_login_info(self):
 231         """
 232         Get the the login info as (username, password)
 233         It will look in the netrc file using the _NETRC_MACHINE value
 234         If there's no info available, return (None, None)
 235         """
 236         if self._downloader is None:
 237             return (None, None)
 238
 239         username = None
 240         password = None
 241         downloader_params = self._downloader.params
 242
 243         # Attempt to use provided username and password or .netrc data
 244         if downloader_params.get('username', None) is not None:
 245             username = downloader_params['username']
 246             password = downloader_params['password']
 247         elif downloader_params.get('usenetrc', False):
 248             try:
 249                 info = netrc.netrc().authenticators(self._NETRC_MACHINE)
 250                 if info is not None:
 251                     username = info[0]
 252                     password = info[2]
 253                 else:
 254                     raise netrc.NetrcParseError('No authenticators for %s' % self._NETRC_MACHINE)
 255             except (IOError, netrc.NetrcParseError) as err:
 256                 self._downloader.report_warning(u'parsing .netrc: %s' % compat_str(err))
 257
 258         return (username, password)
 259
 260 class SearchInfoExtractor(InfoExtractor):
 261     """
 262     Base class for paged search queries extractors.
 263     They accept urls in the format _SEARCH_KEY(|all|[0-9]):{query}
 264     Instances should define _SEARCH_KEY and _MAX_RESULTS.
 265     """
 266
 267     @classmethod
 268     def _make_valid_url(cls):
 269         return r'%s(?P<prefix>|[1-9][0-9]*|all):(?P<query>[\s\S]+)' % cls._SEARCH_KEY
 270
 271     @classmethod
 272     def suitable(cls, url):
 273         return re.match(cls._make_valid_url(), url) is not None
 274
 275     def _real_extract(self, query):
 276         mobj = re.match(self._make_valid_url(), query)
 277         if mobj is None:
 278             raise ExtractorError(u'Invalid search query "%s"' % query)
 279
 280         prefix = mobj.group('prefix')
 281         query = mobj.group('query')
 282         if prefix == '':
 283             return self._get_n_results(query, 1)
 284         elif prefix == 'all':
 285             return self._get_n_results(query, self._MAX_RESULTS)
 286         else:
 287             n = int(prefix)
 288             if n <= 0:
 289                 raise ExtractorError(u'invalid download number %s for query "%s"' % (n, query))
 290             elif n > self._MAX_RESULTS:
 291                 self._downloader.report_warning(u'%s returns max %i results (you requested %i)' % (self._SEARCH_KEY, self._MAX_RESULTS, n))
 292                 n = self._MAX_RESULTS
 293             return self._get_n_results(query, n)
 294
 295     def _get_n_results(self, query, n):
 296         """Get a specified number of results for a query"""
 297         raise NotImplementedError("This method must be implemented by sublclasses")
 298
 299     @property
 300     def SEARCH_KEY(self):
 301         return self._SEARCH_KEY