yt_dlp/networking/exceptions.py

   1 from __future__ import annotations
   2
   3 import typing
   4 import urllib.error
   5
   6 from ..utils import YoutubeDLError
   7
   8 if typing.TYPE_CHECKING:
   9     from .common import RequestHandler, Response
  10
  11
  12 class RequestError(YoutubeDLError):
  13     def __init__(
  14         self,
  15         msg: str | None = None,
  16         cause: Exception | str | None = None,
  17         handler: RequestHandler = None
  18     ):
  19         self.handler = handler
  20         self.cause = cause
  21         if not msg and cause:
  22             msg = str(cause)
  23         super().__init__(msg)
  24
  25
  26 class UnsupportedRequest(RequestError):
  27     """raised when a handler cannot handle a request"""
  28     pass
  29
  30
  31 class NoSupportingHandlers(RequestError):
  32     """raised when no handlers can support a request for various reasons"""
  33
  34     def __init__(self, unsupported_errors: list[UnsupportedRequest], unexpected_errors: list[Exception]):
  35         self.unsupported_errors = unsupported_errors or []
  36         self.unexpected_errors = unexpected_errors or []
  37
  38         # Print a quick summary of the errors
  39         err_handler_map = {}
  40         for err in unsupported_errors:
  41             err_handler_map.setdefault(err.msg, []).append(err.handler.RH_NAME)
  42
  43         reason_str = ', '.join([f'{msg} ({", ".join(handlers)})' for msg, handlers in err_handler_map.items()])
  44         if unexpected_errors:
  45             reason_str = ' + '.join(filter(None, [reason_str, f'{len(unexpected_errors)} unexpected error(s)']))
  46
  47         err_str = 'Unable to handle request'
  48         if reason_str:
  49             err_str += f': {reason_str}'
  50
  51         super().__init__(msg=err_str)
  52
  53
  54 class TransportError(RequestError):
  55     """Network related errors"""
  56
  57
  58 class HTTPError(RequestError):
  59     def __init__(self, response: Response, redirect_loop=False):
  60         self.response = response
  61         self.status = response.status
  62         self.reason = response.reason
  63         self.redirect_loop = redirect_loop
  64         msg = f'HTTP Error {response.status}: {response.reason}'
  65         if redirect_loop:
  66             msg += ' (redirect loop detected)'
  67
  68         super().__init__(msg=msg)
  69
  70     def close(self):
  71         self.response.close()
  72
  73     def __repr__(self):
  74         return f'<HTTPError {self.status}: {self.reason}>'
  75
  76
  77 class IncompleteRead(TransportError):
  78     def __init__(self, partial, expected=None, **kwargs):
  79         self.partial = partial
  80         self.expected = expected
  81         msg = f'{len(partial)} bytes read'
  82         if expected is not None:
  83             msg += f', {expected} more expected'
  84
  85         super().__init__(msg=msg, **kwargs)
  86
  87     def __repr__(self):
  88         return f'<IncompleteRead: {self.msg}>'
  89
  90
  91 class SSLError(TransportError):
  92     pass
  93
  94
  95 class CertificateVerifyError(SSLError):
  96     """Raised when certificate validated has failed"""
  97     pass
  98
  99
 100 class ProxyError(TransportError):
 101     pass
 102
 103
 104 class _CompatHTTPError(urllib.error.HTTPError, HTTPError):
 105     """
 106     Provides backwards compatibility with urllib.error.HTTPError.
 107     Do not use this class directly, use HTTPError instead.
 108     """
 109
 110     def __init__(self, http_error: HTTPError):
 111         super().__init__(
 112             url=http_error.response.url,
 113             code=http_error.status,
 114             msg=http_error.msg,
 115             hdrs=http_error.response.headers,
 116             fp=http_error.response
 117         )
 118         self._closer.file = None  # Disable auto close
 119         self._http_error = http_error
 120         HTTPError.__init__(self, http_error.response, redirect_loop=http_error.redirect_loop)
 121
 122     @property
 123     def status(self):
 124         return self._http_error.status
 125
 126     @status.setter
 127     def status(self, value):
 128         return
 129
 130     @property
 131     def reason(self):
 132         return self._http_error.reason
 133
 134     @reason.setter
 135     def reason(self, value):
 136         return
 137
 138     @property
 139     def headers(self):
 140         return self._http_error.response.headers
 141
 142     @headers.setter
 143     def headers(self, value):
 144         return
 145
 146     def info(self):
 147         return self.response.headers
 148
 149     def getcode(self):
 150         return self.status
 151
 152     def geturl(self):
 153         return self.response.url
 154
 155     @property
 156     def code(self):
 157         return self.status
 158
 159     @code.setter
 160     def code(self, value):
 161         return
 162
 163     @property
 164     def url(self):
 165         return self.response.url
 166
 167     @url.setter
 168     def url(self, value):
 169         return
 170
 171     @property
 172     def hdrs(self):
 173         return self.response.headers
 174
 175     @hdrs.setter
 176     def hdrs(self, value):
 177         return
 178
 179     @property
 180     def filename(self):
 181         return self.response.url
 182
 183     @filename.setter
 184     def filename(self, value):
 185         return
 186
 187     def __getattr__(self, name):
 188         return super().__getattr__(name)
 189
 190     def __str__(self):
 191         return str(self._http_error)
 192
 193     def __repr__(self):
 194         return repr(self._http_error)
 195
 196
 197 network_exceptions = (HTTPError, TransportError)