U
|
I=®d·< ã @ s° d dl mZ d dlZd dlZd dlmZ d dlmZ d dlZd dl Z ddl
|
m Z m Z m Z mZmZmZmZ ddlmZ e e¡Zedd d
|
d d d gZG dd deZede_dS )é )Úabsolute_importN)Ú
|
namedtuple)Ú takewhileé )ÚConnectTimeoutErrorÚ MaxRetryErrorÚ ProtocolErrorÚReadTimeoutErrorÚ ResponseErrorÚ InvalidHeaderÚ
|
ProxyError)ÚsixÚRequestHistoryÚmethodÚurlÚerrorÚstatusÚredirect_locationc @ sê e Zd ZdZeddddddgZedd d
|
gZed gZd Zd ddddeddddddef ddZ dd Z
|
e d2ddZ dd Z dd Zdd Zd3d d Zd d Zd4d!d"Zd#d$ Zd%d& Zd'd( Zd5d*d+Zd,d- Zd6d.d/Zd0d1 ZdS )7ÚRetrya3 Retry configuration.
|
|
Each retry attempt will create a new Retry object with updated values, so
|
they can be safely reused.
|
|
Retries can be defined as a default for a pool::
|
|
retries = Retry(connect=5, read=2, redirect=5)
|
http = PoolManager(retries=retries)
|
response = http.request('GET', 'http://example.com/')
|
|
Or per-request (which overrides the default for the pool)::
|
|
response = http.request('GET', 'http://example.com/', retries=Retry(10))
|
|
Retries can be disabled by passing ``False``::
|
|
response = http.request('GET', 'http://example.com/', retries=False)
|
|
Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless
|
retries are disabled, in which case the causing exception will be raised.
|
|
:param int total:
|
Total number of retries to allow. Takes precedence over other counts.
|
|
Set to ``None`` to remove this constraint and fall back on other
|
counts. It's a good idea to set this to some sensibly-high value to
|
account for unexpected edge cases and avoid infinite retry loops.
|
|
Set to ``0`` to fail on the first retry.
|
|
Set to ``False`` to disable and imply ``raise_on_redirect=False``.
|
|
:param int connect:
|
How many connection-related errors to retry on.
|
|
These are errors raised before the request is sent to the remote server,
|
which we assume has not triggered the server to process the request.
|
|
Set to ``0`` to fail on the first retry of this type.
|
|
:param int read:
|
How many times to retry on read errors.
|
|
These errors are raised after the request was sent to the server, so the
|
request may have side-effects.
|
|
Set to ``0`` to fail on the first retry of this type.
|
|
:param int redirect:
|
How many redirects to perform. Limit this to avoid infinite redirect
|
loops.
|
|
A redirect is a HTTP response with a status code 301, 302, 303, 307 or
|
308.
|
|
Set to ``0`` to fail on the first retry of this type.
|
|
Set to ``False`` to disable and imply ``raise_on_redirect=False``.
|
|
:param int status:
|
How many times to retry on bad status codes.
|
|
These are retries made on responses, where status code matches
|
``status_forcelist``.
|
|
Set to ``0`` to fail on the first retry of this type.
|
|
:param iterable method_whitelist:
|
Set of uppercased HTTP method verbs that we should retry on.
|
|
By default, we only retry on methods which are considered to be
|
idempotent (multiple requests with the same parameters end with the
|
same state). See :attr:`Retry.DEFAULT_METHOD_WHITELIST`.
|
|
Set to a ``False`` value to retry on any verb.
|
|
:param iterable status_forcelist:
|
A set of integer HTTP status codes that we should force a retry on.
|
A retry is initiated if the request method is in ``method_whitelist``
|
and the response status code is in ``status_forcelist``.
|
|
By default, this is disabled with ``None``.
|
|
:param float backoff_factor:
|
A backoff factor to apply between attempts after the second try
|
(most errors are resolved immediately by a second try without a
|
delay). urllib3 will sleep for::
|
|
{backoff factor} * (2 ** ({number of total retries} - 1))
|
|
seconds. If the backoff_factor is 0.1, then :func:`.sleep` will sleep
|
for [0.0s, 0.2s, 0.4s, ...] between retries. It will never be longer
|
than :attr:`Retry.BACKOFF_MAX`.
|
|
By default, backoff is disabled (set to 0).
|
|
:param bool raise_on_redirect: Whether, if the number of redirects is
|
exhausted, to raise a MaxRetryError, or to return a response with a
|
response code in the 3xx range.
|
|
:param bool raise_on_status: Similar meaning to ``raise_on_redirect``:
|
whether we should raise an exception, or return a response,
|
if status falls in ``status_forcelist`` range and retries have
|
been exhausted.
|
|
:param tuple history: The history of the request encountered during
|
each call to :meth:`~Retry.increment`. The list is in the order
|
the requests occurred. Each list item is of class :class:`RequestHistory`.
|
|
:param bool respect_retry_after_header:
|
Whether to respect Retry-After header on status codes defined as
|
:attr:`Retry.RETRY_AFTER_STATUS_CODES` or not.
|
|
:param iterable remove_headers_on_redirect:
|
Sequence of headers to remove from the request when a response
|
indicating a redirect is returned before firing off the redirected
|
request.
|
ÚHEADÚGETÚPUTÚDELETEÚOPTIONSÚTRACEi i i÷ Ú Authorizationéx é
|
Nr Tc C s || _ || _|| _|| _|dks(|dkr0d}d} || _|p>t | _|| _|| _| | _ |
|
| _
|
| pbt | _ | | _ tdd | D | _d S )NFr c S s g | ] }| ¡ qS © )Úlower)Ú.0Úhr r úUD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pip/_vendor/urllib3/util/retry.pyÚ
|
<listcomp>Å s z"Retry.__init__.<locals>.<listcomp>)ÚtotalÚconnectÚreadr ÚredirectÚsetÚstatus_forcelistÚmethod_whitelistÚbackoff_factorÚraise_on_redirectÚraise_on_statusÚtupleÚhistoryÚrespect_retry_after_headerÚ frozensetÚremove_headers_on_redirect)Úselfr$ r% r& r' r r* r) r+ r, r- r/ r0 r2 r r r" Ú__init__¢ s$ ÿzRetry.__init__c K sT t | j| j| j| j| j| j| j| j| j | j
|
| j | j | j d }| |¡ t| f |S )N) r$ r% r& r' r r* r) r+ r, r- r/ r2 r0 )Údictr$ r% r& r' r r* r) r+ r, r- r/ r2 r0 ÚupdateÚtype)r3 ÚkwÚparamsr r r" ÚnewÈ s" ó
|
z Retry.newc C sR |dkr|dk r|n| j }t|tr(|S t|o2d}| ||d}t d||¡ |S )z4 Backwards-compatibility for the old retries format.N)r' z!Converted retries value: %r -> %r)ÚDEFAULTÚ
|
isinstancer ÚboolÚlogÚdebug)ÚclsÚretriesr' ÚdefaultÚ new_retriesr r r" Úfrom_intÛ s
|
zRetry.from_intc C sF t ttdd t| j}|dkr(dS | jd|d }t| j|S )zJ Formula for computing the current backoff
|
|
:rtype: float
|
c S s
|
| j d kS )N)r )Úxr r r" Ú<lambda>ñ ó z(Retry.get_backoff_time.<locals>.<lambda>é r r )ÚlenÚlistr Úreversedr/ r+ ÚminÚ BACKOFF_MAX)r3 Úconsecutive_errors_lenÚ backoff_valuer r r" Úget_backoff_timeé s ÿÿzRetry.get_backoff_timec C s\ t d|¡rt|}n6tj |¡}|d kr6td| t |¡}|t ¡ }|dk rXd}|S )Nz^\s*[0-9]+\s*$z Invalid Retry-After header: %sr ) ÚreÚmatchÚintÚemailÚutilsÚ parsedater ÚtimeÚmktime)r3 Ú retry_afterÚsecondsÚretry_date_tupleÚ
|
retry_dater r r" Úparse_retry_afterú s
|
|
zRetry.parse_retry_afterc C s | d¡}|dkrdS | |¡S )z* Get the value of Retry-After in seconds. z Retry-AfterN)Ú getheaderr] ©r3 ÚresponserY r r r" Úget_retry_after
|
s
|
zRetry.get_retry_afterc C s | |¡}|r t |¡ dS dS )NTF)ra rW Úsleepr_ r r r" Úsleep_for_retry s
|
|
|
zRetry.sleep_for_retryc C s" | ¡ }|dkrd S t |¡ d S )Nr )rP rW rb )r3 Úbackoffr r r" Ú_sleep_backoff s zRetry._sleep_backoffc C s( | j r |r | |¡}|r dS | ¡ dS )aC Sleep between retry attempts.
|
|
This method will respect a server's ``Retry-After`` response header
|
and sleep the duration of the time requested. If that is not present, it
|
will use an exponential backoff. By default, the backoff factor is 0 and
|
this method will return immediately.
|
N)r0 rc re )r3 r` Úsleptr r r" rb " s
|
|
|
z Retry.sleepc C s t |tr|j}t |tS )z{ Errors when we're fairly sure that the server did not receive the
|
request, so it should be safe to retry.
|
)r< r Úoriginal_errorr ©r3 Úerrr r r" Ú_is_connection_error2 s
|
zRetry._is_connection_errorc C s t |ttfS )z Errors that occur after the request has been started, so we should
|
assume that the server began processing it.
|
)r< r r rh r r r" Ú_is_read_error: s zRetry._is_read_errorc C s | j r| ¡ | j krdS dS )z| Checks if a given HTTP method should be retried upon, depending if
|
it is included on the method whitelist.
|
FT)r* Úupper)r3 r r r r" Ú_is_method_retryable@ s zRetry._is_method_retryableFc C s< | |¡sdS | jr"|| jkr"dS | jo:| jo:|o:|| jkS )ax Is this method/status code retryable? (Based on whitelists and control
|
variables such as the number of total retries to allow, whether to
|
respect the Retry-After header, whether this header is present, and
|
whether the returned status code is on the list of status codes to
|
be retried upon on the presence of the aforementioned header)
|
FT)rm r) r$ r0 ÚRETRY_AFTER_STATUS_CODES)r3 r Ú status_codeÚhas_retry_afterr r r" Úis_retryI s
|
ÿþüzRetry.is_retryc C s: | j | j| j| j| jf}ttd|}|s.dS t|dk S )z Are we out of retries? NFr )r$ r% r& r' r rJ ÚfilterrL )r3 Ú retry_countsr r r" Ú is_exhausted] s
|
zRetry.is_exhaustedc C s¬ | j dkr |r t t|||¡| j }|dk r6|d8 }| j}| j} | j}
|
| j} d} d} d}|r| |¡r|dkrt t|||¡n|dk r|d8 }n¶|rÜ| |¡rÜ| dks¶|
|
|¡sÊt t|||¡n| dk rÚ| d8 } np|r| ¡ r|
|
dk rü|
|
d8 }
|
d} | ¡ }|j} n<t j } |rL|jrL| dk r6| d8 } t jj|jd} |j} | jt|||| |f }| j||| |
|
| |d}| ¡ rt|||pt | t d||¡ |S ) a¡ Return a new Retry object with incremented retry counters.
|
|
:param response: A response object, or None, if the server did not
|
return a response.
|
:type response: :class:`~urllib3.response.HTTPResponse`
|
:param Exception error: An error encountered during the request, or
|
None if the response was received successfully.
|
|
:return: A new ``Retry`` object.
|
FNrH Úunknownztoo many redirects)ro )r$ r% r& r' r r/ z$Incremented Retry for (url='%s'): %r)r$ r Úreraiser7 r% r& r' r rj rk rm Úget_redirect_locationr
|
Ú GENERIC_ERRORÚSPECIFIC_ERRORÚformatr/ r r: rt r r> r? )r3 r r r` r Ú_poolÚ _stacktracer$ r% r& r' Ú status_countÚcauser r r/ Ú new_retryr r r" Ú incrementf sb
|
|
|
ÿú
|
zRetry.incrementc C s dj t| | dS )Nz|{cls.__name__}(total={self.total}, connect={self.connect}, read={self.read}, redirect={self.redirect}, status={self.status}))r@ r3 )rz r7 )r3 r r r" Ú__repr__½ s
|
ÿ ýzRetry.__repr__)TN)N)N)F)NNNNNN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r1 ÚDEFAULT_METHOD_WHITELISTrn Ú"DEFAULT_REDIRECT_HEADERS_BLACKLISTrM r4 r: Ú classmethodrD rP r] ra rc re rb rj rk rm rq rt r r r r r r" r sV xÿ
|
ò
|
&
|
|
|
|
ù
|
Wr é )Ú
|
__future__r rW ÚloggingÚ collectionsr Ú itertoolsr rT rQ Ú
|
exceptionsr r r r r
|
r r Úpackagesr Ú getLoggerr r> r Úobjectr r; r r r r" Ú<module> s$ $
|
ÿ *
|
