PK ! Ru __init__.pynu [ from __future__ import absolute_import
# For backwards compatibility, provide imports that used to be here.
from .connection import is_connection_dropped
from .request import make_headers
from .response import is_fp_closed
from .ssl_ import (
SSLContext,
HAS_SNI,
IS_PYOPENSSL,
IS_SECURETRANSPORT,
assert_fingerprint,
resolve_cert_reqs,
resolve_ssl_version,
ssl_wrap_socket,
)
from .timeout import (
current_time,
Timeout,
)
from .retry import Retry
from .url import (
get_host,
parse_url,
split_first,
Url,
)
from .wait import (
wait_for_read,
wait_for_write
)
__all__ = (
'HAS_SNI',
'IS_PYOPENSSL',
'IS_SECURETRANSPORT',
'SSLContext',
'Retry',
'Timeout',
'Url',
'assert_fingerprint',
'current_time',
'is_connection_dropped',
'is_fp_closed',
'get_host',
'parse_url',
'make_headers',
'resolve_cert_reqs',
'resolve_ssl_version',
'split_first',
'ssl_wrap_socket',
'wait_for_read',
'wait_for_write'
)
PK ! TN N
execute.pynu [ # -*- coding: utf-8 -*-
import logging
import os
import sys
import subprocess
import tempfile
from pathlib import Path
from typing import Any, Tuple, Union, List
from subprocess import list2cmdline
from primordial.sizes import ByteSize
from customer_local_ops.util import fmap
DEFAULT_MAX_SEGMENT_SIZE = ByteSize(KiBytes=32)
LOG = logging.getLogger(__name__)
MAX_COMMAND_RESPONSE_BUFFER_SIZE = 2 * DEFAULT_MAX_SEGMENT_SIZE
# Type aliases
RunCommandResult = Tuple[int, str, str]
# pylint: disable=import-error
if sys.platform == 'win32':
import win32con
from win32com.shell import shellcon
from win32com.shell import shell
HANDLE = int
HWND = int
HKEY = int
DWORD = int
def shell_start(file_name: str,
params: str = None,
verb: str = "open",
show: int = win32con.SW_SHOWNORMAL,
mask: int = shellcon.SEE_MASK_FLAG_DDEWAIT,
dir_name: str = None,
id_list: Any = None,
class_id: str = None,
class_key: HKEY = None,
hot_key: DWORD = None,
monitor: HANDLE = None,
window: HWND = None) -> bool:
"""
Wrapper for the Win32 API call ShellExecuteEx. This function can be used on Windows platforms any time Nydus
needs to restart itself for any reason because ShellExecuteEx allows the child process to survive after its
parent process stops. Initially added to resolve a DLL conflict issue, this could also be useful for
upgrading Nydus, for example.
Further information for ShellExecuteEx can be found at
https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shellexecuteexa
:param file_name: The name of the executable to be started. ShellExecuteEx also handles file associations,
so this could also be the name of a document, for example, to be opened with the
associated application, or a URL to be opened by the user's default browser.
:param params: Parameters to be passed to the application. Should not be specified if file_name
is NOT an executable file.
:param verb: Action to take. May be one of 'edit', 'explore', 'find', 'open', 'print', 'properties' or
'runas'. Defaults to 'open'
:param show: Specify how an application is to be shown
:param mask: Flags that indicate content and validity of other parameters
:param dir_name: Name of the working directory. If None, the current directory is used
:param id_list: See Microsoft documentation at the URL above
:param class_id: See Microsoft documentation at the URL above
:param class_key: See Microsoft documentation at the URL above
:param hot_key: See Microsoft documentation at the URL above
:param monitor: See Microsoft documentation at the URL above
:param window: See Microsoft documentation at the URL above
:return: True if the file/application is successfully launched; otherwise, False
"""
def add_field(key: str, val: Any) -> None:
"""
It is an error to include a field with a value of None in the structure passed to ShellExecuteEx, so this
function only adds a key to the dictionary if the value is not None.
:param key: The name of the SHELLEXECUTEINFO field
:param val: The value of the field
"""
if val is not None:
shell_execute_info[key] = val
shell_execute_info = {}
add_field('fMask', mask)
add_field('hwnd', window)
add_field('lpVerb', verb)
add_field('lpFile', file_name)
add_field('lpParameters', params)
add_field('lpDirectory', dir_name)
add_field('nShow', show)
add_field('lpIDList', id_list)
add_field('lpClass', class_id)
add_field('hkeyClass', class_key)
add_field('dwHotKey', hot_key)
add_field('hMonitor', monitor)
return shell.ShellExecuteEx(**shell_execute_info)
else:
def shell_start(**kwargs) -> bool:
return True
def pfx(line):
return '| ' + line
def pfxs(lines):
return list(map(pfx, lines))
def trim_visible_output_to_lines(inp, out):
"""Converts input blob to lines... but not too many"""
if inp is not None:
out = out.replace(inp, '<>', 1)
outl = out.strip().split('\n')
if not outl:
return outl
if len(outl) == 1 and not outl[0].strip():
return [] # no single blank lines please
if len(outl) < 11:
return pfxs(outl)
return pfxs(outl[:5] + ['...elided %d lines...' % (len(outl) - 10)] + outl[-5:])
def mark_error_output(errOut):
"Converts error blob into lines with prefix marks"
se = errOut.strip()
if se:
for L in se.split('\n'):
yield 'ERR: ' + L
class EndsBuffer:
"""String buffer that maintains two segments: a first segment and a
last segment (i.e. the two ends), where each has a maximum size
limit. Any extra output in between these is discarded. The
assumption is that if there is a huge amount of output that
some must be discarded to avoid memory overflows and that
generally the first and last stuff is the most relevant.
"""
def __init__(self, max_segment_size=None):
self._mss = ByteSize(max(0, max_segment_size or 0)) or DEFAULT_MAX_SEGMENT_SIZE
self._data = ''
self._elided = False
def add_str(self, data):
self._data += data
if len(self._data) > self._mss * 2:
self._data = self._data[:self._mss] + self._data[-int(self._mss):]
self._elided = True
def get_bufstr(self):
if self._elided:
return '\n'.join([
self._data[:self._mss],
'...[elided]...',
self._data[-int(self._mss):],
])
return self._data
def str_form(bytestr):
try:
return bytestr.decode('utf-8', errors='backslashreplace')
except UnicodeDecodeError:
try:
import chardet # pylint: disable=import-outside-toplevel
try:
return bytestr.decode(chardet.detect(bytestr)['encoding'])
except UnicodeDecodeError:
pass
except ImportError:
pass
except AttributeError:
return bytestr # already a string
class RunningCommand:
def __init__(self, popen_obj, tag, stdInput, errorOK, logger,
max_buffer_size=MAX_COMMAND_RESPONSE_BUFFER_SIZE):
self.p = popen_obj
self.tag = tag
self.stdInput = stdInput
self.logger = (lambda r, _l=logger or LOG, e=errorOK:
getattr(_l, "error" if r and not e else "info"))
self._bufsize = max_buffer_size
self._output = EndsBuffer(self._bufsize / 2)
self._errors = EndsBuffer(self._bufsize / 2)
self._partial = False
self._completed = False
def checkIfCompleted(self):
self._output.add_str(str_form(self.p.stdout.read()))
self._errors.add_str(str_form(self.p.stderr.read()))
return self.p.poll() is not None
def outputToDate(self):
o = self._output.get_bufstr()
e = self._errors.get_bufstr()
self._output = EndsBuffer(self._bufsize / 2)
self._errors = EndsBuffer(self._bufsize / 2)
self._partial = True
return o, e
def waitForCompletion(self):
# n.b. communicate returns byte strings, in an unknown encoding, although
# with older python, they could also be strings
o, e = fmap(str_form, self.p.communicate())
self._output.add_str(o)
self._errors.add_str(e)
self._completed = True
return self
def getResult(self, omitOutput=False):
if not self._completed:
self.waitForCompletion()
outs, errs = self._output.get_bufstr(), self._errors.get_bufstr()
output_lines = trim_visible_output_to_lines(self.stdInput, outs)
if omitOutput:
output_lines = [line if line.startswith("<>") else "<>" for line in output_lines]
for line in (output_lines
+ list(mark_error_output(errs))
+ ["ExitCode: %d" % self.p.returncode]):
lstr = self.tag + ' ' + line
self.logger(self.p.returncode)(lstr)
# NOTE This is not a Nydus Result; it must be converted
return self.p.returncode, outs.strip(), errs.strip()
def startCommand(cmd, tag, useShell=False, stdInput=None, errorOK=False,
logger=None, omitString=None, env=None):
"""Starts the specified command; no Shell. The cmd is expected to be an
array of strings, although it is also possible to specify
simply a string if there are no arguments to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
The command is run asynchronously in a separate process. The
return value is a RunningCommand object that supports a
.checkIfCompleted() method to test for subprocess completion
(non-blocking) and a .getResult() to get the ProcOpResult of a
completed process (will block until completion if not already
completed).
"""
# if cmd is a string, leave as is to correctly obfuscate omitString
# If cmd is a bytestring, make sure omitString and the replacement text are also bytestrings
log_cmd = ' '.join(cmd) if isinstance(cmd, list) else cmd
replace_text = "<>"
if isinstance(log_cmd, bytes):
if omitString is not None and isinstance(omitString, str):
omitString = omitString.encode('utf-8')
replace_text = b'<>'
if omitString:
log_cmd = log_cmd.replace(omitString, replace_text)
if logger is None:
logger = LOG
logger.info(tag + " RUN: " + str(log_cmd)) # pylint: disable=logging-not-lazy
# pylint: disable=consider-using-with
p = subprocess.Popen(cmd,
shell=useShell,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE,
env=env)
if stdInput:
p.stdin.write(stdInput.encode())
return RunningCommand(p, tag, stdInput, errorOK, logger)
def runCommand(cmd, tag, useShell=False, stdInput=None, errorOK=False,
logger=None, omitString=None, omitOutput=False, env=None):
"""Runs the specified command and waits for completion; no Shell. The
cmd is expected to be an array of strings, although it is also
possible to specify simply a string if there are no arguments
to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
"""
return startCommand(cmd, tag,
useShell=useShell,
stdInput=stdInput,
errorOK=errorOK,
logger=logger,
omitString=omitString,
env=env) \
.waitForCompletion() \
.getResult(omitOutput=omitOutput)
def run_command_pipe(cmd, useShell=False):
"""Used to run commands that make use of | """
p = subprocess.Popen(cmd, shell=useShell, stdout=subprocess.PIPE)
with p:
o, e = p.communicate()
return p.returncode, o, e
def run_powershell(command: str, tag: str, quiet: bool = False) -> Tuple[int, str, str]:
"""Execute the code in ``command`` using PowerShell.
:param command: Code to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:return: Tuple containing (exit_code, stdout, stderr)
"""
# 1. Python 3.5 Windows: cannot use context manager - it does not unlink the file on exit.
# 2. Encode in UTF-8 with byte order mark (BOM) so PowerShell 5.1 (Windows 2016) sees the file is UTF-8. Without
# this, the file will be encoded with the default system encoding which can be changed by administrators and
# which, by default, cannot encode all Unicode characters properly. Encoding as UTF-8 without BOM does not work
# because standard output cannot be decoded as UTF-8.
# - Encoding PowerShell scripts:
# https://docs.microsoft.com/en-us/powershell/scripting/dev-cross-plat/
# vscode/understanding-file-encoding?view=powershell-7.1
# - utf-8-sig encoding: https://docs.python.org/3.5/library/codecs.html#encodings-and-unicode
# - Default encoding (locale.getpreferredencoding()): https://docs.python.org/3.5/library/functions.html#open
# pylint: disable=consider-using-with
temp = tempfile.NamedTemporaryFile(mode='w+t', encoding='utf-8-sig', suffix='.ps1', delete=False)
try:
temp.write(command)
temp.close()
if not quiet:
LOG.debug("Running PowerShell command: %s", command)
return run_powershell_file(temp.name, tag, quiet)
finally:
os.unlink(temp.name)
def run_shell_script_file(script_file: Union[str, Path], tag: str,
quiet: bool = False, script_file_args: List[str] = None,
stdin: str = None) -> Tuple[int, str, str]:
"""Invoke Shell script, passing just ``filename`` or ``filepath`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
"""
command = ['bash', str(script_file)]
if script_file_args:
for arg in script_file_args:
command.append(str(arg))
return runCommand(command, tag, stdInput=stdin, omitOutput=quiet)
def run_powershell_file(script_file: Union[str, Path], tag: str,
quiet: bool = False, script_file_args: List[str] = None,
stdin: str = None) -> Tuple[int, str, str]:
"""Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
"""
command = ['powershell.exe', '-ExecutionPolicy', 'Unrestricted', '-File', str(script_file)]
if script_file_args:
for arg in script_file_args:
command.append(str(arg))
return runCommand(command, tag, stdInput=stdin, omitOutput=quiet)
def run_uapi_command(cmd_list: Union[str, List[str]], description: str, op_name: str,
use_shell: bool = False, omit_string: str = None) -> Tuple[bool, str, str]:
"""Run a command on the target machine
:param cmd_list: string or list of strings that represents a command to be executed
:param description: short description of what the command is doing
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
"""
cmd_list_str = str(cmd_list)
if omit_string:
cmd_list_str = cmd_list_str.replace(omit_string, "<>")
LOG.debug("run_uapi_command %s cmd_list: %s", op_name, cmd_list_str)
exit_code, outs, errs = runCommand(cmd_list, description, useShell=use_shell, omitString=omit_string)
LOG.debug("%s_result- %s - %s - %s", description, exit_code, outs, errs)
return exit_code, outs, errs
def run_multiple_uapi_commands(cmds_list: List[Tuple[str, Union[str, List[str]]]], op_name: str,
use_shell: bool = False, omit_string: str = None) -> Tuple[bool, str, str]:
"""Run a command on the target machine
:param cmds_list: List of tuples with description-command pairs
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
"""
exit_code, outs, errs = 0, '', ''
for description, cmd in cmds_list:
exit_code, outs, errs = run_uapi_command(cmd, description, op_name, use_shell=use_shell,
omit_string=omit_string)
if exit_code != 0:
return exit_code, outs, errs
return exit_code, outs, errs
def start_powershell_file(script_file: Union[str, Path]) -> Tuple[int, str, str]:
"""
Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file.
Do not wait for the sub-process to complete. The exit code returned in the tuple only indicates whether or
not the process was successfully started.
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:return: Tuple containing (exit_code, stdout, stderr)
"""
params = list2cmdline(['-ExecutionPolicy', 'Unrestricted', '-File', str(script_file)])
LOG.info("Staring PowerShell: powershell.exe %s", params)
code = 0 if shell_start('powershell.exe', params=params) else 1
return code, '', ''
def start_powershell(command: str) -> Tuple[int, str, str]:
"""Execute the code in ``command`` using PowerShell.
:param command: Code to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:return: Tuple containing (exit_code, stdout, stderr)
"""
# Because the process started by this command could (and probably will) survive after this process has exited,
# we can't delete the temporary file, here.
# pylint: disable=consider-using-with
temp = tempfile.NamedTemporaryFile(mode='w+t', suffix='.ps1', delete=False)
temp.write(command)
temp.close()
LOG.debug("Running Powershell command: %s", command)
return start_powershell_file(temp.name)
PK ! f6l l
helpers.pynu [ # -*- coding: utf-8 -*-
"""\
© Copyright. All rights reserved.
"""
from __future__ import unicode_literals
from fileinput import FileInput
from functools import reduce
import sys
class HandledFailureException(Exception):
pass
def edit_file_lines(filename, editfunc):
"""Iterates through the lines of the named file, calling the editfunc
for each line, replacing the original file with the new
output.
"""
with FileInput(files=(filename,), inplace=True) as f:
for line in f:
sys.stdout.write(editfunc(line))
def replace_file_lines_multiple(filename, replace_dict, firstword=True):
"""Iterates through the lines of the named file, and through a
dictionary of match -> replace pairs, replacing all that apply for each line,
and replacing the original file with the new output.
"""
with FileInput(files=(filename,), inplace=True) as f:
for line in f:
updated_line = line
for match, replace in replace_dict.items():
updated_line = replace_line(updated_line, match, replace, firstword)
sys.stdout.write(updated_line)
def replace_line(line, match, replace, firstword=True):
"""Checks `line` to see if it starts with `match`; if yes, return
`replace`, otherwise return the original `line`. If
`firstword` is True, then the match must be followed by at
least one space or tab (unless it matches the entire line),
otherwise it is matched directly.
Suitable for use as an editfunc with `edit_file_lines`.
"""
# pylint: disable=too-many-boolean-expressions
if (
line.strip() == match
or (firstword and (line.startswith(match+' ') or line.startswith(match+'\t')))
or (not firstword and line.startswith(match))
):
return replace
return line
def append_line(filename, line):
"""Appends a line to to the specified file.
"""
with open(filename, 'a', encoding='UTF-8') as file:
file.write('\n')
file.write(line)
def create_file(filename, contents):
"""Creates the specified file, with the specified contents.
Overwrites any file already existing at that location.
"""
with open(filename, 'w', encoding='UTF-8') as wf:
wf.write(contents)
def compose(*funcs):
return reduce(lambda f, g: lambda x: f(g(x)), funcs, lambda x: x)
PK ! U3 ; ; retry.pynu [ from __future__ import absolute_import
import time
import logging
from collections import namedtuple
from itertools import takewhile
import email
import re
from ..exceptions import (
ConnectTimeoutError,
MaxRetryError,
ProtocolError,
ReadTimeoutError,
ResponseError,
InvalidHeader,
)
from ..packages import six
log = logging.getLogger(__name__)
# Data structure for representing the metadata of requests that result in a retry.
RequestHistory = namedtuple('RequestHistory', ["method", "url", "error",
"status", "redirect_location"])
class Retry(object):
""" 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 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
: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.
"""
DEFAULT_METHOD_WHITELIST = frozenset([
'HEAD', 'GET', 'PUT', 'DELETE', 'OPTIONS', 'TRACE'])
DEFAULT_REDIRECT_HEADERS_BLACKLIST = frozenset(['Authorization'])
RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])
#: Maximum backoff time.
BACKOFF_MAX = 120
def __init__(self, total=10, connect=None, read=None, redirect=None, status=None,
method_whitelist=DEFAULT_METHOD_WHITELIST, status_forcelist=None,
backoff_factor=0, raise_on_redirect=True, raise_on_status=True,
history=None, respect_retry_after_header=True,
remove_headers_on_redirect=DEFAULT_REDIRECT_HEADERS_BLACKLIST):
self.total = total
self.connect = connect
self.read = read
self.status = status
if redirect is False or total is False:
redirect = 0
raise_on_redirect = False
self.redirect = redirect
self.status_forcelist = status_forcelist or set()
self.method_whitelist = method_whitelist
self.backoff_factor = backoff_factor
self.raise_on_redirect = raise_on_redirect
self.raise_on_status = raise_on_status
self.history = history or tuple()
self.respect_retry_after_header = respect_retry_after_header
self.remove_headers_on_redirect = remove_headers_on_redirect
def new(self, **kw):
params = dict(
total=self.total,
connect=self.connect, read=self.read, redirect=self.redirect, status=self.status,
method_whitelist=self.method_whitelist,
status_forcelist=self.status_forcelist,
backoff_factor=self.backoff_factor,
raise_on_redirect=self.raise_on_redirect,
raise_on_status=self.raise_on_status,
history=self.history,
remove_headers_on_redirect=self.remove_headers_on_redirect,
)
params.update(kw)
return type(self)(**params)
@classmethod
def from_int(cls, retries, redirect=True, default=None):
""" Backwards-compatibility for the old retries format."""
if retries is None:
retries = default if default is not None else cls.DEFAULT
if isinstance(retries, Retry):
return retries
redirect = bool(redirect) and None
new_retries = cls(retries, redirect=redirect)
log.debug("Converted retries value: %r -> %r", retries, new_retries)
return new_retries
def get_backoff_time(self):
""" Formula for computing the current backoff
:rtype: float
"""
# We want to consider only the last consecutive errors sequence (Ignore redirects).
consecutive_errors_len = len(list(takewhile(lambda x: x.redirect_location is None,
reversed(self.history))))
if consecutive_errors_len <= 1:
return 0
backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1))
return min(self.BACKOFF_MAX, backoff_value)
def parse_retry_after(self, retry_after):
# Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4
if re.match(r"^\s*[0-9]+\s*$", retry_after):
seconds = int(retry_after)
else:
retry_date_tuple = email.utils.parsedate(retry_after)
if retry_date_tuple is None:
raise InvalidHeader("Invalid Retry-After header: %s" % retry_after)
retry_date = time.mktime(retry_date_tuple)
seconds = retry_date - time.time()
if seconds < 0:
seconds = 0
return seconds
def get_retry_after(self, response):
""" Get the value of Retry-After in seconds. """
retry_after = response.getheader("Retry-After")
if retry_after is None:
return None
return self.parse_retry_after(retry_after)
def sleep_for_retry(self, response=None):
retry_after = self.get_retry_after(response)
if retry_after:
time.sleep(retry_after)
return True
return False
def _sleep_backoff(self):
backoff = self.get_backoff_time()
if backoff <= 0:
return
time.sleep(backoff)
def sleep(self, response=None):
""" 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.
"""
if response:
slept = self.sleep_for_retry(response)
if slept:
return
self._sleep_backoff()
def _is_connection_error(self, err):
""" Errors when we're fairly sure that the server did not receive the
request, so it should be safe to retry.
"""
return isinstance(err, ConnectTimeoutError)
def _is_read_error(self, err):
""" Errors that occur after the request has been started, so we should
assume that the server began processing it.
"""
return isinstance(err, (ReadTimeoutError, ProtocolError))
def _is_method_retryable(self, method):
""" Checks if a given HTTP method should be retried upon, depending if
it is included on the method whitelist.
"""
if self.method_whitelist and method.upper() not in self.method_whitelist:
return False
return True
def is_retry(self, method, status_code, has_retry_after=False):
""" 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)
"""
if not self._is_method_retryable(method):
return False
if self.status_forcelist and status_code in self.status_forcelist:
return True
return (self.total and self.respect_retry_after_header and
has_retry_after and (status_code in self.RETRY_AFTER_STATUS_CODES))
def is_exhausted(self):
""" Are we out of retries? """
retry_counts = (self.total, self.connect, self.read, self.redirect, self.status)
retry_counts = list(filter(None, retry_counts))
if not retry_counts:
return False
return min(retry_counts) < 0
def increment(self, method=None, url=None, response=None, error=None,
_pool=None, _stacktrace=None):
""" 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.
"""
if self.total is False and error:
# Disabled, indicate to re-raise the error.
raise six.reraise(type(error), error, _stacktrace)
total = self.total
if total is not None:
total -= 1
connect = self.connect
read = self.read
redirect = self.redirect
status_count = self.status
cause = 'unknown'
status = None
redirect_location = None
if error and self._is_connection_error(error):
# Connect retry?
if connect is False:
raise six.reraise(type(error), error, _stacktrace)
elif connect is not None:
connect -= 1
elif error and self._is_read_error(error):
# Read retry?
if read is False or not self._is_method_retryable(method):
raise six.reraise(type(error), error, _stacktrace)
elif read is not None:
read -= 1
elif response and response.get_redirect_location():
# Redirect retry?
if redirect is not None:
redirect -= 1
cause = 'too many redirects'
redirect_location = response.get_redirect_location()
status = response.status
else:
# Incrementing because of a server error like a 500 in
# status_forcelist and a the given method is in the whitelist
cause = ResponseError.GENERIC_ERROR
if response and response.status:
if status_count is not None:
status_count -= 1
cause = ResponseError.SPECIFIC_ERROR.format(
status_code=response.status)
status = response.status
history = self.history + (RequestHistory(method, url, error, status, redirect_location),)
new_retry = self.new(
total=total,
connect=connect, read=read, redirect=redirect, status=status_count,
history=history)
if new_retry.is_exhausted():
raise MaxRetryError(_pool, url, error or ResponseError(cause))
log.debug("Incremented Retry for (url='%s'): %r", url, new_retry)
return new_retry
def __repr__(self):
return ('{cls.__name__}(total={self.total}, connect={self.connect}, '
'read={self.read}, redirect={self.redirect}, status={self.status})').format(
cls=type(self), self=self)
# For backwards compatibility (equivalent to pre-v1.9):
Retry.DEFAULT = Retry(3)
PK ! qCA A # __pycache__/__init__.cpython-38.pycnu [ U
afY @ sR d dl mZ d dlZd dlZd dlZeedddZdd Zd eedd d
Z dS ) ) b64encodeN)sreturnc C s t | S )z?Return `s` base64-encoded.
:param s: string to encode
)r encodedecode)r r Q/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/__init__.pyb64str s r c C s t |tr tttt| |S t |ttf}|s^zt |ttt t
f}W n t k
r\ Y nX |rt |drtttt| |
S tttt| |S t |dr|| S | |S )z!Homomorphic mapping of a functionitemsfmap)
isinstancetuplemap functoolspartialr listdictfilterziprange TypeErrorhasattrr
)funcobjZ
iterableitemsr r r r s
r )lengthr c sJ | st dd} tjdddddd d fddt| D S ) z}Create a random password.
:param length: An int specifying password length
:returns: the password, in cleartext
" '\c s" g | ]}t tjtj qS r )randomchoicestringdigits
ascii_letters).0XZedited_punctuationr r
0 s z#random_password..)r! randintr# punctuationreplacejoinr )r r r( r random_password' s r. )N)
base64r r r! r# strr r intr. r r r r s PK ! &CC CC " __pycache__/execute.cpython-38.pycnu [ U
afN @ s d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlmZm Z m
Z
m Z d dlm Z d dl
mZ d dlmZ eddZe eZd e Ze eeef Zejd
krd dlZd d lm Z d d lm Z eZ eZ eZ eZ!dd
ej"e j#dddddddf eeeeeeeee e!e e e$d
ddZ%ne$dddZ%dd Z&dd Z'dd Z(dd Z)G dd d Z*d d Z+G d d d Z,dd&d'Z/d?eee$e eeef d(d)d*Z0d@e
eef ee$e e ee eeef d+d,d-Z1dAe
eef ee$e e ee eeef d+d.d/Z2dBe
ee e f eee$ee e$eef d0d1d2Z3dCe e ee
ee e f f ee$ee e$eef d3d4d5Z4e
eef e eeef d6d7d8Z5ee eeef d9d:d;Z6dS )D N)Path)AnyTupleUnionList) list2cmdline)ByteSize)fmap )ZKiBytes win32)shellcon)shellopen)
file_nameparamsverbshowmaskdir_nameid_listclass_id class_keyhot_keymonitorwindowreturnc
s t tdd fdd } i | d| | d| | d| | d| | d | | d
| | d | | d | | d
| | d| | d| | d|
tjf S )a
Wrapper for the Win32 API call ShellExecuteEx. This function can be used on Windows platforms any time Nydus
needs to restart itself for any reason because ShellExecuteEx allows the child process to survive after its
parent process stops. Initially added to resolve a DLL conflict issue, this could also be useful for
upgrading Nydus, for example.
Further information for ShellExecuteEx can be found at
https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shellexecuteexa
:param file_name: The name of the executable to be started. ShellExecuteEx also handles file associations,
so this could also be the name of a document, for example, to be opened with the
associated application, or a URL to be opened by the user's default browser.
:param params: Parameters to be passed to the application. Should not be specified if file_name
is NOT an executable file.
:param verb: Action to take. May be one of 'edit', 'explore', 'find', 'open', 'print', 'properties' or
'runas'. Defaults to 'open'
:param show: Specify how an application is to be shown
:param mask: Flags that indicate content and validity of other parameters
:param dir_name: Name of the working directory. If None, the current directory is used
:param id_list: See Microsoft documentation at the URL above
:param class_id: See Microsoft documentation at the URL above
:param class_key: See Microsoft documentation at the URL above
:param hot_key: See Microsoft documentation at the URL above
:param monitor: See Microsoft documentation at the URL above
:param window: See Microsoft documentation at the URL above
:return: True if the file/application is successfully launched; otherwise, False
N)keyvalr c s |dk r| | < dS )aC
It is an error to include a field with a value of None in the structure passed to ShellExecuteEx, so this
function only adds a key to the dictionary if the value is not None.
:param key: The name of the SHELLEXECUTEINFO field
:param val: The value of the field
N )r r Zshell_execute_infor P/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/execute.py add_fieldK s z shell_start..add_fieldZfMaskZhwndZlpVerbZlpFileZ lpParametersZ lpDirectoryZnShowZlpIDListZlpClassZ hkeyClassZdwHotKeyZhMonitor)strr r ZShellExecuteEx)
r r r r r r r r r r r r r" r r r! shell_start$ s '
r$ )r c K s dS NTr )kwargsr r r! r$ f s c C s d| S )Nz| r )liner r r! pfxj s r( c C s t tt| S N)listmapr( )linesr r r! pfxsn s r- c C s | dk r| | dd}| d}|s,|S t|dkrH|d sHg S t|dk r\t|S t|dd dt|d g |d
d S ) z0Converts input blob to lines... but not too manyN <>
r z...elided %d lines...
)replacestripsplitlenr- )inpoutZoutlr r r! trim_visible_output_to_linesr s r; c c s* | }|r&|dD ]}d| V qdS )z0Converts error blob into lines with prefix marksr0 zERR: N)r6 r7 )ZerrOutseLr r r! mark_error_output s r> c @ s* e Zd ZdZd ddZdd Zdd ZdS )
EndsBuffera String buffer that maintains two segments: a first segment and a
last segment (i.e. the two ends), where each has a maximum size
limit. Any extra output in between these is discarded. The
assumption is that if there is a huge amount of output that
some must be discarded to avoid memory overflows and that
generally the first and last stuff is the most relevant.
Nc C s( t td|p dpt| _d| _d| _d S )Nr F)r maxDEFAULT_MAX_SEGMENT_SIZE_mss_data_elided)selfZmax_segment_sizer r r! __init__ s zEndsBuffer.__init__c C sT | j |7 _ t| j | jd krP| j d | j | j t| j d | _ d| _d S Nr T)rD r8 rC intrE )rF datar r r! add_str s (zEndsBuffer.add_strc C s: | j r4d| jd | j d| jt| j d gS | jS )Nr0 z...[elided]...)rE joinrD rC rI rF r r r!
get_bufstr s zEndsBuffer.get_bufstr)N)__name__
__module__ __qualname____doc__rG rK rN r r r r! r? s
r? c C s z| j dddW S tk
rx z>dd l}z | || d W W Y S tk
rZ Y nX W n tk
rr Y nX Y n tk
r | Y S X d S )Nutf-8backslashreplace)errorsr encoding)decodeUnicodeDecodeErrorchardetdetect ImportErrorAttributeError)ZbytestrrY r r r! str_form s
r] c @ s: e Zd ZefddZdd Zdd Zdd Zd
d
d Zd S )RunningCommandc C s\ || _ || _|| _|pt|fdd| _|| _t| jd | _t| jd | _d| _ d| _
d S )Nc S s t || r|sdndS )Nerrorinfo)getattr)rZ_ler r r! s z)RunningCommand.__init__..r F) ptagstdInputLOGlogger_bufsizer? _output_errors_partial
_completed)rF popen_objrf rg errorOKri max_buffer_sizer r r! rG s zRunningCommand.__init__c C s> | j t| jj | jt| jj | j d k S r) ) rk rK r] re stdoutreadrl stderrpollrM r r r! checkIfCompleted s z RunningCommand.checkIfCompletedc C sB | j }| j }t| jd | _ t| jd | _d| _||fS rH )rk rN rl r? rj rm rF orc r r r! outputToDate s
zRunningCommand.outputToDatec C s6 t t| j \}}| j| | j| d| _| S r% )r r] re communicaterk rK rl rn rw r r r! waitForCompletion s
z RunningCommand.waitForCompletionFc C s | j s| | j | j }}t| j|}|rBdd |D }|tt| d| j j
g D ]$}| j d | }| | j j
| q`| j j
|
|
fS )Nc S s g | ]}| d r|ndqS )r. <>)
startswith).0r' r r r!
s z,RunningCommand.getResult..z ExitCode: %d )rn r{ rk rN rl r; rg r* r> re
returncoderf ri r6 )rF
omitOutputoutserrsZ output_linesr' Zlstrr r r! getResult s
zRunningCommand.getResultN)F) rO rP rQ MAX_COMMAND_RESPONSE_BUFFER_SIZErG rv ry r{ r r r r r! r^ s
r^ Fc C s t | trd| n| }d} t |trF|dk rBt |trB|d}d} |rV||| }|dkrbt}||d t| t j
| |t j t j t j |d}
|r|
j
| t|
||||S )a Starts the specified command; no Shell. The cmd is expected to be an
array of strings, although it is also possible to specify
simply a string if there are no arguments to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
The command is run asynchronously in a separate process. The
return value is a RunningCommand object that supports a
.checkIfCompleted() method to test for subprocess completion
(non-blocking) and a .getResult() to get the ProcOpResult of a
completed process (will block until completion if not already
completed).
r r| NrS s <>z RUN: )r rr stdinrt env)
isinstancer* rL bytesr# encoder5 rh r`
subprocessPopenPIPEr writer^ ) cmdrf useShellrg rp ri
omitStringr Zlog_cmdZ replace_textre r r r! startCommand s*
r c
C s$ t | |||||||d j|dS )a Runs the specified command and waits for completion; no Shell. The
cmd is expected to be an array of strings, although it is also
possible to specify simply a string if there are no arguments
to the command.
The tag value is only used to annotate log lines for
distinctive tagging in the logging output.
If errorOK is True then a non-zero return code is still only
logged as "info" instead of "error". The ProcOpResult will
accurately reflect the result of the operation regardless of
the errorOK argument.
If omitString is specified, it is removed from any logging output.
)r rg rp ri r r )r )r r{ r ) r rf r rg rp ri r r r r r r!
runCommand s
r c
C sF t j| |t jd}|& | \}}|j||fW 5 Q R S Q R X dS )z(Used to run commands that make use of | )r rr N)r r r rz r )r r re rx rc r r r! run_command_pipe; s r )commandrf quietr c C sZ t jddddd}z4|| | |s6td| t |j||W S t|j X dS )) Execute the code in ``command`` using PowerShell.
:param command: Code to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:return: Tuple containing (exit_code, stdout, stderr)
w+tz utf-8-sig.ps1F)moderV suffixdeletez Running PowerShell command: %sN)
tempfileNamedTemporaryFileosunlinknamer closerh debugrun_powershell_file)r rf r tempr r r! run_powershellC s
r ) script_filerf r script_file_argsr r c C s8 dt | g}|r(|D ]}|t | qt||||dS )a Invoke Shell script, passing just ``filename`` or ``filepath`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
Zbashrg r r# appendr r rf r r r r argr r r! run_shell_script_filea s
r c C s> ddddt | g}|r.|D ]}|t | qt||||dS )a Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:param stdin: string to pass through standard input
:return: Tuple containing (exit_code, stdout, stderr)
powershell.exe-ExecutionPolicy Unrestricted-Filer r r r r r! r t s
r )cmd_list descriptionop_name use_shell omit_stringr c C sX t | }|r||d}td|| t| |||d\}}}td|||| |||fS )a Run a command on the target machine
:param cmd_list: string or list of strings that represents a command to be executed
:param description: short description of what the command is doing
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
r| z run_uapi_command %s cmd_list: %s)r r z%s_result- %s - %s - %s)r# r5 rh r r ) r r r r r Z cmd_list_str exit_coder r r r r! run_uapi_command s r ) cmds_listr r r r c C sP d\}}}| D ]6\}}t |||||d\}}}|dkr|||f S q|||fS )a Run a command on the target machine
:param cmds_list: List of tuples with description-command pairs
:param op_name: name of the operation that is running the command
:param use_shell: indicator that the command should be executed in a shell
:param omit_string: a string to be removed from any logging output.
:return: Tuple containing (exit_code, stdout, stderr)
)r r@ r@ )r r r )r ) r r r r r r r r r r r r! run_multiple_uapi_commands s
r )r r c C s> t dddt| g}td| td|dr0dnd}|d d fS )
a
Invoke PowerShell, passing just ``filename`` or ``filename`` and a list of arguments for execution of the file.
Do not wait for the sub-process to complete. The exit code returned in the tuple only indicates whether or
not the process was successfully started.
:param script_file: The path of the script file to execute
:param tag: Short string that will be added to logs to improve searchability.
:param quiet: Omit the output of the command from the result.
:param script_file_args: List of string arguments if required while execution of the file
:return: Tuple containing (exit_code, stdout, stderr)
r r r z%Staring PowerShell: powershell.exe %sr )r r r/ r@ )r r# rh r` r$ )r r coder r r! start_powershell_file s
r )r r c C s8 t jdddd}|| | td| t|jS )r r r F)r r r z Running Powershell command: %s)r r r r rh r r r )r r r r r! start_powershell s
r )FNFNNN)FNFNNFN)F)F)FNN)FNN)FN)FN)7loggingr sysr r pathlibr typingr r r r r Zprimordial.sizesr Zcustomer_local_ops.utilr rB getLoggerrO rh r rI r# ZRunCommandResultplatformZwin32conwin32com.shellr
r ZHANDLEZHWNDZHKEYZDWORDZ
SW_SHOWNORMALZSEE_MASK_FLAG_DDEWAITboolr$ r( r- r; r> r? r] r^ r r r r r r r r r r r r r r! s
B 6
3
"PK ! -
" __pycache__/helpers.cpython-38.pycnu [ U
afl @ sx d Z ddlmZ ddlmZ ddlmZ ddlZG dd deZ dd Z
dd d Z dd
dZ dd Z
dd Zdd ZdS )u$ © Copyright. All rights reserved.
)unicode_literals) FileInputreduceNc @ s e Zd ZdS )HandledFailureExceptionN)__name__
__module__ __qualname__ r
r
P/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/helpers.pyr s r c C s8 t | fdd }|D ]}tj|| qW 5 Q R X dS )zIterates through the lines of the named file, calling the editfunc
for each line, replacing the original file with the new
output.
TfilesZinplaceN)r sysstdoutwrite)filenameZeditfuncfliner
r
r edit_file_lines s r Tc C sX t | fdd@}|D ]4}|}| D ]\}}t||||}q$tj| qW 5 Q R X dS )zIterates through the lines of the named file, and through a
dictionary of match -> replace pairs, replacing all that apply for each line,
and replacing the original file with the new output.
Tr N)r items replace_liner r r )r Z replace_dict firstwordr r Z updated_linematchreplacer
r
r replace_file_lines_multiple s r c C sB | |ks:|r,| |d s:| |d s:|s>| |r>|S | S )am Checks `line` to see if it starts with `match`; if yes, return
`replace`, otherwise return the original `line`. If
`firstword` is True, then the match must be followed by at
least one space or tab (unless it matches the entire line),
otherwise it is matched directly.
Suitable for use as an editfunc with `edit_file_lines`.
)strip
startswith)r r r r r
r
r r ) s
r c C s2 t | ddd}|d || W 5 Q R X dS )z-Appends a line to to the specified file.
aUTF-8encoding
Nopenr )r r filer
r
r append_line< s
r' c C s( t | ddd}|| W 5 Q R X dS )z{Creates the specified file, with the specified contents.
Overwrites any file already existing at that location.
wr r! Nr$ )r contentsZwfr
r
r create_fileD s r* c G s t dd | dd S )Nc s fddS )Nc s | S Nr
xr gr
r M z+compose....r
r. r
r. r r0 M r1 zcompose..c S s | S r+ r
r, r
r
r r0 M r1 r )funcsr
r
r composeL s r3 )T)T)__doc__
__future__r Z fileinputr functoolsr r Exceptionr r r r r' r* r3 r
r
r
r s
PK ! v __pycache__/retry.cpython-38.pycnu [ U
af` @ s` d Z ddlmZ ddlmZmZ ddlmZ ddlZee Z
G dd dZ e Z d d
d Z
dS )
u$ © Copyright. All rights reserved.
)unicode_literals)datetime timedeltawrapsNc @ s" e Zd ZdZdddZdd ZdS )RetryzOps decorated with @retry can return a Retry instance to request retry
with the interval and timeout as specified in the decorator. See also the
RETRY sentinel if there is no intermediate_result.
Nc C s, |d ks"t |ts"tdt| || _d S )Nz7Retry intermediate_result must be dictionary but got %s)
isinstancedict TypeErrortypeintermediate_result)selfr r N/opt/nydus/tmp/pip-target-53d1vnqk/lib/python/customer_local_ops/util/retry.py__init__ s zRetry.__init__c C s dt | j S )NzRetry )str__dict__)r
r r r __str__ s z
Retry.__str__)N)__name__
__module__ __qualname____doc__r r r r r r r s
r < c s fdd}|S )zOp decorator that returns a retry request to Nydus when the op returns
a Retry instance. Op will be retried by Nydus after `interval` seconds.
Returns failure at the specified timeout (seconds).
c s t fdd}|S )Nc s | dd }t }|r"| dp.|td }||kr^dtdd}t| d|fS | |}t|t r|j
pzi }| d| d| fS |S )Nr timeout)secondsz Timeout waiting for {} ({}s)r ?F) getr utcnowr formatgetattrLOGerrorr r r
setdefault)argskwr nowZ timeout_absmsgresultZir)intervaloriginalr r r wrapper, s"
z$retry..deco..wrapperr )r* r+ r) r )r* r deco+ s zretry..decor )r) r r- r r, r retry% s r. )r r )r
__future__r r r functoolsr logging getLoggerr r! r RETRYr. r r r r s
PK ! t __init__.pycnu [
abc @@ s d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z m
Z
m Z m Z m
Z
m Z m Z m Z d d l m Z m Z d d l m Z d d l m Z m Z m Z m Z d d
l m Z m Z d Z d S(! i ( t absolute_importi ( t is_connection_dropped( t make_headers( t is_fp_closed( t
SSLContextt HAS_SNIt IS_PYOPENSSLt IS_SECURETRANSPORTt assert_fingerprintt resolve_cert_reqst resolve_ssl_versiont ssl_wrap_socket( t current_timet Timeout( t Retry( t get_hostt parse_urlt split_firstt Url( t
wait_for_readt wait_for_writeR R R R R R
R R R R R R R R R R
R R R R N( R R R R R R
R R R R R R R R R R
R R R R ( t
__future__R t
connectionR t requestR t responseR t ssl_R R R R R R R
R t timeoutR R
t retryR t urlR R R R t waitR R t __all__( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/__init__.pyt s8 :
" PK ! t __init__.pyonu [
abc @@ s d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z m
Z
m Z m Z m
Z
m Z m Z m Z d d l m Z m Z d d l m Z d d l m Z m Z m Z m Z d d
l m Z m Z d Z d S(! i ( t absolute_importi ( t is_connection_dropped( t make_headers( t is_fp_closed( t
SSLContextt HAS_SNIt IS_PYOPENSSLt IS_SECURETRANSPORTt assert_fingerprintt resolve_cert_reqst resolve_ssl_versiont ssl_wrap_socket( t current_timet Timeout( t Retry( t get_hostt parse_urlt split_firstt Url( t
wait_for_readt wait_for_writeR R R R R R
R R R R R R R R R R
R R R R N( R R R R R R
R R R R R R R R R R
R R R R ( t
__future__R t
connectionR t requestR t responseR t ssl_R R R R R R R
R t timeoutR R
t retryR t urlR R R R t waitR R t __all__( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/__init__.pyt s8 :
" PK ! _=
connection.pynu [ from __future__ import absolute_import
import socket
from .wait import wait_for_read
from .selectors import HAS_SELECT, SelectorError
def is_connection_dropped(conn): # Platform-specific
"""
Returns True if the connection is dropped and should be closed.
:param conn:
:class:`httplib.HTTPConnection` object.
Note: For platforms like AppEngine, this will always return ``False`` to
let the platform handle connection recycling transparently for us.
"""
sock = getattr(conn, 'sock', False)
if sock is False: # Platform-specific: AppEngine
return False
if sock is None: # Connection already closed (such as by httplib).
return True
if not HAS_SELECT:
return False
try:
return bool(wait_for_read(sock, timeout=0.0))
except SelectorError:
return True
# This function is copied from socket.py in the Python 2.7 standard
# library test suite. Added to its signature is only `socket_options`.
# One additional modification is that we avoid binding to IPv6 servers
# discovered in DNS if the system doesn't have IPv6 functionality.
def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
source_address=None, socket_options=None):
"""Connect to *address* and return the socket object.
Convenience function. Connect to *address* (a 2-tuple ``(host,
port)``) and return the socket object. Passing the optional
*timeout* parameter will set the timeout on the socket instance
before attempting to connect. If no *timeout* is supplied, the
global default timeout setting returned by :func:`getdefaulttimeout`
is used. If *source_address* is set it must be a tuple of (host, port)
for the socket to bind as a source address before making the connection.
An host of '' or port 0 tells the OS to use the default.
"""
host, port = address
if host.startswith('['):
host = host.strip('[]')
err = None
# Using the value from allowed_gai_family() in the context of getaddrinfo lets
# us select whether to work with IPv4 DNS records, IPv6 records, or both.
# The original create_connection function always returns all records.
family = allowed_gai_family()
for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
sock = None
try:
sock = socket.socket(af, socktype, proto)
# If provided, set socket level options before connecting.
_set_socket_options(sock, socket_options)
if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
sock.settimeout(timeout)
if source_address:
sock.bind(source_address)
sock.connect(sa)
return sock
except socket.error as e:
err = e
if sock is not None:
sock.close()
sock = None
if err is not None:
raise err
raise socket.error("getaddrinfo returns an empty list")
def _set_socket_options(sock, options):
if options is None:
return
for opt in options:
sock.setsockopt(*opt)
def allowed_gai_family():
"""This function is designed to work in the context of
getaddrinfo, where family=socket.AF_UNSPEC is the default and
will perform a DNS search for both IPv6 and IPv4 records."""
family = socket.AF_INET
if HAS_IPV6:
family = socket.AF_UNSPEC
return family
def _has_ipv6(host):
""" Returns True if the system can bind an IPv6 address. """
sock = None
has_ipv6 = False
if socket.has_ipv6:
# has_ipv6 returns true if cPython was compiled with IPv6 support.
# It does not tell us if the system has IPv6 support enabled. To
# determine that we must bind to an IPv6 address.
# https://github.com/shazow/urllib3/pull/611
# https://bugs.python.org/issue658327
try:
sock = socket.socket(socket.AF_INET6)
sock.bind((host, 0))
has_ipv6 = True
except Exception:
pass
if sock:
sock.close()
return has_ipv6
HAS_IPV6 = _has_ipv6('::1')
PK ! 9 connection.pycnu [
abc @@ s d d l m Z d d l Z d d l m Z d d l m Z m Z d Z e j d d d Z d Z d Z
d
Z e d Z d S( i ( t absolute_importNi ( t
wait_for_read( t
HAS_SELECTt
SelectorErrorc C@ so t | d t } | t k r" t S| d k r2 t St s< t Sy t t | d d SWn t k
rj t SXd S( s
Returns True if the connection is dropped and should be closed.
:param conn:
:class:`httplib.HTTPConnection` object.
Note: For platforms like AppEngine, this will always return ``False`` to
let the platform handle connection recycling transparently for us.
t sockt timeoutg N( t getattrt Falset Nonet TrueR t boolR R ( t connR ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt is_connection_dropped s
c C@ sO | \ } } | j d r- | j d } n d } t } x t j | | | t j D] } | \ } }
} } }
d } yl t j | |
| } t | | | t j k r | j | n | r | j
| n | j |
| SWqX t j k
r"} | } | d k r#| j
d } q#qX XqX W| d k r<| n t j d d S( sd Connect to *address* and return the socket object.
Convenience function. Connect to *address* (a 2-tuple ``(host,
port)``) and return the socket object. Passing the optional
*timeout* parameter will set the timeout on the socket instance
before attempting to connect. If no *timeout* is supplied, the
global default timeout setting returned by :func:`getdefaulttimeout`
is used. If *source_address* is set it must be a tuple of (host, port)
for the socket to bind as a source address before making the connection.
An host of '' or port 0 tells the OS to use the default.
t [s []s! getaddrinfo returns an empty listN( t
startswitht stripR t allowed_gai_familyt sockett getaddrinfot SOCK_STREAMt _set_socket_optionst _GLOBAL_DEFAULT_TIMEOUTt
settimeoutt bindt connectt errort close( t addressR t source_addresst socket_optionst hostt portt errt familyt rest aft socktypet protot canonnamet saR t e( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt create_connection$ s2 "
c C@ s2 | d k r d Sx | D] } | j | q Wd S( N( R t
setsockopt( R t optionst opt( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyR X s
c C@ s t j } t r t j } n | S( s This function is designed to work in the context of
getaddrinfo, where family=socket.AF_UNSPEC is the default and
will perform a DNS search for both IPv6 and IPv4 records.( R t AF_INETt HAS_IPV6t AF_UNSPEC( R! ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyR ` s c C@ sr d } t } t j r[ y/ t j t j } | j | d f t } Wq[ t k
rW q[ Xn | rn | j n | S( s6 Returns True if the system can bind an IPv6 address. i N( R R R t has_ipv6t AF_INET6R R t ExceptionR ( R R R0 ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt _has_ipv6k s
s ::1( t
__future__R R t waitR t selectorsR R R R R R) R R R3 R. ( ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt s 3 PK ! 9 connection.pyonu [
abc @@ s d d l m Z d d l Z d d l m Z d d l m Z m Z d Z e j d d d Z d Z d Z
d
Z e d Z d S( i ( t absolute_importNi ( t
wait_for_read( t
HAS_SELECTt
SelectorErrorc C@ so t | d t } | t k r" t S| d k r2 t St s< t Sy t t | d d SWn t k
rj t SXd S( s
Returns True if the connection is dropped and should be closed.
:param conn:
:class:`httplib.HTTPConnection` object.
Note: For platforms like AppEngine, this will always return ``False`` to
let the platform handle connection recycling transparently for us.
t sockt timeoutg N( t getattrt Falset Nonet TrueR t boolR R ( t connR ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt is_connection_dropped s
c C@ sO | \ } } | j d r- | j d } n d } t } x t j | | | t j D] } | \ } }
} } }
d } yl t j | |
| } t | | | t j k r | j | n | r | j
| n | j |
| SWqX t j k
r"} | } | d k r#| j
d } q#qX XqX W| d k r<| n t j d d S( sd Connect to *address* and return the socket object.
Convenience function. Connect to *address* (a 2-tuple ``(host,
port)``) and return the socket object. Passing the optional
*timeout* parameter will set the timeout on the socket instance
before attempting to connect. If no *timeout* is supplied, the
global default timeout setting returned by :func:`getdefaulttimeout`
is used. If *source_address* is set it must be a tuple of (host, port)
for the socket to bind as a source address before making the connection.
An host of '' or port 0 tells the OS to use the default.
t [s []s! getaddrinfo returns an empty listN( t
startswitht stripR t allowed_gai_familyt sockett getaddrinfot SOCK_STREAMt _set_socket_optionst _GLOBAL_DEFAULT_TIMEOUTt
settimeoutt bindt connectt errort close( t addressR t source_addresst socket_optionst hostt portt errt familyt rest aft socktypet protot canonnamet saR t e( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt create_connection$ s2 "
c C@ s2 | d k r d Sx | D] } | j | q Wd S( N( R t
setsockopt( R t optionst opt( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyR X s
c C@ s t j } t r t j } n | S( s This function is designed to work in the context of
getaddrinfo, where family=socket.AF_UNSPEC is the default and
will perform a DNS search for both IPv6 and IPv4 records.( R t AF_INETt HAS_IPV6t AF_UNSPEC( R! ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyR ` s c C@ sr d } t } t j r[ y/ t j t j } | j | d f t } Wq[ t k
rW q[ Xn | rn | j n | S( s6 Returns True if the system can bind an IPv6 address. i N( R R R t has_ipv6t AF_INET6R R t ExceptionR ( R R R0 ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt _has_ipv6k s
s ::1( t
__future__R R t waitR t selectorsR R R R R R) R R R3 R. ( ( ( sG /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/connection.pyt s 3 PK ! Aay y
request.pynu [ from __future__ import absolute_import
from base64 import b64encode
from ..packages.six import b, integer_types
from ..exceptions import UnrewindableBodyError
ACCEPT_ENCODING = 'gzip,deflate'
_FAILEDTELL = object()
def make_headers(keep_alive=None, accept_encoding=None, user_agent=None,
basic_auth=None, proxy_basic_auth=None, disable_cache=None):
"""
Shortcuts for generating request headers.
:param keep_alive:
If ``True``, adds 'connection: keep-alive' header.
:param accept_encoding:
Can be a boolean, list, or string.
``True`` translates to 'gzip,deflate'.
List will get joined by comma.
String will be used as provided.
:param user_agent:
String representing the user-agent you want, such as
"python-urllib3/0.6"
:param basic_auth:
Colon-separated username:password string for 'authorization: basic ...'
auth header.
:param proxy_basic_auth:
Colon-separated username:password string for 'proxy-authorization: basic ...'
auth header.
:param disable_cache:
If ``True``, adds 'cache-control: no-cache' header.
Example::
>>> make_headers(keep_alive=True, user_agent="Batman/1.0")
{'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
>>> make_headers(accept_encoding=True)
{'accept-encoding': 'gzip,deflate'}
"""
headers = {}
if accept_encoding:
if isinstance(accept_encoding, str):
pass
elif isinstance(accept_encoding, list):
accept_encoding = ','.join(accept_encoding)
else:
accept_encoding = ACCEPT_ENCODING
headers['accept-encoding'] = accept_encoding
if user_agent:
headers['user-agent'] = user_agent
if keep_alive:
headers['connection'] = 'keep-alive'
if basic_auth:
headers['authorization'] = 'Basic ' + \
b64encode(b(basic_auth)).decode('utf-8')
if proxy_basic_auth:
headers['proxy-authorization'] = 'Basic ' + \
b64encode(b(proxy_basic_auth)).decode('utf-8')
if disable_cache:
headers['cache-control'] = 'no-cache'
return headers
def set_file_position(body, pos):
"""
If a position is provided, move file to that point.
Otherwise, we'll attempt to record a position for future use.
"""
if pos is not None:
rewind_body(body, pos)
elif getattr(body, 'tell', None) is not None:
try:
pos = body.tell()
except (IOError, OSError):
# This differentiates from None, allowing us to catch
# a failed `tell()` later when trying to rewind the body.
pos = _FAILEDTELL
return pos
def rewind_body(body, body_pos):
"""
Attempt to rewind body to a certain position.
Primarily used for request redirects and retries.
:param body:
File-like object that supports seek.
:param int pos:
Position to seek to in file.
"""
body_seek = getattr(body, 'seek', None)
if body_seek is not None and isinstance(body_pos, integer_types):
try:
body_seek(body_pos)
except (IOError, OSError):
raise UnrewindableBodyError("An error occurred when rewinding request "
"body for redirect/retry.")
elif body_pos is _FAILEDTELL:
raise UnrewindableBodyError("Unable to record file position for rewinding "
"request body during a redirect/retry.")
else:
raise ValueError("body_pos must be of type integer, "
"instead it was %s." % type(body_pos))
PK !
request.pycnu [
abc @@ s d d l m Z d d l m Z d d l m Z m Z d d l m Z d Z e
Z d
d
d
d
d
d
d Z
d Z d Z d
S( i ( t absolute_import( t b64encodei ( t bt
integer_types( t UnrewindableBodyErrors gzip,deflatec C@ s i } | rR t | t r n' t | t r? d j | } n t } | | d >> make_headers(keep_alive=True, user_agent="Batman/1.0")
{'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
>>> make_headers(accept_encoding=True)
{'accept-encoding': 'gzip,deflate'}
t ,s accept-encodings
user-agents
keep-alivet
connections Basic s utf-8t
authorizations proxy-authorizations no-caches
cache-control( t
isinstancet strt listt joint ACCEPT_ENCODINGR R t decode( t
keep_alivet accept_encodingt
user_agentt
basic_autht proxy_basic_autht
disable_cachet headers( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyt make_headers s* $
##
c C@ sk | d k r t | | nK t | d d d k rg y | j } Wqg t t f k
rc t } qg Xn | S( s
If a position is provided, move file to that point.
Otherwise, we'll attempt to record a position for future use.
t tellN( t Nonet rewind_bodyt getattrR t IOErrort OSErrort _FAILEDTELL( t bodyt pos( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyt set_file_positionM s
c C@ s t | d d } | d k rd t | t rd y | | Wq t t f k
r` t d q Xn1 | t k r t d n t d t | d S( s
Attempt to rewind body to a certain position.
Primarily used for request redirects and retries.
:param body:
File-like object that supports seek.
:param int pos:
Position to seek to in file.
t seeksA An error occurred when rewinding request body for redirect/retry.sR Unable to record file position for rewinding request body during a redirect/retry.s4 body_pos must be of type integer, instead it was %s.N(
R R R R R R R R t
ValueErrort type( R t body_post body_seek( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyR _ s N( t
__future__R t base64R t packages.sixR R t
exceptionsR R t objectR R R R R ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyt s A PK !
request.pyonu [
abc @@ s d d l m Z d d l m Z d d l m Z m Z d d l m Z d Z e
Z d
d
d
d
d
d
d Z
d Z d Z d
S( i ( t absolute_import( t b64encodei ( t bt
integer_types( t UnrewindableBodyErrors gzip,deflatec C@ s i } | rR t | t r n' t | t r? d j | } n t } | | d >> make_headers(keep_alive=True, user_agent="Batman/1.0")
{'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
>>> make_headers(accept_encoding=True)
{'accept-encoding': 'gzip,deflate'}
t ,s accept-encodings
user-agents
keep-alivet
connections Basic s utf-8t
authorizations proxy-authorizations no-caches
cache-control( t
isinstancet strt listt joint ACCEPT_ENCODINGR R t decode( t
keep_alivet accept_encodingt
user_agentt
basic_autht proxy_basic_autht
disable_cachet headers( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyt make_headers s* $
##
c C@ sk | d k r t | | nK t | d d d k rg y | j } Wqg t t f k
rc t } qg Xn | S( s
If a position is provided, move file to that point.
Otherwise, we'll attempt to record a position for future use.
t tellN( t Nonet rewind_bodyt getattrR t IOErrort OSErrort _FAILEDTELL( t bodyt pos( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyt set_file_positionM s
c C@ s t | d d } | d k rd t | t rd y | | Wq t t f k
r` t d q Xn1 | t k r t d n t d t | d S( s
Attempt to rewind body to a certain position.
Primarily used for request redirects and retries.
:param body:
File-like object that supports seek.
:param int pos:
Position to seek to in file.
t seeksA An error occurred when rewinding request body for redirect/retry.sR Unable to record file position for rewinding request body during a redirect/retry.s4 body_pos must be of type integer, instead it was %s.N(
R R R R R R R R t
ValueErrort type( R t body_post body_seek( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyR _ s N( t
__future__R t base64R t packages.sixR R t
exceptionsR R t objectR R R R R ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/request.pyt s A PK ! 9 ' ' response.pynu [ from __future__ import absolute_import
from ..packages.six.moves import http_client as httplib
from ..exceptions import HeaderParsingError
def is_fp_closed(obj):
"""
Checks whether a given file-like object is closed.
:param obj:
The file-like object to check.
"""
try:
# Check `isclosed()` first, in case Python3 doesn't set `closed`.
# GH Issue #928
return obj.isclosed()
except AttributeError:
pass
try:
# Check via the official file-like-object way.
return obj.closed
except AttributeError:
pass
try:
# Check if the object is a container for another file-like object that
# gets released on exhaustion (e.g. HTTPResponse).
return obj.fp is None
except AttributeError:
pass
raise ValueError("Unable to determine whether fp is closed.")
def assert_header_parsing(headers):
"""
Asserts whether all headers have been successfully parsed.
Extracts encountered errors from the result of parsing headers.
Only works on Python 3.
:param headers: Headers to verify.
:type headers: `httplib.HTTPMessage`.
:raises urllib3.exceptions.HeaderParsingError:
If parsing errors are found.
"""
# This will fail silently if we pass in the wrong kind of parameter.
# To make debugging easier add an explicit check.
if not isinstance(headers, httplib.HTTPMessage):
raise TypeError('expected httplib.Message, got {0}.'.format(
type(headers)))
defects = getattr(headers, 'defects', None)
get_payload = getattr(headers, 'get_payload', None)
unparsed_data = None
if get_payload: # Platform-specific: Python 3.
unparsed_data = get_payload()
if defects or unparsed_data:
raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)
def is_response_to_head(response):
"""
Checks whether the request of a response has been a HEAD-request.
Handles the quirks of AppEngine.
:param conn:
:type conn: :class:`httplib.HTTPResponse`
"""
# FIXME: Can we do this somehow without accessing private httplib _method?
method = response._method
if isinstance(method, int): # Platform-specific: Appengine
return method == 3
return method.upper() == 'HEAD'
PK ! 8 response.pycnu [
abc @@ sO d d l m Z d d l m Z d d l m Z d Z d Z d Z d S( i ( t absolute_importi ( t http_client( t HeaderParsingErrorc C@ sv y | j SWn t k
r! n Xy | j SWn t k
r@ n Xy | j d k SWn t k
re n Xt d d S( st
Checks whether a given file-like object is closed.
:param obj:
The file-like object to check.
s) Unable to determine whether fp is closed.N( t isclosedt AttributeErrort closedt fpt Nonet
ValueError( t obj( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt is_fp_closed s
c C@ s t | t j s0 t d j t | n t | d d } t | d d } d } | rl | } n | sx | r t d | d | n d S( sP
Asserts whether all headers have been successfully parsed.
Extracts encountered errors from the result of parsing headers.
Only works on Python 3.
:param headers: Headers to verify.
:type headers: `httplib.HTTPMessage`.
:raises urllib3.exceptions.HeaderParsingError:
If parsing errors are found.
s" expected httplib.Message, got {0}.t defectst get_payloadt
unparsed_dataN( t
isinstancet httplibt HTTPMessaget TypeErrort formatt typet getattrR R ( t headersR R R
( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt assert_header_parsing& s c C@ s2 | j } t | t r" | d k S| j d k S( s
Checks whether the request of a response has been a HEAD-request.
Handles the quirks of AppEngine.
:param conn:
:type conn: :class:`httplib.HTTPResponse`
i t HEAD( t _methodR t intt upper( t responset method( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt is_response_to_headE s
N(
t
__future__R t packages.six.movesR R t
exceptionsR R
R R ( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt s
PK ! 8 response.pyonu [
abc @@ sO d d l m Z d d l m Z d d l m Z d Z d Z d Z d S( i ( t absolute_importi ( t http_client( t HeaderParsingErrorc C@ sv y | j SWn t k
r! n Xy | j SWn t k
r@ n Xy | j d k SWn t k
re n Xt d d S( st
Checks whether a given file-like object is closed.
:param obj:
The file-like object to check.
s) Unable to determine whether fp is closed.N( t isclosedt AttributeErrort closedt fpt Nonet
ValueError( t obj( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt is_fp_closed s
c C@ s t | t j s0 t d j t | n t | d d } t | d d } d } | rl | } n | sx | r t d | d | n d S( sP
Asserts whether all headers have been successfully parsed.
Extracts encountered errors from the result of parsing headers.
Only works on Python 3.
:param headers: Headers to verify.
:type headers: `httplib.HTTPMessage`.
:raises urllib3.exceptions.HeaderParsingError:
If parsing errors are found.
s" expected httplib.Message, got {0}.t defectst get_payloadt
unparsed_dataN( t
isinstancet httplibt HTTPMessaget TypeErrort formatt typet getattrR R ( t headersR R R
( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt assert_header_parsing& s c C@ s2 | j } t | t r" | d k S| j d k S( s
Checks whether the request of a response has been a HEAD-request.
Handles the quirks of AppEngine.
:param conn:
:type conn: :class:`httplib.HTTPResponse`
i t HEAD( t _methodR t intt upper( t responset method( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt is_response_to_headE s
N(
t
__future__R t packages.six.movesR R t
exceptionsR R
R R ( ( ( sE /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/response.pyt s
PK ! ML9 9 retry.pycnu [
abc @@ s d d l m Z d d l Z d d l Z d d l m Z d d l m Z d d l Z d d l Z d d l
m Z m Z m
Z
m Z m Z m Z d d l m Z e j e Z e d d d
d d d
g Z d e f d YZ e d e _ d S( i ( t absolute_importN( t
namedtuple( t takewhilei ( t ConnectTimeoutErrort
MaxRetryErrort
ProtocolErrort ReadTimeoutErrort
ResponseErrort
InvalidHeader( t sixt RequestHistoryt methodt urlt errort statust redirect_locationt Retryc B@ s4 e Z d Z e d d d d d d g Z e d g Z e d d d
g Z d Z d d d d d e d d
e e d e e d
Z
d Z e e d d Z
d Z d Z d Z d d Z d Z d d Z d Z d Z d Z e d Z d Z d d d d d d d Z d Z RS( s2 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 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
: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.
t HEADt GETt PUTt DELETEt OPTIONSt TRACEt
Authorizationi i i ix i
i c C@ s | | _ | | _ | | _ | | _ | t k s< | t k rK d } t } n | | _ | p` t | _ | | _ | | _ | | _
|
| _ | p t | _
| | _ |
| _ d S( Ni ( t totalt connectt readR t Falset redirectt sett status_forcelistt method_whitelistt backoff_factort raise_on_redirectt raise_on_statust tuplet historyt respect_retry_after_headert remove_headers_on_redirect( t selfR R R R R R R R R! R" R$ R% R& ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt __init__ s c K@ s t d | j d | j d | j d | j d | j d | j d | j d | j d | j d
| j
d | j d | j } | j
| t | | S(
NR R R R R R R R R! R" R$ R& ( t dictR R R R R R R R R! R" R$ R& t updatet type( R' t kwt params( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt new s $
c C@ sx | d k r* | d k r | n | j } n t | t r= | St | oL d } | | d | } t j d | | | S( s4 Backwards-compatibility for the old retries format.R s! Converted retries value: %r -> %rN( t Nonet DEFAULTt
isinstanceR t boolt logt debug( t clst retriesR t defaultt new_retries( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt from_int s c C@ s\ t t t d t | j } | d k r7 d S| j d | d } t | j | S( sJ Formula for computing the current backoff
:rtype: float
c S@ s
| j d k S( N( R R/ ( t x( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt t i i i ( t lent listR t reversedR$ R t mint BACKOFF_MAX( R' t consecutive_errors_lent
backoff_value( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt get_backoff_time s c C@ s t j d | r! t | } nP t j j | } | d k rR t d | n t j | } | t j } | d k r d } n | S( Ns ^\s*[0-9]+\s*$s Invalid Retry-After header: %si (
t ret matcht intt emailt utilst parsedateR/ R t timet mktime( R' t retry_aftert secondst retry_date_tuplet
retry_date( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt parse_retry_after s c C@ s, | j d } | d k r d S| j | S( s* Get the value of Retry-After in seconds. s Retry-AfterN( t getheaderR/ RQ ( R' t responseRM ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt get_retry_after s c C@ s* | j | } | r& t j | t St S( N( RT RK t sleept TrueR ( R' RS RM ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt sleep_for_retry s
c C@ s- | j } | d k r d St j | d S( Ni ( RD RK RU ( R' t backoff( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _sleep_backoff s c C@ s0 | r" | j | } | r" d Sn | j d S( sC 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( RW RY ( R' RS t slept( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyRU s
c C@ s
t | t S( s{ Errors when we're fairly sure that the server did not receive the
request, so it should be safe to retry.
( R1 R ( R' t err( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _is_connection_error s c C@ s t | t t f S( s Errors that occur after the request has been started, so we should
assume that the server began processing it.
( R1 R R ( R' R[ ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _is_read_error! s c C@ s& | j r" | j | j k r" t St S( s| Checks if a given HTTP method should be retried upon, depending if
it is included on the method whitelist.
( R t upperR RV ( R' R ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _is_method_retryable' s c C@ sT | j | s t S| j r/ | | j k r/ t S| j oS | j oS | oS | | j k S( sx 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)
( R_ R R RV R R% t RETRY_AFTER_STATUS_CODES( R' R t status_codet has_retry_after( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt is_retry0 s c C@ sS | j | j | j | j | j f } t t d | } | sC t St | d k S( s Are we out of retries? i N(
R R R R R R> t filterR/ R R@ ( R' t retry_counts( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt is_exhausted@ s
$c
C@ s | j t k r3 | r3 t j t | | | n | j } | d k rU | d 8} n | j } | j } | j }
| j } d } d }
d } | r | j
| r | t k r t j t | | | q| d k r| d 8} qn | rQ| j | rQ| t k s| j | r5t j t | | | q| d k r| d 8} qn | r| j
r|
d k r||
d 8}
n d } | j
} | j }
nU t j } | r| j r| d k r| d 8} n t j j d | j } | j }
n | j t | | | |
| f } | j d | d | d | d |
d | d
| } | j rnt | | | pet | n t j d | | | S(
s 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.
i t unknowns too many redirectsRa R R R R R R$ s$ Incremented Retry for (url='%s'): %rN( R R R t reraiseR+ R/ R R R R R\ R] R_ t get_redirect_locationR t
GENERIC_ERRORt SPECIFIC_ERRORt formatR$ R
R. Rf R R3 R4 ( R' R R RS R
t _poolt _stacktraceR R R R t status_countt causeR R R$ t new_retry( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt incrementI sX
" !c C@ s d j d t | d | S( Ns| {cls.__name__}(total={self.total}, connect={self.connect}, read={self.read}, redirect={self.redirect}, status={self.status})R5 R' ( Rl R+ ( R' ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt __repr__ s N( t __name__t
__module__t __doc__t frozensett DEFAULT_METHOD_WHITELISTt" DEFAULT_REDIRECT_HEADERS_BLACKLISTR` RA R/ RV R( R. t classmethodR9 RD RQ RT RW RY RU R\ R] R_ R Rc Rf Rr Rs ( ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyR s8 x
Ji ( t
__future__R RK t loggingt collectionsR t itertoolsR RH RE t
exceptionsR R R R R R t packagesR t getLoggerRt R3 R
t objectR R0 ( ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt s . PK ! ML9 9 retry.pyonu [
abc @@ s d d l m Z d d l Z d d l Z d d l m Z d d l m Z d d l Z d d l Z d d l
m Z m Z m
Z
m Z m Z m Z d d l m Z e j e Z e d d d
d d d
g Z d e f d YZ e d e _ d S( i ( t absolute_importN( t
namedtuple( t takewhilei ( t ConnectTimeoutErrort
MaxRetryErrort
ProtocolErrort ReadTimeoutErrort
ResponseErrort
InvalidHeader( t sixt RequestHistoryt methodt urlt errort statust redirect_locationt Retryc B@ s4 e Z d Z e d d d d d d g Z e d g Z e d d d
g Z d Z d d d d d e d d
e e d e e d
Z
d Z e e d d Z
d Z d Z d Z d d Z d Z d d Z d Z d Z d Z e d Z d Z d d d d d d d Z d Z RS( s2 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 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
: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.
t HEADt GETt PUTt DELETEt OPTIONSt TRACEt
Authorizationi i i ix i
i c C@ s | | _ | | _ | | _ | | _ | t k s< | t k rK d } t } n | | _ | p` t | _ | | _ | | _ | | _
|
| _ | p t | _
| | _ |
| _ d S( Ni ( t totalt connectt readR t Falset redirectt sett status_forcelistt method_whitelistt backoff_factort raise_on_redirectt raise_on_statust tuplet historyt respect_retry_after_headert remove_headers_on_redirect( t selfR R R R R R R R R! R" R$ R% R& ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt __init__ s c K@ s t d | j d | j d | j d | j d | j d | j d | j d | j d | j d
| j
d | j d | j } | j
| t | | S(
NR R R R R R R R R! R" R$ R& ( t dictR R R R R R R R R! R" R$ R& t updatet type( R' t kwt params( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt new s $
c C@ sx | d k r* | d k r | n | j } n t | t r= | St | oL d } | | d | } t j d | | | S( s4 Backwards-compatibility for the old retries format.R s! Converted retries value: %r -> %rN( t Nonet DEFAULTt
isinstanceR t boolt logt debug( t clst retriesR t defaultt new_retries( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt from_int s c C@ s\ t t t d t | j } | d k r7 d S| j d | d } t | j | S( sJ Formula for computing the current backoff
:rtype: float
c S@ s
| j d k S( N( R R/ ( t x( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt t i i i ( t lent listR t reversedR$ R t mint BACKOFF_MAX( R' t consecutive_errors_lent
backoff_value( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt get_backoff_time s c C@ s t j d | r! t | } nP t j j | } | d k rR t d | n t j | } | t j } | d k r d } n | S( Ns ^\s*[0-9]+\s*$s Invalid Retry-After header: %si (
t ret matcht intt emailt utilst parsedateR/ R t timet mktime( R' t retry_aftert secondst retry_date_tuplet
retry_date( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt parse_retry_after s c C@ s, | j d } | d k r d S| j | S( s* Get the value of Retry-After in seconds. s Retry-AfterN( t getheaderR/ RQ ( R' t responseRM ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt get_retry_after s c C@ s* | j | } | r& t j | t St S( N( RT RK t sleept TrueR ( R' RS RM ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt sleep_for_retry s
c C@ s- | j } | d k r d St j | d S( Ni ( RD RK RU ( R' t backoff( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _sleep_backoff s c C@ s0 | r" | j | } | r" d Sn | j d S( sC 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( RW RY ( R' RS t slept( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyRU s
c C@ s
t | t S( s{ Errors when we're fairly sure that the server did not receive the
request, so it should be safe to retry.
( R1 R ( R' t err( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _is_connection_error s c C@ s t | t t f S( s Errors that occur after the request has been started, so we should
assume that the server began processing it.
( R1 R R ( R' R[ ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _is_read_error! s c C@ s& | j r" | j | j k r" t St S( s| Checks if a given HTTP method should be retried upon, depending if
it is included on the method whitelist.
( R t upperR RV ( R' R ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt _is_method_retryable' s c C@ sT | j | s t S| j r/ | | j k r/ t S| j oS | j oS | oS | | j k S( sx 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)
( R_ R R RV R R% t RETRY_AFTER_STATUS_CODES( R' R t status_codet has_retry_after( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt is_retry0 s c C@ sS | j | j | j | j | j f } t t d | } | sC t St | d k S( s Are we out of retries? i N(
R R R R R R> t filterR/ R R@ ( R' t retry_counts( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt is_exhausted@ s
$c
C@ s | j t k r3 | r3 t j t | | | n | j } | d k rU | d 8} n | j } | j } | j }
| j } d } d }
d } | r | j
| r | t k r t j t | | | q| d k r| d 8} qn | rQ| j | rQ| t k s| j | r5t j t | | | q| d k r| d 8} qn | r| j
r|
d k r||
d 8}
n d } | j
} | j }
nU t j } | r| j r| d k r| d 8} n t j j d | j } | j }
n | j t | | | |
| f } | j d | d | d | d |
d | d
| } | j rnt | | | pet | n t j d | | | S(
s 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.
i t unknowns too many redirectsRa R R R R R R$ s$ Incremented Retry for (url='%s'): %rN( R R R t reraiseR+ R/ R R R R R\ R] R_ t get_redirect_locationR t
GENERIC_ERRORt SPECIFIC_ERRORt formatR$ R
R. Rf R R3 R4 ( R' R R RS R
t _poolt _stacktraceR R R R t status_countt causeR R R$ t new_retry( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt incrementI sX
" !c C@ s d j d t | d | S( Ns| {cls.__name__}(total={self.total}, connect={self.connect}, read={self.read}, redirect={self.redirect}, status={self.status})R5 R' ( Rl R+ ( R' ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt __repr__ s N( t __name__t
__module__t __doc__t frozensett DEFAULT_METHOD_WHITELISTt" DEFAULT_REDIRECT_HEADERS_BLACKLISTR` RA R/ RV R( R. t classmethodR9 RD RQ RT RW RY RU R\ R] R_ R Rc Rf Rr Rs ( ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyR s8 x
Ji ( t
__future__R RK t loggingt collectionsR t itertoolsR RH RE t
exceptionsR R R R R R t packagesR t getLoggerRt R3 R
t objectR R0 ( ( ( sB /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/retry.pyt s . PK ! };=R R selectors.pynu [ # Backport of selectors.py from Python 3.5+ to support Python < 3.4
# Also has the behavior specified in PEP 475 which is to retry syscalls
# in the case of an EINTR error. This module is required because selectors34
# does not follow this behavior and instead returns that no dile descriptor
# events have occurred rather than retry the syscall. The decision to drop
# support for select.devpoll is made to maintain 100% test coverage.
import errno
import math
import select
import socket
import sys
import time
from collections import namedtuple, Mapping
try:
monotonic = time.monotonic
except (AttributeError, ImportError): # Python 3.3<
monotonic = time.time
EVENT_READ = (1 << 0)
EVENT_WRITE = (1 << 1)
HAS_SELECT = True # Variable that shows whether the platform has a selector.
_SYSCALL_SENTINEL = object() # Sentinel in case a system call returns None.
_DEFAULT_SELECTOR = None
class SelectorError(Exception):
def __init__(self, errcode):
super(SelectorError, self).__init__()
self.errno = errcode
def __repr__(self):
return "".format(self.errno)
def __str__(self):
return self.__repr__()
def _fileobj_to_fd(fileobj):
""" Return a file descriptor from a file object. If
given an integer will simply return that integer back. """
if isinstance(fileobj, int):
fd = fileobj
else:
try:
fd = int(fileobj.fileno())
except (AttributeError, TypeError, ValueError):
raise ValueError("Invalid file object: {0!r}".format(fileobj))
if fd < 0:
raise ValueError("Invalid file descriptor: {0}".format(fd))
return fd
# Determine which function to use to wrap system calls because Python 3.5+
# already handles the case when system calls are interrupted.
if sys.version_info >= (3, 5):
def _syscall_wrapper(func, _, *args, **kwargs):
""" This is the short-circuit version of the below logic
because in Python 3.5+ all system calls automatically restart
and recalculate their timeouts. """
try:
return func(*args, **kwargs)
except (OSError, IOError, select.error) as e:
errcode = None
if hasattr(e, "errno"):
errcode = e.errno
raise SelectorError(errcode)
else:
def _syscall_wrapper(func, recalc_timeout, *args, **kwargs):
""" Wrapper function for syscalls that could fail due to EINTR.
All functions should be retried if there is time left in the timeout
in accordance with PEP 475. """
timeout = kwargs.get("timeout", None)
if timeout is None:
expires = None
recalc_timeout = False
else:
timeout = float(timeout)
if timeout < 0.0: # Timeout less than 0 treated as no timeout.
expires = None
else:
expires = monotonic() + timeout
args = list(args)
if recalc_timeout and "timeout" not in kwargs:
raise ValueError(
"Timeout must be in args or kwargs to be recalculated")
result = _SYSCALL_SENTINEL
while result is _SYSCALL_SENTINEL:
try:
result = func(*args, **kwargs)
# OSError is thrown by select.select
# IOError is thrown by select.epoll.poll
# select.error is thrown by select.poll.poll
# Aren't we thankful for Python 3.x rework for exceptions?
except (OSError, IOError, select.error) as e:
# select.error wasn't a subclass of OSError in the past.
errcode = None
if hasattr(e, "errno"):
errcode = e.errno
elif hasattr(e, "args"):
errcode = e.args[0]
# Also test for the Windows equivalent of EINTR.
is_interrupt = (errcode == errno.EINTR or (hasattr(errno, "WSAEINTR") and
errcode == errno.WSAEINTR))
if is_interrupt:
if expires is not None:
current_time = monotonic()
if current_time > expires:
raise OSError(errno=errno.ETIMEDOUT)
if recalc_timeout:
if "timeout" in kwargs:
kwargs["timeout"] = expires - current_time
continue
if errcode:
raise SelectorError(errcode)
else:
raise
return result
SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])
class _SelectorMapping(Mapping):
""" Mapping of file objects to selector keys """
def __init__(self, selector):
self._selector = selector
def __len__(self):
return len(self._selector._fd_to_key)
def __getitem__(self, fileobj):
try:
fd = self._selector._fileobj_lookup(fileobj)
return self._selector._fd_to_key[fd]
except KeyError:
raise KeyError("{0!r} is not registered.".format(fileobj))
def __iter__(self):
return iter(self._selector._fd_to_key)
class BaseSelector(object):
""" Abstract Selector class
A selector supports registering file objects to be monitored
for specific I/O events.
A file object is a file descriptor or any object with a
`fileno()` method. An arbitrary object can be attached to the
file object which can be used for example to store context info,
a callback, etc.
A selector can use various implementations (select(), poll(), epoll(),
and kqueue()) depending on the platform. The 'DefaultSelector' class uses
the most efficient implementation for the current platform.
"""
def __init__(self):
# Maps file descriptors to keys.
self._fd_to_key = {}
# Read-only mapping returned by get_map()
self._map = _SelectorMapping(self)
def _fileobj_lookup(self, fileobj):
""" Return a file descriptor from a file object.
This wraps _fileobj_to_fd() to do an exhaustive
search in case the object is invalid but we still
have it in our map. Used by unregister() so we can
unregister an object that was previously registered
even if it is closed. It is also used by _SelectorMapping
"""
try:
return _fileobj_to_fd(fileobj)
except ValueError:
# Search through all our mapped keys.
for key in self._fd_to_key.values():
if key.fileobj is fileobj:
return key.fd
# Raise ValueError after all.
raise
def register(self, fileobj, events, data=None):
""" Register a file object for a set of events to monitor. """
if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
raise ValueError("Invalid events: {0!r}".format(events))
key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
if key.fd in self._fd_to_key:
raise KeyError("{0!r} (FD {1}) is already registered"
.format(fileobj, key.fd))
self._fd_to_key[key.fd] = key
return key
def unregister(self, fileobj):
""" Unregister a file object from being monitored. """
try:
key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
except KeyError:
raise KeyError("{0!r} is not registered".format(fileobj))
# Getting the fileno of a closed socket on Windows errors with EBADF.
except socket.error as e: # Platform-specific: Windows.
if e.errno != errno.EBADF:
raise
else:
for key in self._fd_to_key.values():
if key.fileobj is fileobj:
self._fd_to_key.pop(key.fd)
break
else:
raise KeyError("{0!r} is not registered".format(fileobj))
return key
def modify(self, fileobj, events, data=None):
""" Change a registered file object monitored events and data. """
# NOTE: Some subclasses optimize this operation even further.
try:
key = self._fd_to_key[self._fileobj_lookup(fileobj)]
except KeyError:
raise KeyError("{0!r} is not registered".format(fileobj))
if events != key.events:
self.unregister(fileobj)
key = self.register(fileobj, events, data)
elif data != key.data:
# Use a shortcut to update the data.
key = key._replace(data=data)
self._fd_to_key[key.fd] = key
return key
def select(self, timeout=None):
""" Perform the actual selection until some monitored file objects
are ready or the timeout expires. """
raise NotImplementedError()
def close(self):
""" Close the selector. This must be called to ensure that all
underlying resources are freed. """
self._fd_to_key.clear()
self._map = None
def get_key(self, fileobj):
""" Return the key associated with a registered file object. """
mapping = self.get_map()
if mapping is None:
raise RuntimeError("Selector is closed")
try:
return mapping[fileobj]
except KeyError:
raise KeyError("{0!r} is not registered".format(fileobj))
def get_map(self):
""" Return a mapping of file objects to selector keys """
return self._map
def _key_from_fd(self, fd):
""" Return the key associated to a given file descriptor
Return None if it is not found. """
try:
return self._fd_to_key[fd]
except KeyError:
return None
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
# Almost all platforms have select.select()
if hasattr(select, "select"):
class SelectSelector(BaseSelector):
""" Select-based selector. """
def __init__(self):
super(SelectSelector, self).__init__()
self._readers = set()
self._writers = set()
def register(self, fileobj, events, data=None):
key = super(SelectSelector, self).register(fileobj, events, data)
if events & EVENT_READ:
self._readers.add(key.fd)
if events & EVENT_WRITE:
self._writers.add(key.fd)
return key
def unregister(self, fileobj):
key = super(SelectSelector, self).unregister(fileobj)
self._readers.discard(key.fd)
self._writers.discard(key.fd)
return key
def _select(self, r, w, timeout=None):
""" Wrapper for select.select because timeout is a positional arg """
return select.select(r, w, [], timeout)
def select(self, timeout=None):
# Selecting on empty lists on Windows errors out.
if not len(self._readers) and not len(self._writers):
return []
timeout = None if timeout is None else max(timeout, 0.0)
ready = []
r, w, _ = _syscall_wrapper(self._select, True, self._readers,
self._writers, timeout)
r = set(r)
w = set(w)
for fd in r | w:
events = 0
if fd in r:
events |= EVENT_READ
if fd in w:
events |= EVENT_WRITE
key = self._key_from_fd(fd)
if key:
ready.append((key, events & key.events))
return ready
if hasattr(select, "poll"):
class PollSelector(BaseSelector):
""" Poll-based selector """
def __init__(self):
super(PollSelector, self).__init__()
self._poll = select.poll()
def register(self, fileobj, events, data=None):
key = super(PollSelector, self).register(fileobj, events, data)
event_mask = 0
if events & EVENT_READ:
event_mask |= select.POLLIN
if events & EVENT_WRITE:
event_mask |= select.POLLOUT
self._poll.register(key.fd, event_mask)
return key
def unregister(self, fileobj):
key = super(PollSelector, self).unregister(fileobj)
self._poll.unregister(key.fd)
return key
def _wrap_poll(self, timeout=None):
""" Wrapper function for select.poll.poll() so that
_syscall_wrapper can work with only seconds. """
if timeout is not None:
if timeout <= 0:
timeout = 0
else:
# select.poll.poll() has a resolution of 1 millisecond,
# round away from zero to wait *at least* timeout seconds.
timeout = math.ceil(timeout * 1e3)
result = self._poll.poll(timeout)
return result
def select(self, timeout=None):
ready = []
fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout)
for fd, event_mask in fd_events:
events = 0
if event_mask & ~select.POLLIN:
events |= EVENT_WRITE
if event_mask & ~select.POLLOUT:
events |= EVENT_READ
key = self._key_from_fd(fd)
if key:
ready.append((key, events & key.events))
return ready
if hasattr(select, "epoll"):
class EpollSelector(BaseSelector):
""" Epoll-based selector """
def __init__(self):
super(EpollSelector, self).__init__()
self._epoll = select.epoll()
def fileno(self):
return self._epoll.fileno()
def register(self, fileobj, events, data=None):
key = super(EpollSelector, self).register(fileobj, events, data)
events_mask = 0
if events & EVENT_READ:
events_mask |= select.EPOLLIN
if events & EVENT_WRITE:
events_mask |= select.EPOLLOUT
_syscall_wrapper(self._epoll.register, False, key.fd, events_mask)
return key
def unregister(self, fileobj):
key = super(EpollSelector, self).unregister(fileobj)
try:
_syscall_wrapper(self._epoll.unregister, False, key.fd)
except SelectorError:
# This can occur when the fd was closed since registry.
pass
return key
def select(self, timeout=None):
if timeout is not None:
if timeout <= 0:
timeout = 0.0
else:
# select.epoll.poll() has a resolution of 1 millisecond
# but luckily takes seconds so we don't need a wrapper
# like PollSelector. Just for better rounding.
timeout = math.ceil(timeout * 1e3) * 1e-3
timeout = float(timeout)
else:
timeout = -1.0 # epoll.poll() must have a float.
# We always want at least 1 to ensure that select can be called
# with no file descriptors registered. Otherwise will fail.
max_events = max(len(self._fd_to_key), 1)
ready = []
fd_events = _syscall_wrapper(self._epoll.poll, True,
timeout=timeout,
maxevents=max_events)
for fd, event_mask in fd_events:
events = 0
if event_mask & ~select.EPOLLIN:
events |= EVENT_WRITE
if event_mask & ~select.EPOLLOUT:
events |= EVENT_READ
key = self._key_from_fd(fd)
if key:
ready.append((key, events & key.events))
return ready
def close(self):
self._epoll.close()
super(EpollSelector, self).close()
if hasattr(select, "kqueue"):
class KqueueSelector(BaseSelector):
""" Kqueue / Kevent-based selector """
def __init__(self):
super(KqueueSelector, self).__init__()
self._kqueue = select.kqueue()
def fileno(self):
return self._kqueue.fileno()
def register(self, fileobj, events, data=None):
key = super(KqueueSelector, self).register(fileobj, events, data)
if events & EVENT_READ:
kevent = select.kevent(key.fd,
select.KQ_FILTER_READ,
select.KQ_EV_ADD)
_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
if events & EVENT_WRITE:
kevent = select.kevent(key.fd,
select.KQ_FILTER_WRITE,
select.KQ_EV_ADD)
_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
return key
def unregister(self, fileobj):
key = super(KqueueSelector, self).unregister(fileobj)
if key.events & EVENT_READ:
kevent = select.kevent(key.fd,
select.KQ_FILTER_READ,
select.KQ_EV_DELETE)
try:
_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
except SelectorError:
pass
if key.events & EVENT_WRITE:
kevent = select.kevent(key.fd,
select.KQ_FILTER_WRITE,
select.KQ_EV_DELETE)
try:
_syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
except SelectorError:
pass
return key
def select(self, timeout=None):
if timeout is not None:
timeout = max(timeout, 0)
max_events = len(self._fd_to_key) * 2
ready_fds = {}
kevent_list = _syscall_wrapper(self._kqueue.control, True,
None, max_events, timeout)
for kevent in kevent_list:
fd = kevent.ident
event_mask = kevent.filter
events = 0
if event_mask == select.KQ_FILTER_READ:
events |= EVENT_READ
if event_mask == select.KQ_FILTER_WRITE:
events |= EVENT_WRITE
key = self._key_from_fd(fd)
if key:
if key.fd not in ready_fds:
ready_fds[key.fd] = (key, events & key.events)
else:
old_events = ready_fds[key.fd][1]
ready_fds[key.fd] = (key, (events | old_events) & key.events)
return list(ready_fds.values())
def close(self):
self._kqueue.close()
super(KqueueSelector, self).close()
if not hasattr(select, 'select'): # Platform-specific: AppEngine
HAS_SELECT = False
def _can_allocate(struct):
""" Checks that select structs can be allocated by the underlying
operating system, not just advertised by the select module. We don't
check select() because we'll be hopeful that most platforms that
don't have it available will not advertise it. (ie: GAE) """
try:
# select.poll() objects won't fail until used.
if struct == 'poll':
p = select.poll()
p.poll(0)
# All others will fail on allocation.
else:
getattr(select, struct)().close()
return True
except (OSError, AttributeError) as e:
return False
# Choose the best implementation, roughly:
# kqueue == epoll > poll > select. Devpoll not supported. (See above)
# select() also can't accept a FD > FD_SETSIZE (usually around 1024)
def DefaultSelector():
""" This function serves as a first call for DefaultSelector to
detect if the select module is being monkey-patched incorrectly
by eventlet, greenlet, and preserve proper behavior. """
global _DEFAULT_SELECTOR
if _DEFAULT_SELECTOR is None:
if _can_allocate('kqueue'):
_DEFAULT_SELECTOR = KqueueSelector
elif _can_allocate('epoll'):
_DEFAULT_SELECTOR = EpollSelector
elif _can_allocate('poll'):
_DEFAULT_SELECTOR = PollSelector
elif hasattr(select, 'select'):
_DEFAULT_SELECTOR = SelectSelector
else: # Platform-specific: AppEngine
raise ValueError('Platform does not have a selector')
return _DEFAULT_SELECTOR()
PK ! Q Q
selectors.pycnu [
abc @ s d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z m Z y
e j Z Wn e
e f k
r e j Z n Xd# Z d$ Z
e Z e Z d a d e f d YZ d Z e j d% k r d
Z n d Z e d d
d d d g Z d e f d YZ d e f d YZ e e d rad e f d YZ n e e d rd e f d YZ n e e d rd e f d YZ n e e d rd e f d YZ n e e d se! Z n d! Z" d" Z# d S(& iN( t
namedtuplet Mappingi i t
SelectorErrorc B s# e Z d Z d Z d Z RS( c C s t t | j | | _ d S( N( t superR t __init__t errno( t selft errcode( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s d j | j S( Ns ( t formatR ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt __repr__" s c C s
| j S( N( R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt __str__% s ( t __name__t
__module__R R R
( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s t | t r | } nH y t | j } Wn/ t t t f k
r_ t d j | n X| d k r t d j | n | S( sl Return a file descriptor from a file object. If
given an integer will simply return that integer back. s Invalid file object: {0!r}i s Invalid file descriptor: {0}( t
isinstancet intt filenot AttributeErrort TypeErrort
ValueErrorR ( t fileobjt fd( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt _fileobj_to_fd) s i i c O sd y | | | SWnL t t t j f k
r_ } d } t | d rP | j } n t | n Xd S( s This is the short-circuit version of the below logic
because in Python 3.5+ all system calls automatically restart
and recalculate their timeouts. R N( t OSErrort IOErrort selectt errort Nonet hasattrR R ( t funct _t argst kwargst eR ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt _syscall_wrapper; s c O s | j d d } | d k r- d } t } n. t | } | d k rN d } n
t | } t | } | r d | k r t d n t } x5| t k ry | | | } Wq t t t
j f k
r} d } t | d r | j
} n t | d r| j d } n | t
j k p8t t
d o8| t
j k } | r| d k r t }
|
| k rwt d t
j n | rd | k r| |
| d ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR4 s
t BaseSelectorc B s e Z d Z d Z d Z d
d Z d Z d
d Z d
d Z d Z
d Z d Z d
Z
d Z d Z RS( s/ Abstract Selector class
A selector supports registering file objects to be monitored
for specific I/O events.
A file object is a file descriptor or any object with a
`fileno()` method. An arbitrary object can be attached to the
file object which can be used for example to store context info,
a callback, etc.
A selector can use various implementations (select(), poll(), epoll(),
and kqueue()) depending on the platform. The 'DefaultSelector' class uses
the most efficient implementation for the current platform.
c C s i | _ t | | _ d S( N( R8 R4 t _map( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C sY y t | SWnD t k
rT x- | j j D] } | j | k r. | j Sq. W n Xd S( sa Return a file descriptor from a file object.
This wraps _fileobj_to_fd() to do an exhaustive
search in case the object is invalid but we still
have it in our map. Used by unregister() so we can
unregister an object that was previously registered
even if it is closed. It is also used by _SelectorMapping
N( R R R8 t valuesR R ( R R t key( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR: s
c C s | s | t t B@r. t d j | n t | | j | | | } | j | j k r| t d j | | j n | | j | j <| S( s8 Register a file object for a set of events to monitor. s Invalid events: {0!r}s$ {0!r} (FD {1}) is already registered( t
EVENT_READt EVENT_WRITER R R1 R: R R8 R; ( R R R2 R3 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt register s c C s y | j j | j | } Wn t k
rG t d j | n t j k
r } | j t j k rq q xV | j j D], } | j
| k r | j j | j Pq q Wt d j | n X| S( s0 Unregister a file object from being monitored. s {0!r} is not registered( R8 t popR: R; R t socketR R t EBADFRB R R ( R R RC R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt
unregister s
c C s y | j | j | } Wn& t k
rB t d j | n X| | j k rw | j | | j | | | } n4 | | j k r | j d | } | | j | j | j j | j n | t @r^ | j j | j n | S( N( R RW RF RD RY t addR RE RZ ( R R R2 R3 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF & s
c C sB t t | j | } | j j | j | j j | j | S( N( R RW RJ RY t discardR RZ ( R R RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ . s c C s t j | | g | S( s? Wrapper for select.select because timeout is a positional arg ( R ( R t rt wR" ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt _select4 s c C s t | j r$ t | j r$ g S| d k r6 d n t | d } g } t | j t | j | j | \ } } } t | } t | } x| | | BD]p } d } | | k r | t O} n | | k r | t
O} n | j | } | r | j | | | j
@f q q W| S( Ng i ( R7 RY RZ R t maxR! R_ t TrueRX RD RE RT t appendR2 ( R R" t readyR] R^ R R R2 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR 8 s$ !
!N( R R R? R R RF RJ R_ R ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRW s t pollt PollSelectorc B sD e Z d Z d Z d d Z d Z d d Z d d Z RS( s Poll-based selector c C s& t t | j t j | _ d S( N( R Re R R Rd t _poll( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR S s c C sr t t | j | | | } d } | t @r> | t j O} n | t @rX | t j O} n | j j | j | | S( Ni (
R Re RF RD R t POLLINRE t POLLOUTRf R ( R R R2 R3 RC t
event_mask( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF W s
c C s/ t t | j | } | j j | j | S( N( R Re RJ Rf R ( R R RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ a s c C sM | d k r7 | d k r! d } q7 t j | d } n | j j | } | S( sj Wrapper function for select.poll.poll() so that
_syscall_wrapper can work with only seconds. i g @@N( R t matht ceilRf Rd ( R R" R. ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt
_wrap_pollf s c C s g } t | j t d | } x | D]z \ } } d } | t j @rR | t O} n | t j @rm | t O} n | j | } | r% | j | | | j
@f q% q% W| S( NR" i ( R! Rl Ra R Rg RE Rh RD RT Rb R2 ( R R" Rc t fd_eventsR Ri R2 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR t s
!N( R R R? R R RF RJ Rl R ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRe Q s
t epollt
EpollSelectorc B sJ e Z d Z d Z d Z d d Z d Z d d Z d Z RS( s Epoll-based selector c C s& t t | j t j | _ d S( N( R Ro R R Rn t _epoll( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s
| j j S( N( Rp R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C sx t t | j | | | } d } | t @r> | t j O} n | t @rX | t j O} n t | j j t
| j | | S( Ni ( R Ro RF RD R t EPOLLINRE t EPOLLOUTR! Rp R% R ( R R R2 R3 RC t events_mask( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF s
c C sM t t | j | } y t | j j t | j Wn t k
rH n X| S( N( R Ro RJ R! Rp R% R R ( R R RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ s
c C s | d k rG | d k r! d } n t j | d d } t | } n d } t t | j d } g } t | j j t
d | d | } x | D]z \ } } d } | t j @r | t
O} n | t j @r | t O} n | j | } | r | j | | | j @f q q W| S( Ni g g @@gMbP?g i R" t maxevents( R Rj Rk R& R` R7 R8 R! Rp Rd Ra R Rq RE Rr RD RT Rb R2 ( R R" t
max_eventsRc Rm R Ri R2 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s*
!c C s$ | j j t t | j d S( N( Rp RO R Ro ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRO s
N(
R R R? R R R RF RJ R RO ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRo s
!t kqueuet KqueueSelectorc B sJ e Z d Z d Z d Z d d Z d Z d d Z d Z RS( s Kqueue / Kevent-based selector c C s& t t | j t j | _ d S( N( R Rw R R Rv t _kqueue( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s
| j j S( N( Rx R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s t t | j | | | } | t @rh t j | j t j t j } t | j
j t | g d d n | t
@r t j | j t j t j } t | j
j t | g d d n | S( Ni ( R Rw RF RD R t keventR t KQ_FILTER_READt KQ_EV_ADDR! Rx t controlR% RE t KQ_FILTER_WRITE( R R R2 R3 RC Ry ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF s
"
"c C s t t | j | } | j t @r} t j | j t j t j } y# t
| j j t
| g d d Wq} t k
ry q} Xn | j t @r t j | j t j t j } y# t
| j j t
| g d d Wq t k
r q Xn | S( Ni ( R Rw RJ R2 RD R Ry R Rz t KQ_EV_DELETER! Rx R| R% R RE R} ( R R RC Ry ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ s$
#
#
c C s9 | d k r t | d } n t | j d } i } t | j j t d | | } x | D] } | j } | j } d } | t
j k r | t O} n | t
j
k r | t O} n | j | } | r\ | j | k r | | | j @f | | j sF
814BR PK ! Q Q
selectors.pyonu [
abc @ s d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z m Z y
e j Z Wn e
e f k
r e j Z n Xd# Z d$ Z
e Z e Z d a d e f d YZ d Z e j d% k r d
Z n d Z e d d
d d d g Z d e f d YZ d e f d YZ e e d rad e f d YZ n e e d rd e f d YZ n e e d rd e f d YZ n e e d rd e f d YZ n e e d se! Z n d! Z" d" Z# d S(& iN( t
namedtuplet Mappingi i t
SelectorErrorc B s# e Z d Z d Z d Z RS( c C s t t | j | | _ d S( N( t superR t __init__t errno( t selft errcode( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s d j | j S( Ns ( t formatR ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt __repr__" s c C s
| j S( N( R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt __str__% s ( t __name__t
__module__R R R
( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s t | t r | } nH y t | j } Wn/ t t t f k
r_ t d j | n X| d k r t d j | n | S( sl Return a file descriptor from a file object. If
given an integer will simply return that integer back. s Invalid file object: {0!r}i s Invalid file descriptor: {0}( t
isinstancet intt filenot AttributeErrort TypeErrort
ValueErrorR ( t fileobjt fd( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt _fileobj_to_fd) s i i c O sd y | | | SWnL t t t j f k
r_ } d } t | d rP | j } n t | n Xd S( s This is the short-circuit version of the below logic
because in Python 3.5+ all system calls automatically restart
and recalculate their timeouts. R N( t OSErrort IOErrort selectt errort Nonet hasattrR R ( t funct _t argst kwargst eR ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt _syscall_wrapper; s c O s | j d d } | d k r- d } t } n. t | } | d k rN d } n
t | } t | } | r d | k r t d n t } x5| t k ry | | | } Wq t t t
j f k
r} d } t | d r | j
} n t | d r| j d } n | t
j k p8t t
d o8| t
j k } | r| d k r t }
|
| k rwt d t
j n | rd | k r| |
| d ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR4 s
t BaseSelectorc B s e Z d Z d Z d Z d
d Z d Z d
d Z d
d Z d Z
d Z d Z d
Z
d Z d Z RS( s/ Abstract Selector class
A selector supports registering file objects to be monitored
for specific I/O events.
A file object is a file descriptor or any object with a
`fileno()` method. An arbitrary object can be attached to the
file object which can be used for example to store context info,
a callback, etc.
A selector can use various implementations (select(), poll(), epoll(),
and kqueue()) depending on the platform. The 'DefaultSelector' class uses
the most efficient implementation for the current platform.
c C s i | _ t | | _ d S( N( R8 R4 t _map( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C sY y t | SWnD t k
rT x- | j j D] } | j | k r. | j Sq. W n Xd S( sa Return a file descriptor from a file object.
This wraps _fileobj_to_fd() to do an exhaustive
search in case the object is invalid but we still
have it in our map. Used by unregister() so we can
unregister an object that was previously registered
even if it is closed. It is also used by _SelectorMapping
N( R R R8 t valuesR R ( R R t key( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR: s
c C s | s | t t B@r. t d j | n t | | j | | | } | j | j k r| t d j | | j n | | j | j <| S( s8 Register a file object for a set of events to monitor. s Invalid events: {0!r}s$ {0!r} (FD {1}) is already registered( t
EVENT_READt EVENT_WRITER R R1 R: R R8 R; ( R R R2 R3 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt register s c C s y | j j | j | } Wn t k
rG t d j | n t j k
r } | j t j k rq q xV | j j D], } | j
| k r | j j | j Pq q Wt d j | n X| S( s0 Unregister a file object from being monitored. s {0!r} is not registered( R8 t popR: R; R t socketR R t EBADFRB R R ( R R RC R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt
unregister s
c C s y | j | j | } Wn& t k
rB t d j | n X| | j k rw | j | | j | | | } n4 | | j k r | j d | } | | j | j | j j | j n | t @r^ | j j | j n | S( N( R RW RF RD RY t addR RE RZ ( R R R2 R3 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF & s
c C sB t t | j | } | j j | j | j j | j | S( N( R RW RJ RY t discardR RZ ( R R RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ . s c C s t j | | g | S( s? Wrapper for select.select because timeout is a positional arg ( R ( R t rt wR" ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt _select4 s c C s t | j r$ t | j r$ g S| d k r6 d n t | d } g } t | j t | j | j | \ } } } t | } t | } x| | | BD]p } d } | | k r | t O} n | | k r | t
O} n | j | } | r | j | | | j
@f q q W| S( Ng i ( R7 RY RZ R t maxR! R_ t TrueRX RD RE RT t appendR2 ( R R" t readyR] R^ R R R2 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR 8 s$ !
!N( R R R? R R RF RJ R_ R ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRW s t pollt PollSelectorc B sD e Z d Z d Z d d Z d Z d d Z d d Z RS( s Poll-based selector c C s& t t | j t j | _ d S( N( R Re R R Rd t _poll( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR S s c C sr t t | j | | | } d } | t @r> | t j O} n | t @rX | t j O} n | j j | j | | S( Ni (
R Re RF RD R t POLLINRE t POLLOUTRf R ( R R R2 R3 RC t
event_mask( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF W s
c C s/ t t | j | } | j j | j | S( N( R Re RJ Rf R ( R R RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ a s c C sM | d k r7 | d k r! d } q7 t j | d } n | j j | } | S( sj Wrapper function for select.poll.poll() so that
_syscall_wrapper can work with only seconds. i g @@N( R t matht ceilRf Rd ( R R" R. ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyt
_wrap_pollf s c C s g } t | j t d | } x | D]z \ } } d } | t j @rR | t O} n | t j @rm | t O} n | j | } | r% | j | | | j
@f q% q% W| S( NR" i ( R! Rl Ra R Rg RE Rh RD RT Rb R2 ( R R" Rc t fd_eventsR Ri R2 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR t s
!N( R R R? R R RF RJ Rl R ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRe Q s
t epollt
EpollSelectorc B sJ e Z d Z d Z d Z d d Z d Z d d Z d Z RS( s Epoll-based selector c C s& t t | j t j | _ d S( N( R Ro R R Rn t _epoll( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s
| j j S( N( Rp R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C sx t t | j | | | } d } | t @r> | t j O} n | t @rX | t j O} n t | j j t
| j | | S( Ni ( R Ro RF RD R t EPOLLINRE t EPOLLOUTR! Rp R% R ( R R R2 R3 RC t events_mask( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF s
c C sM t t | j | } y t | j j t | j Wn t k
rH n X| S( N( R Ro RJ R! Rp R% R R ( R R RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ s
c C s | d k rG | d k r! d } n t j | d d } t | } n d } t t | j d } g } t | j j t
d | d | } x | D]z \ } } d } | t j @r | t
O} n | t j @r | t O} n | j | } | r | j | | | j @f q q W| S( Ni g g @@gMbP?g i R" t maxevents( R Rj Rk R& R` R7 R8 R! Rp Rd Ra R Rq RE Rr RD RT Rb R2 ( R R" t
max_eventsRc Rm R Ri R2 RC ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s*
!c C s$ | j j t t | j d S( N( Rp RO R Ro ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRO s
N(
R R R? R R R RF RJ R RO ( ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRo s
!t kqueuet KqueueSelectorc B sJ e Z d Z d Z d Z d d Z d Z d d Z d Z RS( s Kqueue / Kevent-based selector c C s& t t | j t j | _ d S( N( R Rw R R Rv t _kqueue( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s
| j j S( N( Rx R ( R ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyR s c C s t t | j | | | } | t @rh t j | j t j t j } t | j
j t | g d d n | t
@r t j | j t j t j } t | j
j t | g d d n | S( Ni ( R Rw RF RD R t keventR t KQ_FILTER_READt KQ_EV_ADDR! Rx t controlR% RE t KQ_FILTER_WRITE( R R R2 R3 RC Ry ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRF s
"
"c C s t t | j | } | j t @r} t j | j t j t j } y# t
| j j t
| g d d Wq} t k
ry q} Xn | j t @r t j | j t j t j } y# t
| j j t
| g d d Wq t k
r q Xn | S( Ni ( R Rw RJ R2 RD R Ry R Rz t KQ_EV_DELETER! Rx R| R% R RE R} ( R R RC Ry ( ( sF /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/selectors.pyRJ s$
#
#
c C s9 | d k r t | d } n t | j d } i } t | j j t d | | } x | D] } | j } | j } d } | t
j k r | t O} n | t
j
k r | t O} n | j | } | r\ | j | k r | | | j @f | | j sF
814BR PK ! e/ / ssl_.pynu [ from __future__ import absolute_import
import errno
import warnings
import hmac
from binascii import hexlify, unhexlify
from hashlib import md5, sha1, sha256
from ..exceptions import SSLError, InsecurePlatformWarning, SNIMissingWarning
SSLContext = None
HAS_SNI = False
IS_PYOPENSSL = False
IS_SECURETRANSPORT = False
# Maps the length of a digest to a possible hash function producing this digest
HASHFUNC_MAP = {
32: md5,
40: sha1,
64: sha256,
}
def _const_compare_digest_backport(a, b):
"""
Compare two digests of equal length in constant time.
The digests must be of type str/bytes.
Returns True if the digests match, and False otherwise.
"""
result = abs(len(a) - len(b))
for l, r in zip(bytearray(a), bytearray(b)):
result |= l ^ r
return result == 0
_const_compare_digest = getattr(hmac, 'compare_digest',
_const_compare_digest_backport)
try: # Test for SSL features
import ssl
from ssl import wrap_socket, CERT_NONE, PROTOCOL_SSLv23
from ssl import HAS_SNI # Has SNI?
except ImportError:
pass
try:
from ssl import OP_NO_SSLv2, OP_NO_SSLv3, OP_NO_COMPRESSION
except ImportError:
OP_NO_SSLv2, OP_NO_SSLv3 = 0x1000000, 0x2000000
OP_NO_COMPRESSION = 0x20000
# A secure default.
# Sources for more information on TLS ciphers:
#
# - https://wiki.mozilla.org/Security/Server_Side_TLS
# - https://www.ssllabs.com/projects/best-practices/index.html
# - https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
#
# The general intent is:
# - Prefer TLS 1.3 cipher suites
# - prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE),
# - prefer ECDHE over DHE for better performance,
# - prefer any AES-GCM and ChaCha20 over any AES-CBC for better performance and
# security,
# - prefer AES-GCM over ChaCha20 because hardware-accelerated AES is common,
# - disable NULL authentication, MD5 MACs and DSS for security reasons.
DEFAULT_CIPHERS = ':'.join([
'TLS13-AES-256-GCM-SHA384',
'TLS13-CHACHA20-POLY1305-SHA256',
'TLS13-AES-128-GCM-SHA256',
'ECDH+AESGCM',
'ECDH+CHACHA20',
'DH+AESGCM',
'DH+CHACHA20',
'ECDH+AES256',
'DH+AES256',
'ECDH+AES128',
'DH+AES',
'RSA+AESGCM',
'RSA+AES',
'!aNULL',
'!eNULL',
'!MD5',
])
try:
from ssl import SSLContext # Modern SSL?
except ImportError:
import sys
class SSLContext(object): # Platform-specific: Python 2 & 3.1
supports_set_ciphers = ((2, 7) <= sys.version_info < (3,) or
(3, 2) <= sys.version_info)
def __init__(self, protocol_version):
self.protocol = protocol_version
# Use default values from a real SSLContext
self.check_hostname = False
self.verify_mode = ssl.CERT_NONE
self.ca_certs = None
self.options = 0
self.certfile = None
self.keyfile = None
self.ciphers = None
def load_cert_chain(self, certfile, keyfile):
self.certfile = certfile
self.keyfile = keyfile
def load_verify_locations(self, cafile=None, capath=None):
self.ca_certs = cafile
if capath is not None:
raise SSLError("CA directories not supported in older Pythons")
def set_ciphers(self, cipher_suite):
if not self.supports_set_ciphers:
raise TypeError(
'Your version of Python does not support setting '
'a custom cipher suite. Please upgrade to Python '
'2.7, 3.2, or later if you need this functionality.'
)
self.ciphers = cipher_suite
def wrap_socket(self, socket, server_hostname=None, server_side=False):
warnings.warn(
'A true SSLContext object is not available. This prevents '
'urllib3 from configuring SSL appropriately and may cause '
'certain SSL connections to fail. You can upgrade to a newer '
'version of Python to solve this. For more information, see '
'https://urllib3.readthedocs.io/en/latest/advanced-usage.html'
'#ssl-warnings',
InsecurePlatformWarning
)
kwargs = {
'keyfile': self.keyfile,
'certfile': self.certfile,
'ca_certs': self.ca_certs,
'cert_reqs': self.verify_mode,
'ssl_version': self.protocol,
'server_side': server_side,
}
if self.supports_set_ciphers: # Platform-specific: Python 2.7+
return wrap_socket(socket, ciphers=self.ciphers, **kwargs)
else: # Platform-specific: Python 2.6
return wrap_socket(socket, **kwargs)
def assert_fingerprint(cert, fingerprint):
"""
Checks if given fingerprint matches the supplied certificate.
:param cert:
Certificate as bytes object.
:param fingerprint:
Fingerprint as string of hexdigits, can be interspersed by colons.
"""
fingerprint = fingerprint.replace(':', '').lower()
digest_length = len(fingerprint)
hashfunc = HASHFUNC_MAP.get(digest_length)
if not hashfunc:
raise SSLError(
'Fingerprint of invalid length: {0}'.format(fingerprint))
# We need encode() here for py32; works on py2 and p33.
fingerprint_bytes = unhexlify(fingerprint.encode())
cert_digest = hashfunc(cert).digest()
if not _const_compare_digest(cert_digest, fingerprint_bytes):
raise SSLError('Fingerprints did not match. Expected "{0}", got "{1}".'
.format(fingerprint, hexlify(cert_digest)))
def resolve_cert_reqs(candidate):
"""
Resolves the argument to a numeric constant, which can be passed to
the wrap_socket function/method from the ssl module.
Defaults to :data:`ssl.CERT_NONE`.
If given a string it is assumed to be the name of the constant in the
:mod:`ssl` module or its abbrevation.
(So you can specify `REQUIRED` instead of `CERT_REQUIRED`.
If it's neither `None` nor a string we assume it is already the numeric
constant which can directly be passed to wrap_socket.
"""
if candidate is None:
return CERT_NONE
if isinstance(candidate, str):
res = getattr(ssl, candidate, None)
if res is None:
res = getattr(ssl, 'CERT_' + candidate)
return res
return candidate
def resolve_ssl_version(candidate):
"""
like resolve_cert_reqs
"""
if candidate is None:
return PROTOCOL_SSLv23
if isinstance(candidate, str):
res = getattr(ssl, candidate, None)
if res is None:
res = getattr(ssl, 'PROTOCOL_' + candidate)
return res
return candidate
def create_urllib3_context(ssl_version=None, cert_reqs=None,
options=None, ciphers=None):
"""All arguments have the same meaning as ``ssl_wrap_socket``.
By default, this function does a lot of the same work that
``ssl.create_default_context`` does on Python 3.4+. It:
- Disables SSLv2, SSLv3, and compression
- Sets a restricted set of server ciphers
If you wish to enable SSLv3, you can do::
from urllib3.util import ssl_
context = ssl_.create_urllib3_context()
context.options &= ~ssl_.OP_NO_SSLv3
You can do the same to enable compression (substituting ``COMPRESSION``
for ``SSLv3`` in the last line above).
:param ssl_version:
The desired protocol version to use. This will default to
PROTOCOL_SSLv23 which will negotiate the highest protocol that both
the server and your installation of OpenSSL support.
:param cert_reqs:
Whether to require the certificate verification. This defaults to
``ssl.CERT_REQUIRED``.
:param options:
Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,
``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``.
:param ciphers:
Which cipher suites to allow the server to select.
:returns:
Constructed SSLContext object with specified options
:rtype: SSLContext
"""
context = SSLContext(ssl_version or ssl.PROTOCOL_SSLv23)
# Setting the default here, as we may have no ssl module on import
cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs
if options is None:
options = 0
# SSLv2 is easily broken and is considered harmful and dangerous
options |= OP_NO_SSLv2
# SSLv3 has several problems and is now dangerous
options |= OP_NO_SSLv3
# Disable compression to prevent CRIME attacks for OpenSSL 1.0+
# (issue #309)
options |= OP_NO_COMPRESSION
context.options |= options
if getattr(context, 'supports_set_ciphers', True): # Platform-specific: Python 2.6
context.set_ciphers(ciphers or DEFAULT_CIPHERS)
context.verify_mode = cert_reqs
if getattr(context, 'check_hostname', None) is not None: # Platform-specific: Python 3.2
# We do our own verification, including fingerprints and alternative
# hostnames. So disable it here
context.check_hostname = False
return context
def ssl_wrap_socket(sock, keyfile=None, certfile=None, cert_reqs=None,
ca_certs=None, server_hostname=None,
ssl_version=None, ciphers=None, ssl_context=None,
ca_cert_dir=None):
"""
All arguments except for server_hostname, ssl_context, and ca_cert_dir have
the same meaning as they do when using :func:`ssl.wrap_socket`.
:param server_hostname:
When SNI is supported, the expected hostname of the certificate
:param ssl_context:
A pre-made :class:`SSLContext` object. If none is provided, one will
be created using :func:`create_urllib3_context`.
:param ciphers:
A string of ciphers we wish the client to support. This is not
supported on Python 2.6 as the ssl module does not support it.
:param ca_cert_dir:
A directory containing CA certificates in multiple separate files, as
supported by OpenSSL's -CApath flag or the capath argument to
SSLContext.load_verify_locations().
"""
context = ssl_context
if context is None:
# Note: This branch of code and all the variables in it are no longer
# used by urllib3 itself. We should consider deprecating and removing
# this code.
context = create_urllib3_context(ssl_version, cert_reqs,
ciphers=ciphers)
if ca_certs or ca_cert_dir:
try:
context.load_verify_locations(ca_certs, ca_cert_dir)
except IOError as e: # Platform-specific: Python 2.6, 2.7, 3.2
raise SSLError(e)
# Py33 raises FileNotFoundError which subclasses OSError
# These are not equivalent unless we check the errno attribute
except OSError as e: # Platform-specific: Python 3.3 and beyond
if e.errno == errno.ENOENT:
raise SSLError(e)
raise
elif ssl_context is None and hasattr(context, 'load_default_certs'):
# try to load OS default certs; works well on Windows (require Python3.4+)
context.load_default_certs()
if certfile:
context.load_cert_chain(certfile, keyfile)
if HAS_SNI: # Platform-specific: OpenSSL with enabled SNI
return context.wrap_socket(sock, server_hostname=server_hostname)
warnings.warn(
'An HTTPS request has been made, but the SNI (Subject Name '
'Indication) extension to TLS is not available on this platform. '
'This may cause the server to present an incorrect TLS '
'certificate, which can cause validation failures. You can upgrade to '
'a newer version of Python to solve this. For more information, see '
'https://urllib3.readthedocs.io/en/latest/advanced-usage.html'
'#ssl-warnings',
SNIMissingWarning
)
return context.wrap_socket(sock)
PK ! {Gm) m) ssl_.pycnu [
abc @@ sG d d l m Z d d l Z d d l Z d d l Z d d l m Z m Z d d l m Z m
Z
m Z d d l m
Z
m Z m Z d Z e Z e Z e Z i e d 6e
d 6e d 6Z d
Z e e d e Z y< d d l Z d d l m Z m Z m Z d d
l m Z Wn e k
r n Xy d d l m Z m Z m! Z! Wn# e k
red+ \ Z Z d Z! n Xd j" d d d d d d d d d d d d d d d! d" g Z# y d d# l m Z Wn3 e k
rd d l$ Z$ d$ e% f d% YZ n Xd& Z& d' Z' d( Z( d d d d d) Z) d d d d d d d d d d* Z* d S(, i ( t absolute_importN( t hexlifyt unhexlify( t md5t sha1t sha256i ( t SSLErrort InsecurePlatformWarningt SNIMissingWarningi i( i@ c C@ s` t t | t | } x7 t t | t | D] \ } } | | | AO} q8 W| d k S( s
Compare two digests of equal length in constant time.
The digests must be of type str/bytes.
Returns True if the digests match, and False otherwise.
i ( t abst lent zipt bytearray( t at bt resultt lt r( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt _const_compare_digest_backport s (t compare_digest( t wrap_sockett CERT_NONEt PROTOCOL_SSLv23( t HAS_SNI( t OP_NO_SSLv2t OP_NO_SSLv3t OP_NO_COMPRESSIONi i i t :s TLS13-AES-256-GCM-SHA384s TLS13-CHACHA20-POLY1305-SHA256s TLS13-AES-128-GCM-SHA256s ECDH+AESGCMs
ECDH+CHACHA20s DH+AESGCMs DH+CHACHA20s ECDH+AES256s DH+AES256s ECDH+AES128s DH+AESs
RSA+AESGCMs RSA+AESs !aNULLs !eNULLs !MD5( t
SSLContextR c B@ so e Z d e j k o d k n p1 d
e j k Z d Z d Z d d d Z d Z d e
d Z RS( i i i c C@ sO | | _ t | _ t j | _ d | _ d | _ d | _ d | _
d | _ d S( Ni ( t protocolt Falset check_hostnamet sslR t verify_modet Nonet ca_certst optionst certfilet keyfilet ciphers( t selft protocol_version( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt __init__c s c C@ s | | _ | | _ d S( N( R% R& ( R( R% R& ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt load_cert_chainn s c C@ s( | | _ | d k r$ t d n d S( Ns- CA directories not supported in older Pythons( R# R" R ( R( t cafilet capath( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt load_verify_locationsr s c C@ s% | j s t d n | | _ d S( Ns Your version of Python does not support setting a custom cipher suite. Please upgrade to Python 2.7, 3.2, or later if you need this functionality.( t supports_set_cipherst TypeErrorR' ( R( t cipher_suite( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt set_ciphersx s c C@ s t j d t i | j d 6| j d 6| j d 6| j d 6| j d 6| d 6} | j rn t | d | j
| St | | Sd S( Ns2 A true SSLContext object is not available. This prevents urllib3 from configuring SSL appropriately and may cause certain SSL connections to fail. You can upgrade to a newer version of Python to solve this. For more information, see https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warningsR& R% R# t cert_reqst ssl_versiont server_sideR' ( t warningst warnR R& R% R# R! R R/ R R' ( R( t sockett server_hostnameR5 t kwargs( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyR s
( i i ( i ( i i N( t __name__t
__module__t syst version_infoR/ R* R+ R" R. R2 R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyR _ s c C@ s | j d d j } t | } t j | } | sQ t d j | n t | j } | | j } t
| | s t d j | t | n d S( s
Checks if given fingerprint matches the supplied certificate.
:param cert:
Certificate as bytes object.
:param fingerprint:
Fingerprint as string of hexdigits, can be interspersed by colons.
R t s" Fingerprint of invalid length: {0}s6 Fingerprints did not match. Expected "{0}", got "{1}".N( t replacet lowerR
t HASHFUNC_MAPt getR t formatR t encodet digestt _const_compare_digestR ( t certt fingerprintt
digest_lengtht hashfunct fingerprint_bytest cert_digest( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt assert_fingerprint s
c C@ s[ | d k r t St | t rW t t | d } | d k rS t t d | } n | S| S( s
Resolves the argument to a numeric constant, which can be passed to
the wrap_socket function/method from the ssl module.
Defaults to :data:`ssl.CERT_NONE`.
If given a string it is assumed to be the name of the constant in the
:mod:`ssl` module or its abbrevation.
(So you can specify `REQUIRED` instead of `CERT_REQUIRED`.
If it's neither `None` nor a string we assume it is already the numeric
constant which can directly be passed to wrap_socket.
t CERT_N( R" R t
isinstancet strt getattrR ( t candidatet res( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt resolve_cert_reqs s c C@ s[ | d k r t St | t rW t t | d } | d k rS t t d | } n | S| S( s
like resolve_cert_reqs
t PROTOCOL_N( R" R RP RQ RR R ( RS RT ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt resolve_ssl_version s c C@ s t | p t j } | d k r* t j n | } | d k rc d } | t O} | t O} | t O} n | j | O_ t | d t
r | j | p t n | | _
t | d d d k r t | _ n | S( s All arguments have the same meaning as ``ssl_wrap_socket``.
By default, this function does a lot of the same work that
``ssl.create_default_context`` does on Python 3.4+. It:
- Disables SSLv2, SSLv3, and compression
- Sets a restricted set of server ciphers
If you wish to enable SSLv3, you can do::
from urllib3.util import ssl_
context = ssl_.create_urllib3_context()
context.options &= ~ssl_.OP_NO_SSLv3
You can do the same to enable compression (substituting ``COMPRESSION``
for ``SSLv3`` in the last line above).
:param ssl_version:
The desired protocol version to use. This will default to
PROTOCOL_SSLv23 which will negotiate the highest protocol that both
the server and your installation of OpenSSL support.
:param cert_reqs:
Whether to require the certificate verification. This defaults to
``ssl.CERT_REQUIRED``.
:param options:
Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,
``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``.
:param ciphers:
Which cipher suites to allow the server to select.
:returns:
Constructed SSLContext object with specified options
:rtype: SSLContext
i R/ R N( R R R R" t
CERT_REQUIREDR R R R$ RR t TrueR2 t DEFAULT_CIPHERSR! R R ( R4 R3 R$ R' t context( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt create_urllib3_context s #
c
C@ s | }
|
d k r* t | | d | }
n | s6 | r y |
j | | Wq t k
rk } t | q t k
r } | j t j k r t | n q Xn( | d k r t |
d r |
j n | r |
j
| | n t r |
j | d | St
j d t |
j | S( s
All arguments except for server_hostname, ssl_context, and ca_cert_dir have
the same meaning as they do when using :func:`ssl.wrap_socket`.
:param server_hostname:
When SNI is supported, the expected hostname of the certificate
:param ssl_context:
A pre-made :class:`SSLContext` object. If none is provided, one will
be created using :func:`create_urllib3_context`.
:param ciphers:
A string of ciphers we wish the client to support. This is not
supported on Python 2.6 as the ssl module does not support it.
:param ca_cert_dir:
A directory containing CA certificates in multiple separate files, as
supported by OpenSSL's -CApath flag or the capath argument to
SSLContext.load_verify_locations().
R' t load_default_certsR9 s An HTTPS request has been made, but the SNI (Subject Name Indication) extension to TLS is not available on this platform. This may cause the server to present an incorrect TLS certificate, which can cause validation failures. You can upgrade to a newer version of Python to solve this. For more information, see https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warningsN( R" R\ R. t IOErrorR t OSErrort errnot ENOENTt hasattrR] R+ R R R6 R7 R ( t sockR& R% R3 R# R9 R4 R' t ssl_contextt ca_cert_dirR[ t e( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt ssl_wrap_socket s.
( i i (+ t
__future__R R` R6 t hmact binasciiR R t hashlibR R R t
exceptionsR R R R" R R R t IS_PYOPENSSLt IS_SECURETRANSPORTRB R RR RG R R R R t ImportErrorR R R t joinRZ R= t objectRN RU RW R\ Rg ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt sv
: > PK ! {Gm) m) ssl_.pyonu [
abc @@ sG d d l m Z d d l Z d d l Z d d l Z d d l m Z m Z d d l m Z m
Z
m Z d d l m
Z
m Z m Z d Z e Z e Z e Z i e d 6e
d 6e d 6Z d
Z e e d e Z y< d d l Z d d l m Z m Z m Z d d
l m Z Wn e k
r n Xy d d l m Z m Z m! Z! Wn# e k
red+ \ Z Z d Z! n Xd j" d d d d d d d d d d d d d d d! d" g Z# y d d# l m Z Wn3 e k
rd d l$ Z$ d$ e% f d% YZ n Xd& Z& d' Z' d( Z( d d d d d) Z) d d d d d d d d d d* Z* d S(, i ( t absolute_importN( t hexlifyt unhexlify( t md5t sha1t sha256i ( t SSLErrort InsecurePlatformWarningt SNIMissingWarningi i( i@ c C@ s` t t | t | } x7 t t | t | D] \ } } | | | AO} q8 W| d k S( s
Compare two digests of equal length in constant time.
The digests must be of type str/bytes.
Returns True if the digests match, and False otherwise.
i ( t abst lent zipt bytearray( t at bt resultt lt r( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt _const_compare_digest_backport s (t compare_digest( t wrap_sockett CERT_NONEt PROTOCOL_SSLv23( t HAS_SNI( t OP_NO_SSLv2t OP_NO_SSLv3t OP_NO_COMPRESSIONi i i t :s TLS13-AES-256-GCM-SHA384s TLS13-CHACHA20-POLY1305-SHA256s TLS13-AES-128-GCM-SHA256s ECDH+AESGCMs
ECDH+CHACHA20s DH+AESGCMs DH+CHACHA20s ECDH+AES256s DH+AES256s ECDH+AES128s DH+AESs
RSA+AESGCMs RSA+AESs !aNULLs !eNULLs !MD5( t
SSLContextR c B@ so e Z d e j k o d k n p1 d
e j k Z d Z d Z d d d Z d Z d e
d Z RS( i i i c C@ sO | | _ t | _ t j | _ d | _ d | _ d | _ d | _
d | _ d S( Ni ( t protocolt Falset check_hostnamet sslR t verify_modet Nonet ca_certst optionst certfilet keyfilet ciphers( t selft protocol_version( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt __init__c s c C@ s | | _ | | _ d S( N( R% R& ( R( R% R& ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt load_cert_chainn s c C@ s( | | _ | d k r$ t d n d S( Ns- CA directories not supported in older Pythons( R# R" R ( R( t cafilet capath( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt load_verify_locationsr s c C@ s% | j s t d n | | _ d S( Ns Your version of Python does not support setting a custom cipher suite. Please upgrade to Python 2.7, 3.2, or later if you need this functionality.( t supports_set_cipherst TypeErrorR' ( R( t cipher_suite( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt set_ciphersx s c C@ s t j d t i | j d 6| j d 6| j d 6| j d 6| j d 6| d 6} | j rn t | d | j
| St | | Sd S( Ns2 A true SSLContext object is not available. This prevents urllib3 from configuring SSL appropriately and may cause certain SSL connections to fail. You can upgrade to a newer version of Python to solve this. For more information, see https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warningsR& R% R# t cert_reqst ssl_versiont server_sideR' ( t warningst warnR R& R% R# R! R R/ R R' ( R( t sockett server_hostnameR5 t kwargs( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyR s
( i i ( i ( i i N( t __name__t
__module__t syst version_infoR/ R* R+ R" R. R2 R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyR _ s c C@ s | j d d j } t | } t j | } | sQ t d j | n t | j } | | j } t
| | s t d j | t | n d S( s
Checks if given fingerprint matches the supplied certificate.
:param cert:
Certificate as bytes object.
:param fingerprint:
Fingerprint as string of hexdigits, can be interspersed by colons.
R t s" Fingerprint of invalid length: {0}s6 Fingerprints did not match. Expected "{0}", got "{1}".N( t replacet lowerR
t HASHFUNC_MAPt getR t formatR t encodet digestt _const_compare_digestR ( t certt fingerprintt
digest_lengtht hashfunct fingerprint_bytest cert_digest( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt assert_fingerprint s
c C@ s[ | d k r t St | t rW t t | d } | d k rS t t d | } n | S| S( s
Resolves the argument to a numeric constant, which can be passed to
the wrap_socket function/method from the ssl module.
Defaults to :data:`ssl.CERT_NONE`.
If given a string it is assumed to be the name of the constant in the
:mod:`ssl` module or its abbrevation.
(So you can specify `REQUIRED` instead of `CERT_REQUIRED`.
If it's neither `None` nor a string we assume it is already the numeric
constant which can directly be passed to wrap_socket.
t CERT_N( R" R t
isinstancet strt getattrR ( t candidatet res( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt resolve_cert_reqs s c C@ s[ | d k r t St | t rW t t | d } | d k rS t t d | } n | S| S( s
like resolve_cert_reqs
t PROTOCOL_N( R" R RP RQ RR R ( RS RT ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt resolve_ssl_version s c C@ s t | p t j } | d k r* t j n | } | d k rc d } | t O} | t O} | t O} n | j | O_ t | d t
r | j | p t n | | _
t | d d d k r t | _ n | S( s All arguments have the same meaning as ``ssl_wrap_socket``.
By default, this function does a lot of the same work that
``ssl.create_default_context`` does on Python 3.4+. It:
- Disables SSLv2, SSLv3, and compression
- Sets a restricted set of server ciphers
If you wish to enable SSLv3, you can do::
from urllib3.util import ssl_
context = ssl_.create_urllib3_context()
context.options &= ~ssl_.OP_NO_SSLv3
You can do the same to enable compression (substituting ``COMPRESSION``
for ``SSLv3`` in the last line above).
:param ssl_version:
The desired protocol version to use. This will default to
PROTOCOL_SSLv23 which will negotiate the highest protocol that both
the server and your installation of OpenSSL support.
:param cert_reqs:
Whether to require the certificate verification. This defaults to
``ssl.CERT_REQUIRED``.
:param options:
Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,
``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``.
:param ciphers:
Which cipher suites to allow the server to select.
:returns:
Constructed SSLContext object with specified options
:rtype: SSLContext
i R/ R N( R R R R" t
CERT_REQUIREDR R R R$ RR t TrueR2 t DEFAULT_CIPHERSR! R R ( R4 R3 R$ R' t context( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt create_urllib3_context s #
c
C@ s | }
|
d k r* t | | d | }
n | s6 | r y |
j | | Wq t k
rk } t | q t k
r } | j t j k r t | n q Xn( | d k r t |
d r |
j n | r |
j
| | n t r |
j | d | St
j d t |
j | S( s
All arguments except for server_hostname, ssl_context, and ca_cert_dir have
the same meaning as they do when using :func:`ssl.wrap_socket`.
:param server_hostname:
When SNI is supported, the expected hostname of the certificate
:param ssl_context:
A pre-made :class:`SSLContext` object. If none is provided, one will
be created using :func:`create_urllib3_context`.
:param ciphers:
A string of ciphers we wish the client to support. This is not
supported on Python 2.6 as the ssl module does not support it.
:param ca_cert_dir:
A directory containing CA certificates in multiple separate files, as
supported by OpenSSL's -CApath flag or the capath argument to
SSLContext.load_verify_locations().
R' t load_default_certsR9 s An HTTPS request has been made, but the SNI (Subject Name Indication) extension to TLS is not available on this platform. This may cause the server to present an incorrect TLS certificate, which can cause validation failures. You can upgrade to a newer version of Python to solve this. For more information, see https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warningsN( R" R\ R. t IOErrorR t OSErrort errnot ENOENTt hasattrR] R+ R R R6 R7 R ( t sockR& R% R3 R# R9 R4 R' t ssl_contextt ca_cert_dirR[ t e( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt ssl_wrap_socket s.
( i i (+ t
__future__R R` R6 t hmact binasciiR R t hashlibR R R t
exceptionsR R R R" R R R t IS_PYOPENSSLt IS_SECURETRANSPORTRB R RR RG R R R R t ImportErrorR R R t joinRZ R= t objectRN RU RW R\ Rg ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/ssl_.pyt sv
: > PK ! UR & &
timeout.pynu [ from __future__ import absolute_import
# The default socket timeout, used by httplib to indicate that no timeout was
# specified by the user
from socket import _GLOBAL_DEFAULT_TIMEOUT
import time
from ..exceptions import TimeoutStateError
# A sentinel value to indicate that no timeout was specified by the user in
# urllib3
_Default = object()
# Use time.monotonic if available.
current_time = getattr(time, "monotonic", time.time)
class Timeout(object):
""" Timeout configuration.
Timeouts can be defined as a default for a pool::
timeout = Timeout(connect=2.0, read=7.0)
http = PoolManager(timeout=timeout)
response = http.request('GET', 'http://example.com/')
Or per-request (which overrides the default for the pool)::
response = http.request('GET', 'http://example.com/', timeout=Timeout(10))
Timeouts can be disabled by setting all the parameters to ``None``::
no_timeout = Timeout(connect=None, read=None)
response = http.request('GET', 'http://example.com/, timeout=no_timeout)
:param total:
This combines the connect and read timeouts into one; the read timeout
will be set to the time leftover from the connect attempt. In the
event that both a connect timeout and a total are specified, or a read
timeout and a total are specified, the shorter timeout will be applied.
Defaults to None.
:type total: integer, float, or None
:param connect:
The maximum amount of time to wait for a connection attempt to a server
to succeed. Omitting the parameter will default the connect timeout to
the system default, probably `the global default timeout in socket.py
`_.
None will set an infinite timeout for connection attempts.
:type connect: integer, float, or None
:param read:
The maximum amount of time to wait between consecutive
read operations for a response from the server. Omitting
the parameter will default the read timeout to the system
default, probably `the global default timeout in socket.py
`_.
None will set an infinite timeout.
:type read: integer, float, or None
.. note::
Many factors can affect the total amount of time for urllib3 to return
an HTTP response.
For example, Python's DNS resolver does not obey the timeout specified
on the socket. Other factors that can affect total request time include
high CPU load, high swap, the program running at a low priority level,
or other behaviors.
In addition, the read and total timeouts only measure the time between
read operations on the socket connecting the client and the server,
not the total amount of time for the request to return a complete
response. For most requests, the timeout is raised because the server
has not sent the first byte in the specified time. This is not always
the case; if a server streams one byte every fifteen seconds, a timeout
of 20 seconds will not trigger, even though the request will take
several minutes to complete.
If your goal is to cut off any request after a set amount of wall clock
time, consider having a second "watcher" thread to cut off a slow
request.
"""
#: A sentinel object representing the default timeout value
DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT
def __init__(self, total=None, connect=_Default, read=_Default):
self._connect = self._validate_timeout(connect, 'connect')
self._read = self._validate_timeout(read, 'read')
self.total = self._validate_timeout(total, 'total')
self._start_connect = None
def __str__(self):
return '%s(connect=%r, read=%r, total=%r)' % (
type(self).__name__, self._connect, self._read, self.total)
@classmethod
def _validate_timeout(cls, value, name):
""" Check that a timeout attribute is valid.
:param value: The timeout value to validate
:param name: The name of the timeout attribute to validate. This is
used to specify in error messages.
:return: The validated and casted version of the given value.
:raises ValueError: If it is a numeric value less than or equal to
zero, or the type is not an integer, float, or None.
"""
if value is _Default:
return cls.DEFAULT_TIMEOUT
if value is None or value is cls.DEFAULT_TIMEOUT:
return value
if isinstance(value, bool):
raise ValueError("Timeout cannot be a boolean value. It must "
"be an int, float or None.")
try:
float(value)
except (TypeError, ValueError):
raise ValueError("Timeout value %s was %s, but it must be an "
"int, float or None." % (name, value))
try:
if value <= 0:
raise ValueError("Attempted to set %s timeout to %s, but the "
"timeout cannot be set to a value less "
"than or equal to 0." % (name, value))
except TypeError: # Python 3
raise ValueError("Timeout value %s was %s, but it must be an "
"int, float or None." % (name, value))
return value
@classmethod
def from_float(cls, timeout):
""" Create a new Timeout from a legacy timeout value.
The timeout value used by httplib.py sets the same timeout on the
connect(), and recv() socket requests. This creates a :class:`Timeout`
object that sets the individual timeouts to the ``timeout`` value
passed to this function.
:param timeout: The legacy timeout value.
:type timeout: integer, float, sentinel default object, or None
:return: Timeout object
:rtype: :class:`Timeout`
"""
return Timeout(read=timeout, connect=timeout)
def clone(self):
""" Create a copy of the timeout object
Timeout properties are stored per-pool but each request needs a fresh
Timeout object to ensure each one has its own start/stop configured.
:return: a copy of the timeout object
:rtype: :class:`Timeout`
"""
# We can't use copy.deepcopy because that will also create a new object
# for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to
# detect the user default.
return Timeout(connect=self._connect, read=self._read,
total=self.total)
def start_connect(self):
""" Start the timeout clock, used during a connect() attempt
:raises urllib3.exceptions.TimeoutStateError: if you attempt
to start a timer that has been started already.
"""
if self._start_connect is not None:
raise TimeoutStateError("Timeout timer has already been started.")
self._start_connect = current_time()
return self._start_connect
def get_connect_duration(self):
""" Gets the time elapsed since the call to :meth:`start_connect`.
:return: Elapsed time.
:rtype: float
:raises urllib3.exceptions.TimeoutStateError: if you attempt
to get duration for a timer that hasn't been started.
"""
if self._start_connect is None:
raise TimeoutStateError("Can't get connect duration for timer "
"that has not started.")
return current_time() - self._start_connect
@property
def connect_timeout(self):
""" Get the value to use when setting a connection timeout.
This will be a positive float or integer, the value None
(never timeout), or the default system timeout.
:return: Connect timeout.
:rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
"""
if self.total is None:
return self._connect
if self._connect is None or self._connect is self.DEFAULT_TIMEOUT:
return self.total
return min(self._connect, self.total)
@property
def read_timeout(self):
""" Get the value for the read timeout.
This assumes some time has elapsed in the connection timeout and
computes the read timeout appropriately.
If self.total is set, the read timeout is dependent on the amount of
time taken by the connect timeout. If the connection time has not been
established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be
raised.
:return: Value to use for the read timeout.
:rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
:raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`
has not yet been called on this object.
"""
if (self.total is not None and
self.total is not self.DEFAULT_TIMEOUT and
self._read is not None and
self._read is not self.DEFAULT_TIMEOUT):
# In case the connect timeout has not yet been established.
if self._start_connect is None:
return self._read
return max(0, min(self.total - self.get_connect_duration(),
self._read))
elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT:
return max(0, self.total - self.get_connect_duration())
else:
return self._read
PK !
\% % timeout.pycnu [
abc @@ st d d l m Z d d l m Z d d l Z d d l m Z e Z e e d e j Z
d e f d YZ d S( i ( t absolute_import( t _GLOBAL_DEFAULT_TIMEOUTNi ( t TimeoutStateErrort monotonict Timeoutc B@ s e Z d Z e Z d
e e d Z d Z e d Z
e d Z d Z d Z
d Z e d Z e d Z RS( s Timeout configuration.
Timeouts can be defined as a default for a pool::
timeout = Timeout(connect=2.0, read=7.0)
http = PoolManager(timeout=timeout)
response = http.request('GET', 'http://example.com/')
Or per-request (which overrides the default for the pool)::
response = http.request('GET', 'http://example.com/', timeout=Timeout(10))
Timeouts can be disabled by setting all the parameters to ``None``::
no_timeout = Timeout(connect=None, read=None)
response = http.request('GET', 'http://example.com/, timeout=no_timeout)
:param total:
This combines the connect and read timeouts into one; the read timeout
will be set to the time leftover from the connect attempt. In the
event that both a connect timeout and a total are specified, or a read
timeout and a total are specified, the shorter timeout will be applied.
Defaults to None.
:type total: integer, float, or None
:param connect:
The maximum amount of time to wait for a connection attempt to a server
to succeed. Omitting the parameter will default the connect timeout to
the system default, probably `the global default timeout in socket.py
`_.
None will set an infinite timeout for connection attempts.
:type connect: integer, float, or None
:param read:
The maximum amount of time to wait between consecutive
read operations for a response from the server. Omitting
the parameter will default the read timeout to the system
default, probably `the global default timeout in socket.py
`_.
None will set an infinite timeout.
:type read: integer, float, or None
.. note::
Many factors can affect the total amount of time for urllib3 to return
an HTTP response.
For example, Python's DNS resolver does not obey the timeout specified
on the socket. Other factors that can affect total request time include
high CPU load, high swap, the program running at a low priority level,
or other behaviors.
In addition, the read and total timeouts only measure the time between
read operations on the socket connecting the client and the server,
not the total amount of time for the request to return a complete
response. For most requests, the timeout is raised because the server
has not sent the first byte in the specified time. This is not always
the case; if a server streams one byte every fifteen seconds, a timeout
of 20 seconds will not trigger, even though the request will take
several minutes to complete.
If your goal is to cut off any request after a set amount of wall clock
time, consider having a second "watcher" thread to cut off a slow
request.
c C@ sL | j | d | _ | j | d | _ | j | d | _ d | _ d S( Nt connectt readt total( t _validate_timeoutt _connectt _readR t Nonet _start_connect( t selfR R R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt __init__] s c C@ s& d t | j | j | j | j f S( Ns! %s(connect=%r, read=%r, total=%r)( t typet __name__R R
R ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt __str__c s c C@ s | t k r | j S| d k s. | | j k r2 | St | t rP t d n y t | Wn- t t f k
r t d | | f n Xy) | d k r t d | | f n Wn' t k
r t d | | f n X| S( s Check that a timeout attribute is valid.
:param value: The timeout value to validate
:param name: The name of the timeout attribute to validate. This is
used to specify in error messages.
:return: The validated and casted version of the given value.
:raises ValueError: If it is a numeric value less than or equal to
zero, or the type is not an integer, float, or None.
sD Timeout cannot be a boolean value. It must be an int, float or None.s> Timeout value %s was %s, but it must be an int, float or None.i sd Attempted to set %s timeout to %s, but the timeout cannot be set to a value less than or equal to 0.N( t _Defaultt DEFAULT_TIMEOUTR t
isinstancet boolt
ValueErrort floatt TypeError( t clst valuet name( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyR g s&
c C@ s t d | d | S( s Create a new Timeout from a legacy timeout value.
The timeout value used by httplib.py sets the same timeout on the
connect(), and recv() socket requests. This creates a :class:`Timeout`
object that sets the individual timeouts to the ``timeout`` value
passed to this function.
:param timeout: The legacy timeout value.
:type timeout: integer, float, sentinel default object, or None
:return: Timeout object
:rtype: :class:`Timeout`
R R ( R ( R t timeout( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt
from_float s c C@ s" t d | j d | j d | j S( s Create a copy of the timeout object
Timeout properties are stored per-pool but each request needs a fresh
Timeout object to ensure each one has its own start/stop configured.
:return: a copy of the timeout object
:rtype: :class:`Timeout`
R R R ( R R R
R ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt clone s c C@ s1 | j d k r t d n t | _ | j S( s Start the timeout clock, used during a connect() attempt
:raises urllib3.exceptions.TimeoutStateError: if you attempt
to start a timer that has been started already.
s' Timeout timer has already been started.N( R R R t current_time( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt
start_connect s c C@ s, | j d k r t d n t | j S( s Gets the time elapsed since the call to :meth:`start_connect`.
:return: Elapsed time.
:rtype: float
:raises urllib3.exceptions.TimeoutStateError: if you attempt
to get duration for a timer that hasn't been started.
s: Can't get connect duration for timer that has not started.N( R R R R ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt get_connect_duration s c C@ sQ | j d k r | j S| j d k s7 | j | j k r> | j St | j | j S( s" Get the value to use when setting a connection timeout.
This will be a positive float or integer, the value None
(never timeout), or the default system timeout.
:return: Connect timeout.
:rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
N( R R R R t min( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt connect_timeout s
!c C@ s | j d k r~ | j | j k r~ | j d k r~ | j | j k r~ | j d k rX | j St d t | j | j | j S| j d k r | j | j k r t d | j | j S| j Sd S( s Get the value for the read timeout.
This assumes some time has elapsed in the connection timeout and
computes the read timeout appropriately.
If self.total is set, the read timeout is dependent on the amount of
time taken by the connect timeout. If the connection time has not been
established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be
raised.
:return: Value to use for the read timeout.
:rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
:raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`
has not yet been called on this object.
i N( R R R R
R t maxR" R! ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt read_timeout s
!N( R t
__module__t __doc__R R R R R R t classmethodR R R R R! t propertyR# R% ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyR s F %
( t
__future__R t socketR t timet
exceptionsR t objectR t getattrR R ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt s PK !
\% % timeout.pyonu [
abc @@ st d d l m Z d d l m Z d d l Z d d l m Z e Z e e d e j Z
d e f d YZ d S( i ( t absolute_import( t _GLOBAL_DEFAULT_TIMEOUTNi ( t TimeoutStateErrort monotonict Timeoutc B@ s e Z d Z e Z d
e e d Z d Z e d Z
e d Z d Z d Z
d Z e d Z e d Z RS( s Timeout configuration.
Timeouts can be defined as a default for a pool::
timeout = Timeout(connect=2.0, read=7.0)
http = PoolManager(timeout=timeout)
response = http.request('GET', 'http://example.com/')
Or per-request (which overrides the default for the pool)::
response = http.request('GET', 'http://example.com/', timeout=Timeout(10))
Timeouts can be disabled by setting all the parameters to ``None``::
no_timeout = Timeout(connect=None, read=None)
response = http.request('GET', 'http://example.com/, timeout=no_timeout)
:param total:
This combines the connect and read timeouts into one; the read timeout
will be set to the time leftover from the connect attempt. In the
event that both a connect timeout and a total are specified, or a read
timeout and a total are specified, the shorter timeout will be applied.
Defaults to None.
:type total: integer, float, or None
:param connect:
The maximum amount of time to wait for a connection attempt to a server
to succeed. Omitting the parameter will default the connect timeout to
the system default, probably `the global default timeout in socket.py
`_.
None will set an infinite timeout for connection attempts.
:type connect: integer, float, or None
:param read:
The maximum amount of time to wait between consecutive
read operations for a response from the server. Omitting
the parameter will default the read timeout to the system
default, probably `the global default timeout in socket.py
`_.
None will set an infinite timeout.
:type read: integer, float, or None
.. note::
Many factors can affect the total amount of time for urllib3 to return
an HTTP response.
For example, Python's DNS resolver does not obey the timeout specified
on the socket. Other factors that can affect total request time include
high CPU load, high swap, the program running at a low priority level,
or other behaviors.
In addition, the read and total timeouts only measure the time between
read operations on the socket connecting the client and the server,
not the total amount of time for the request to return a complete
response. For most requests, the timeout is raised because the server
has not sent the first byte in the specified time. This is not always
the case; if a server streams one byte every fifteen seconds, a timeout
of 20 seconds will not trigger, even though the request will take
several minutes to complete.
If your goal is to cut off any request after a set amount of wall clock
time, consider having a second "watcher" thread to cut off a slow
request.
c C@ sL | j | d | _ | j | d | _ | j | d | _ d | _ d S( Nt connectt readt total( t _validate_timeoutt _connectt _readR t Nonet _start_connect( t selfR R R ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt __init__] s c C@ s& d t | j | j | j | j f S( Ns! %s(connect=%r, read=%r, total=%r)( t typet __name__R R
R ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt __str__c s c C@ s | t k r | j S| d k s. | | j k r2 | St | t rP t d n y t | Wn- t t f k
r t d | | f n Xy) | d k r t d | | f n Wn' t k
r t d | | f n X| S( s Check that a timeout attribute is valid.
:param value: The timeout value to validate
:param name: The name of the timeout attribute to validate. This is
used to specify in error messages.
:return: The validated and casted version of the given value.
:raises ValueError: If it is a numeric value less than or equal to
zero, or the type is not an integer, float, or None.
sD Timeout cannot be a boolean value. It must be an int, float or None.s> Timeout value %s was %s, but it must be an int, float or None.i sd Attempted to set %s timeout to %s, but the timeout cannot be set to a value less than or equal to 0.N( t _Defaultt DEFAULT_TIMEOUTR t
isinstancet boolt
ValueErrort floatt TypeError( t clst valuet name( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyR g s&
c C@ s t d | d | S( s Create a new Timeout from a legacy timeout value.
The timeout value used by httplib.py sets the same timeout on the
connect(), and recv() socket requests. This creates a :class:`Timeout`
object that sets the individual timeouts to the ``timeout`` value
passed to this function.
:param timeout: The legacy timeout value.
:type timeout: integer, float, sentinel default object, or None
:return: Timeout object
:rtype: :class:`Timeout`
R R ( R ( R t timeout( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt
from_float s c C@ s" t d | j d | j d | j S( s Create a copy of the timeout object
Timeout properties are stored per-pool but each request needs a fresh
Timeout object to ensure each one has its own start/stop configured.
:return: a copy of the timeout object
:rtype: :class:`Timeout`
R R R ( R R R
R ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt clone s c C@ s1 | j d k r t d n t | _ | j S( s Start the timeout clock, used during a connect() attempt
:raises urllib3.exceptions.TimeoutStateError: if you attempt
to start a timer that has been started already.
s' Timeout timer has already been started.N( R R R t current_time( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt
start_connect s c C@ s, | j d k r t d n t | j S( s Gets the time elapsed since the call to :meth:`start_connect`.
:return: Elapsed time.
:rtype: float
:raises urllib3.exceptions.TimeoutStateError: if you attempt
to get duration for a timer that hasn't been started.
s: Can't get connect duration for timer that has not started.N( R R R R ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt get_connect_duration s c C@ sQ | j d k r | j S| j d k s7 | j | j k r> | j St | j | j S( s" Get the value to use when setting a connection timeout.
This will be a positive float or integer, the value None
(never timeout), or the default system timeout.
:return: Connect timeout.
:rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
N( R R R R t min( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt connect_timeout s
!c C@ s | j d k r~ | j | j k r~ | j d k r~ | j | j k r~ | j d k rX | j St d t | j | j | j S| j d k r | j | j k r t d | j | j S| j Sd S( s Get the value for the read timeout.
This assumes some time has elapsed in the connection timeout and
computes the read timeout appropriately.
If self.total is set, the read timeout is dependent on the amount of
time taken by the connect timeout. If the connection time has not been
established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be
raised.
:return: Value to use for the read timeout.
:rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
:raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`
has not yet been called on this object.
i N( R R R R
R t maxR" R! ( R
( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt read_timeout s
!N( R t
__module__t __doc__R R R R R R t classmethodR R R R R! t propertyR# R% ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyR s F %
( t
__future__R t socketR t timet
exceptionsR t objectR t getattrR R ( ( ( sD /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/timeout.pyt s PK ! ԗ url.pynu [ from __future__ import absolute_import
from collections import namedtuple
import re
from ..exceptions import LocationParseError
url_attrs = ['scheme', 'auth', 'host', 'port', 'path', 'query', 'fragment']
# We only want to normalize urls with an HTTP(S) scheme.
# urllib3 infers URLs without a scheme (None) to be http.
NORMALIZABLE_SCHEMES = ('http', 'https', None)
_contains_disallowed_url_pchar_re = re.compile('[\x00-\x20\x7f]')
from ..packages.six.moves.urllib.parse import quote
class Url(namedtuple('Url', url_attrs)):
"""
Datastructure for representing an HTTP URL. Used as a return value for
:func:`parse_url`. Both the scheme and host are normalized as they are
both case-insensitive according to RFC 3986.
"""
__slots__ = ()
def __new__(cls, scheme=None, auth=None, host=None, port=None, path=None,
query=None, fragment=None):
if path and not path.startswith('/'):
path = '/' + path
if scheme:
scheme = scheme.lower()
if host and scheme in NORMALIZABLE_SCHEMES:
host = host.lower()
return super(Url, cls).__new__(cls, scheme, auth, host, port, path,
query, fragment)
@property
def hostname(self):
"""For backwards-compatibility with urlparse. We're nice like that."""
return self.host
@property
def request_uri(self):
"""Absolute path including the query string."""
uri = self.path or '/'
if self.query is not None:
uri += '?' + self.query
return uri
@property
def netloc(self):
"""Network location including host and port"""
if self.port:
return '%s:%d' % (self.host, self.port)
return self.host
@property
def url(self):
"""
Convert self into a url
This function should more or less round-trip with :func:`.parse_url`. The
returned url may not be exactly the same as the url inputted to
:func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
with a blank port will have : removed).
Example: ::
>>> U = parse_url('http://google.com/mail/')
>>> U.url
'http://google.com/mail/'
>>> Url('http', 'username:password', 'host.com', 80,
... '/path', 'query', 'fragment').url
'http://username:password@host.com:80/path?query#fragment'
"""
scheme, auth, host, port, path, query, fragment = self
url = ''
# We use "is not None" we want things to happen with empty strings (or 0 port)
if scheme is not None:
url += scheme + '://'
if auth is not None:
url += auth + '@'
if host is not None:
url += host
if port is not None:
url += ':' + str(port)
if path is not None:
url += path
if query is not None:
url += '?' + query
if fragment is not None:
url += '#' + fragment
return url
def __str__(self):
return self.url
def split_first(s, delims):
"""
Given a string and an iterable of delimiters, split on the first found
delimiter. Return two split parts and the matched delimiter.
If not found, then the first part is the full input string.
Example::
>>> split_first('foo/bar?baz', '?/=')
('foo', 'bar?baz', '/')
>>> split_first('foo/bar?baz', '123')
('foo/bar?baz', '', None)
Scales linearly with number of delims. Not ideal for large number of delims.
"""
min_idx = None
min_delim = None
for d in delims:
idx = s.find(d)
if idx < 0:
continue
if min_idx is None or idx < min_idx:
min_idx = idx
min_delim = d
if min_idx is None or min_idx < 0:
return s, '', None
return s[:min_idx], s[min_idx + 1:], min_delim
def parse_url(url):
"""
Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
performed to parse incomplete urls. Fields not provided will be None.
Partly backwards-compatible with :mod:`urlparse`.
Example::
>>> parse_url('http://google.com/mail/')
Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
>>> parse_url('google.com:80')
Url(scheme=None, host='google.com', port=80, path=None, ...)
>>> parse_url('/foo?bar')
Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
"""
# While this code has overlap with stdlib's urlparse, it is much
# simplified for our needs and less annoying.
# Additionally, this implementations does silly things to be optimal
# on CPython.
if not url:
# Empty
return Url()
# Prevent CVE-2019-9740.
# adapted from https://github.com/python/cpython/pull/12755
url = _contains_disallowed_url_pchar_re.sub(lambda match: quote(match.group()), url)
scheme = None
auth = None
host = None
port = None
path = None
fragment = None
query = None
# Scheme
if '://' in url:
scheme, url = url.split('://', 1)
# Find the earliest Authority Terminator
# (http://tools.ietf.org/html/rfc3986#section-3.2)
url, path_, delim = split_first(url, ['/', '?', '#'])
if delim:
# Reassemble the path
path = delim + path_
# Auth
if '@' in url:
# Last '@' denotes end of auth part
auth, url = url.rsplit('@', 1)
# IPv6
if url and url[0] == '[':
host, url = url.split(']', 1)
host += ']'
# Port
if ':' in url:
_host, port = url.split(':', 1)
if not host:
host = _host
if port:
# If given, ports must be integers. No whitespace, no plus or
# minus prefixes, no non-integer digits such as ^2 (superscript).
if not port.isdigit():
raise LocationParseError(url)
try:
port = int(port)
except ValueError:
raise LocationParseError(url)
else:
# Blank ports are cool, too. (rfc3986#section-3.2.3)
port = None
elif not host and url:
host = url
if not path:
return Url(scheme, auth, host, port, path, query, fragment)
# Fragment
if '#' in path:
path, fragment = path.split('#', 1)
# Query
if '?' in path:
path, query = path.split('?', 1)
return Url(scheme, auth, host, port, path, query, fragment)
def get_host(url):
"""
Deprecated. Use :func:`parse_url` instead.
"""
p = parse_url(url)
return p.scheme or 'http', p.hostname, p.port
PK ! 31u u url.pycnu [
abc @@ s d d l m Z d d l m Z d d l Z d d l m Z d d d d d
d d g Z d Z e j
d Z d d l m
Z
d e d e f d YZ d Z d Z d Z d S( i ( t absolute_import( t
namedtupleNi ( t LocationParseErrort schemet autht hostt portt patht queryt fragmentt httpt httpss [ - ]( t quotet Urlc B@ sw e Z d Z d Z d d d d d d d d Z e d Z e d Z e d Z e d Z
d Z RS( s
Datastructure for representing an HTTP URL. Used as a return value for
:func:`parse_url`. Both the scheme and host are normalized as they are
both case-insensitive according to RFC 3986.
c C@ s | r# | j d r# d | } n | r8 | j } n | rY | t k rY | j } n t t | j | | | | | | | | S( Nt /( t
startswitht lowert NORMALIZABLE_SCHEMESt superR
t __new__( t clsR R R R R R R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyR s
!c C@ s | j S( s@ For backwards-compatibility with urlparse. We're nice like that.( R ( t self( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt hostname$ s c C@ s6 | j p d } | j d k r2 | d | j 7} n | S( s) Absolute path including the query string.R t ?N( R R t None( R t uri( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt request_uri) s c C@ s$ | j r d | j | j f S| j S( s( Network location including host and ports %s:%d( R R ( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt netloc3 s c C@ s | \ } } } } } } } d } | d k r> | | d 7} n | d k r[ | | d 7} n | d k rt | | 7} n | d k r | d t | 7} n | d k r | | 7} n | d k r | d | 7} n | d k r | d | 7} n | S( s
Convert self into a url
This function should more or less round-trip with :func:`.parse_url`. The
returned url may not be exactly the same as the url inputted to
:func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
with a blank port will have : removed).
Example: ::
>>> U = parse_url('http://google.com/mail/')
>>> U.url
'http://google.com/mail/'
>>> Url('http', 'username:password', 'host.com', 80,
... '/path', 'query', 'fragment').url
'http://username:password@host.com:80/path?query#fragment'
t s ://t @t :R t #N( R t str( R R R R R R R R t url( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyR! : s"
c C@ s | j S( N( R! ( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt __str__b s ( N( t __name__t
__module__t __doc__t __slots__R R t propertyR R R R! R" ( ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyR
s
(c C@ s d } d } xV | D]N } | j | } | d k r: q n | d k sR | | k r | } | } q q W| d k s} | d k r | d d f S| | | | d | f S( s
Given a string and an iterable of delimiters, split on the first found
delimiter. Return two split parts and the matched delimiter.
If not found, then the first part is the full input string.
Example::
>>> split_first('foo/bar?baz', '?/=')
('foo', 'bar?baz', '/')
>>> split_first('foo/bar?baz', '123')
('foo/bar?baz', '', None)
Scales linearly with number of delims. Not ideal for large number of delims.
i R i N( R t find( t st delimst min_idxt min_delimt dt idx( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt split_firstf s
c C@ s; | s
t St j d | } d } d } d } d } d } d } d } d | k rs | j d d \ } } n t | d d d g \ } } } | r | | } n d | k r | j d d \ } } n | r | d d k r | j d
d \ } } | d
7} n d | k r| j d d \ }
} | s<|
} n | r| j s]t | n y t | } Wqt
k
rt | qXqd } n | r| r| } n | st | | | | | | | Sd | k r| j d d \ } } n d | k r | j d d \ } } n t | | | | | | | S(
s:
Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
performed to parse incomplete urls. Fields not provided will be None.
Partly backwards-compatible with :mod:`urlparse`.
Example::
>>> parse_url('http://google.com/mail/')
Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
>>> parse_url('google.com:80')
Url(scheme=None, host='google.com', port=80, path=None, ...)
>>> parse_url('/foo?bar')
Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
c S@ s t | j S( N( R t group( t match( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt R s ://i R R R R i t [t ]R N( R
t! _contains_disallowed_url_pchar_ret subR t splitR/ t rsplitt isdigitR t intt
ValueError( R! R R R R R R R t path_t delimt _host( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt parse_url sR !
c C@ s( t | } | j p d | j | j f S( s4
Deprecated. Use :func:`parse_url` instead.
R
( R? R R R ( R! t p( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt get_host s ( R
R N( t
__future__R t collectionsR t ret
exceptionsR t url_attrsR R t compileR5 t packages.six.moves.urllib.parseR R
R/ R? RA ( ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt s U ! aPK ! 31u u url.pyonu [
abc @@ s d d l m Z d d l m Z d d l Z d d l m Z d d d d d
d d g Z d Z e j
d Z d d l m
Z
d e d e f d YZ d Z d Z d Z d S( i ( t absolute_import( t
namedtupleNi ( t LocationParseErrort schemet autht hostt portt patht queryt fragmentt httpt httpss [ - ]( t quotet Urlc B@ sw e Z d Z d Z d d d d d d d d Z e d Z e d Z e d Z e d Z
d Z RS( s
Datastructure for representing an HTTP URL. Used as a return value for
:func:`parse_url`. Both the scheme and host are normalized as they are
both case-insensitive according to RFC 3986.
c C@ s | r# | j d r# d | } n | r8 | j } n | rY | t k rY | j } n t t | j | | | | | | | | S( Nt /( t
startswitht lowert NORMALIZABLE_SCHEMESt superR
t __new__( t clsR R R R R R R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyR s
!c C@ s | j S( s@ For backwards-compatibility with urlparse. We're nice like that.( R ( t self( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt hostname$ s c C@ s6 | j p d } | j d k r2 | d | j 7} n | S( s) Absolute path including the query string.R t ?N( R R t None( R t uri( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt request_uri) s c C@ s$ | j r d | j | j f S| j S( s( Network location including host and ports %s:%d( R R ( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt netloc3 s c C@ s | \ } } } } } } } d } | d k r> | | d 7} n | d k r[ | | d 7} n | d k rt | | 7} n | d k r | d t | 7} n | d k r | | 7} n | d k r | d | 7} n | d k r | d | 7} n | S( s
Convert self into a url
This function should more or less round-trip with :func:`.parse_url`. The
returned url may not be exactly the same as the url inputted to
:func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
with a blank port will have : removed).
Example: ::
>>> U = parse_url('http://google.com/mail/')
>>> U.url
'http://google.com/mail/'
>>> Url('http', 'username:password', 'host.com', 80,
... '/path', 'query', 'fragment').url
'http://username:password@host.com:80/path?query#fragment'
t s ://t @t :R t #N( R t str( R R R R R R R R t url( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyR! : s"
c C@ s | j S( N( R! ( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt __str__b s ( N( t __name__t
__module__t __doc__t __slots__R R t propertyR R R R! R" ( ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyR
s
(c C@ s d } d } xV | D]N } | j | } | d k r: q n | d k sR | | k r | } | } q q W| d k s} | d k r | d d f S| | | | d | f S( s
Given a string and an iterable of delimiters, split on the first found
delimiter. Return two split parts and the matched delimiter.
If not found, then the first part is the full input string.
Example::
>>> split_first('foo/bar?baz', '?/=')
('foo', 'bar?baz', '/')
>>> split_first('foo/bar?baz', '123')
('foo/bar?baz', '', None)
Scales linearly with number of delims. Not ideal for large number of delims.
i R i N( R t find( t st delimst min_idxt min_delimt dt idx( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt split_firstf s
c C@ s; | s
t St j d | } d } d } d } d } d } d } d } d | k rs | j d d \ } } n t | d d d g \ } } } | r | | } n d | k r | j d d \ } } n | r | d d k r | j d
d \ } } | d
7} n d | k r| j d d \ }
} | s<|
} n | r| j s]t | n y t | } Wqt
k
rt | qXqd } n | r| r| } n | st | | | | | | | Sd | k r| j d d \ } } n d | k r | j d d \ } } n t | | | | | | | S(
s:
Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
performed to parse incomplete urls. Fields not provided will be None.
Partly backwards-compatible with :mod:`urlparse`.
Example::
>>> parse_url('http://google.com/mail/')
Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
>>> parse_url('google.com:80')
Url(scheme=None, host='google.com', port=80, path=None, ...)
>>> parse_url('/foo?bar')
Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
c S@ s t | j S( N( R t group( t match( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt R s ://i R R R R i t [t ]R N( R
t! _contains_disallowed_url_pchar_ret subR t splitR/ t rsplitt isdigitR t intt
ValueError( R! R R R R R R R t path_t delimt _host( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt parse_url sR !
c C@ s( t | } | j p d | j | j f S( s4
Deprecated. Use :func:`parse_url` instead.
R
( R? R R R ( R! t p( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt get_host s ( R
R N( t
__future__R t collectionsR t ret
exceptionsR t url_attrsR R t compileR5 t packages.six.moves.urllib.parseR R
R/ R? RA ( ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/url.pyt s U ! aPK ! <# wait.pynu [ from .selectors import (
HAS_SELECT,
DefaultSelector,
EVENT_READ,
EVENT_WRITE
)
def _wait_for_io_events(socks, events, timeout=None):
""" Waits for IO events to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be interacted with immediately. """
if not HAS_SELECT:
raise ValueError('Platform does not have a selector')
if not isinstance(socks, list):
# Probably just a single socket.
if hasattr(socks, "fileno"):
socks = [socks]
# Otherwise it might be a non-list iterable.
else:
socks = list(socks)
with DefaultSelector() as selector:
for sock in socks:
selector.register(sock, events)
return [key[0].fileobj for key in
selector.select(timeout) if key[1] & events]
def wait_for_read(socks, timeout=None):
""" Waits for reading to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be read from immediately. """
return _wait_for_io_events(socks, EVENT_READ, timeout)
def wait_for_write(socks, timeout=None):
""" Waits for writing to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be written to immediately. """
return _wait_for_io_events(socks, EVENT_WRITE, timeout)
PK ! [32 2 wait.pycnu [
abc @ sJ d d l m Z m Z m Z m Z d d Z d d Z d d Z d S( i ( t
HAS_SELECTt DefaultSelectort
EVENT_READt EVENT_WRITEc C s t s t d n t | t sN t | d r? | g } qN t | } n t ] } x | D] } | j | | qa Wg | j | D]! } | d | @r | d j ^ q SWd QXd S( s Waits for IO events to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be interacted with immediately. s! Platform does not have a selectort filenoi i N( R t
ValueErrort
isinstancet listt hasattrR t registert selectt fileobj( t sockst eventst timeoutt selectort sockt key( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt _wait_for_io_events s
c C s t | t | S( s Waits for reading to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be read from immediately. ( R R ( R R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt
wait_for_read s c C s t | t | S( s Waits for writing to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be written to immediately. ( R R ( R R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt wait_for_write$ s N( t selectorsR R R R t NoneR R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt s " PK ! [32 2 wait.pyonu [
abc @ sJ d d l m Z m Z m Z m Z d d Z d d Z d d Z d S( i ( t
HAS_SELECTt DefaultSelectort
EVENT_READt EVENT_WRITEc C s t s t d n t | t sN t | d r? | g } qN t | } n t ] } x | D] } | j | | qa Wg | j | D]! } | d | @r | d j ^ q SWd QXd S( s Waits for IO events to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be interacted with immediately. s! Platform does not have a selectort filenoi i N( R t
ValueErrort
isinstancet listt hasattrR t registert selectt fileobj( t sockst eventst timeoutt selectort sockt key( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt _wait_for_io_events s
c C s t | t | S( s Waits for reading to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be read from immediately. ( R R ( R R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt
wait_for_read s c C s t | t | S( s Waits for writing to be available from a list of sockets
or optionally a single socket if passed in. Returns a list of
sockets that can be written to immediately. ( R R ( R R ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt wait_for_write$ s N( t selectorsR R R R t NoneR R R ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/urllib3/util/wait.pyt s " PK ! Ru __init__.pynu [ PK ! TN N
O execute.pynu [ PK ! f6l l
R helpers.pynu [ PK ! U3 ; ; 6\ retry.pynu [ PK ! qCA A # n __pycache__/__init__.cpython-38.pycnu [ PK ! &CC CC " __pycache__/execute.cpython-38.pycnu [ PK ! -
" __pycache__/helpers.cpython-38.pycnu [ PK ! v __pycache__/retry.cpython-38.pycnu [ PK ! t __init__.pycnu [ PK ! t I __init__.pyonu [ PK ! _=
connection.pynu [ PK ! 9 L connection.pycnu [ PK ! 9 ! connection.pyonu [ PK ! Aay y
1 request.pynu [ PK !
? request.pycnu [ PK !
N request.pyonu [ PK ! 9 ' ' ] response.pynu [ PK ! 8 f response.pycnu [ PK ! 8 p response.pyonu [ PK ! ML9 9 Uy retry.pycnu [ PK ! ML9 9 retry.pyonu [ PK ! };=R R selectors.pynu [ PK ! Q Q
? selectors.pycnu [ PK ! Q Q
selectors.pyonu [ PK ! e/ / ssl_.pynu [ PK ! {Gm) m) ssl_.pycnu [ PK ! {Gm) m) = ssl_.pyonu [ PK ! UR & &
Qg timeout.pynu [ PK !
\% % timeout.pycnu [ PK !
\% % ׳ timeout.pyonu [ PK ! ԗ url.pynu [ PK ! 31u u url.pycnu [ PK ! 31u u v url.pyonu [ PK ! <# "* wait.pynu [ PK ! [32 2 0 wait.pycnu [ PK ! [32 2 n7 wait.pyonu [ PK $ $
>