Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! 8'w 'w sessions.pynu [ """
requests.sessions
~~~~~~~~~~~~~~~~~
This module provides a Session object to manage and persist settings across
requests (cookies, auth, proxies).
"""
import os
import sys
import time
from collections import OrderedDict
from datetime import timedelta
from ._internal_utils import to_native_string
from .adapters import HTTPAdapter
from .auth import _basic_auth_str
from .compat import Mapping, cookielib, urljoin, urlparse
from .cookies import (
RequestsCookieJar,
cookiejar_from_dict,
extract_cookies_to_jar,
merge_cookies,
)
from .exceptions import (
ChunkedEncodingError,
ContentDecodingError,
InvalidSchema,
TooManyRedirects,
)
from .hooks import default_hooks, dispatch_hook
# formerly defined here, reexposed here for backward compatibility
from .models import ( # noqa: F401
DEFAULT_REDIRECT_LIMIT,
REDIRECT_STATI,
PreparedRequest,
Request,
)
from .status_codes import codes
from .structures import CaseInsensitiveDict
from .utils import ( # noqa: F401
DEFAULT_PORTS,
default_headers,
get_auth_from_url,
get_environ_proxies,
get_netrc_auth,
requote_uri,
resolve_proxies,
rewind_body,
should_bypass_proxies,
to_key_val_list,
)
# Preferred clock, based on which one is more accurate on a given system.
if sys.platform == "win32":
preferred_clock = time.perf_counter
else:
preferred_clock = time.time
def merge_setting(request_setting, session_setting, dict_class=OrderedDict):
"""Determines appropriate setting for a given request, taking into account
the explicit setting on that request, and the setting in the session. If a
setting is a dictionary, they will be merged together using `dict_class`
"""
if session_setting is None:
return request_setting
if request_setting is None:
return session_setting
# Bypass if not a dictionary (e.g. verify)
if not (
isinstance(session_setting, Mapping) and isinstance(request_setting, Mapping)
):
return request_setting
merged_setting = dict_class(to_key_val_list(session_setting))
merged_setting.update(to_key_val_list(request_setting))
# Remove keys that are set to None. Extract keys first to avoid altering
# the dictionary during iteration.
none_keys = [k for (k, v) in merged_setting.items() if v is None]
for key in none_keys:
del merged_setting[key]
return merged_setting
def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict):
"""Properly merges both requests and session hooks.
This is necessary because when request_hooks == {'response': []}, the
merge breaks Session hooks entirely.
"""
if session_hooks is None or session_hooks.get("response") == []:
return request_hooks
if request_hooks is None or request_hooks.get("response") == []:
return session_hooks
return merge_setting(request_hooks, session_hooks, dict_class)
class SessionRedirectMixin:
def get_redirect_target(self, resp):
"""Receives a Response. Returns a redirect URI or ``None``"""
# Due to the nature of how requests processes redirects this method will
# be called at least once upon the original response and at least twice
# on each subsequent redirect response (if any).
# If a custom mixin is used to handle this logic, it may be advantageous
# to cache the redirect location onto the response object as a private
# attribute.
if resp.is_redirect:
location = resp.headers["location"]
# Currently the underlying http module on py3 decode headers
# in latin1, but empirical evidence suggests that latin1 is very
# rarely used with non-ASCII characters in HTTP headers.
# It is more likely to get UTF8 header rather than latin1.
# This causes incorrect handling of UTF8 encoded location headers.
# To solve this, we re-encode the location in latin1.
location = location.encode("latin1")
return to_native_string(location, "utf8")
return None
def should_strip_auth(self, old_url, new_url):
"""Decide whether Authorization header should be removed when redirecting"""
old_parsed = urlparse(old_url)
new_parsed = urlparse(new_url)
if old_parsed.hostname != new_parsed.hostname:
return True
# Special case: allow http -> https redirect when using the standard
# ports. This isn't specified by RFC 7235, but is kept to avoid
# breaking backwards compatibility with older versions of requests
# that allowed any redirects on the same host.
if (
old_parsed.scheme == "http"
and old_parsed.port in (80, None)
and new_parsed.scheme == "https"
and new_parsed.port in (443, None)
):
return False
# Handle default port usage corresponding to scheme.
changed_port = old_parsed.port != new_parsed.port
changed_scheme = old_parsed.scheme != new_parsed.scheme
default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None)
if (
not changed_scheme
and old_parsed.port in default_port
and new_parsed.port in default_port
):
return False
# Standard case: root URI must match
return changed_port or changed_scheme
def resolve_redirects(
self,
resp,
req,
stream=False,
timeout=None,
verify=True,
cert=None,
proxies=None,
yield_requests=False,
**adapter_kwargs,
):
"""Receives a Response. Returns a generator of Responses or Requests."""
hist = [] # keep track of history
url = self.get_redirect_target(resp)
previous_fragment = urlparse(req.url).fragment
while url:
prepared_request = req.copy()
# Update history and keep track of redirects.
# resp.history must ignore the original request in this loop
hist.append(resp)
resp.history = hist[1:]
try:
resp.content # Consume socket so it can be released
except (ChunkedEncodingError, ContentDecodingError, RuntimeError):
resp.raw.read(decode_content=False)
if len(resp.history) >= self.max_redirects:
raise TooManyRedirects(
f"Exceeded {self.max_redirects} redirects.", response=resp
)
# Release the connection back into the pool.
resp.close()
# Handle redirection without scheme (see: RFC 1808 Section 4)
if url.startswith("//"):
parsed_rurl = urlparse(resp.url)
url = ":".join([to_native_string(parsed_rurl.scheme), url])
# Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2)
parsed = urlparse(url)
if parsed.fragment == "" and previous_fragment:
parsed = parsed._replace(fragment=previous_fragment)
elif parsed.fragment:
previous_fragment = parsed.fragment
url = parsed.geturl()
# Facilitate relative 'location' headers, as allowed by RFC 7231.
# (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
# Compliant with RFC3986, we percent encode the url.
if not parsed.netloc:
url = urljoin(resp.url, requote_uri(url))
else:
url = requote_uri(url)
prepared_request.url = to_native_string(url)
self.rebuild_method(prepared_request, resp)
# https://github.com/psf/requests/issues/1084
if resp.status_code not in (
codes.temporary_redirect,
codes.permanent_redirect,
):
# https://github.com/psf/requests/issues/3490
purged_headers = ("Content-Length", "Content-Type", "Transfer-Encoding")
for header in purged_headers:
prepared_request.headers.pop(header, None)
prepared_request.body = None
headers = prepared_request.headers
headers.pop("Cookie", None)
# Extract any cookies sent on the response to the cookiejar
# in the new request. Because we've mutated our copied prepared
# request, use the old one that we haven't yet touched.
extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
merge_cookies(prepared_request._cookies, self.cookies)
prepared_request.prepare_cookies(prepared_request._cookies)
# Rebuild auth and proxy information.
proxies = self.rebuild_proxies(prepared_request, proxies)
self.rebuild_auth(prepared_request, resp)
# A failed tell() sets `_body_position` to `object()`. This non-None
# value ensures `rewindable` will be True, allowing us to raise an
# UnrewindableBodyError, instead of hanging the connection.
rewindable = prepared_request._body_position is not None and (
"Content-Length" in headers or "Transfer-Encoding" in headers
)
# Attempt to rewind consumed file-like object.
if rewindable:
rewind_body(prepared_request)
# Override the original request.
req = prepared_request
if yield_requests:
yield req
else:
resp = self.send(
req,
stream=stream,
timeout=timeout,
verify=verify,
cert=cert,
proxies=proxies,
allow_redirects=False,
**adapter_kwargs,
)
extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)
# extract redirect url, if any, for the next loop
url = self.get_redirect_target(resp)
yield resp
def rebuild_auth(self, prepared_request, response):
"""When being redirected we may want to strip authentication from the
request to avoid leaking credentials. This method intelligently removes
and reapplies authentication where possible to avoid credential loss.
"""
headers = prepared_request.headers
url = prepared_request.url
if "Authorization" in headers and self.should_strip_auth(
response.request.url, url
):
# If we get redirected to a new host, we should strip out any
# authentication headers.
del headers["Authorization"]
# .netrc might have more auth for us on our new host.
new_auth = get_netrc_auth(url) if self.trust_env else None
if new_auth is not None:
prepared_request.prepare_auth(new_auth)
def rebuild_proxies(self, prepared_request, proxies):
"""This method re-evaluates the proxy configuration by considering the
environment variables. If we are redirected to a URL covered by
NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
proxy keys for this URL (in case they were stripped by a previous
redirect).
This method also replaces the Proxy-Authorization header where
necessary.
:rtype: dict
"""
headers = prepared_request.headers
scheme = urlparse(prepared_request.url).scheme
new_proxies = resolve_proxies(prepared_request, proxies, self.trust_env)
if "Proxy-Authorization" in headers:
del headers["Proxy-Authorization"]
try:
username, password = get_auth_from_url(new_proxies[scheme])
except KeyError:
username, password = None, None
# urllib3 handles proxy authorization for us in the standard adapter.
# Avoid appending this to TLS tunneled requests where it may be leaked.
if not scheme.startswith("https") and username and password:
headers["Proxy-Authorization"] = _basic_auth_str(username, password)
return new_proxies
def rebuild_method(self, prepared_request, response):
"""When being redirected we may want to change the method of the request
based on certain specs or browser behavior.
"""
method = prepared_request.method
# https://tools.ietf.org/html/rfc7231#section-6.4.4
if response.status_code == codes.see_other and method != "HEAD":
method = "GET"
# Do what the browsers do, despite standards...
# First, turn 302s into GETs.
if response.status_code == codes.found and method != "HEAD":
method = "GET"
# Second, if a POST is responded to with a 301, turn it into a GET.
# This bizarre behaviour is explained in Issue 1704.
if response.status_code == codes.moved and method == "POST":
method = "GET"
prepared_request.method = method
class Session(SessionRedirectMixin):
"""A Requests session.
Provides cookie persistence, connection-pooling, and configuration.
Basic Usage::
>>> import requests
>>> s = requests.Session()
>>> s.get('https://httpbin.org/get')
Or as a context manager::
>>> with requests.Session() as s:
... s.get('https://httpbin.org/get')
"""
__attrs__ = [
"headers",
"cookies",
"auth",
"proxies",
"hooks",
"params",
"verify",
"cert",
"adapters",
"stream",
"trust_env",
"max_redirects",
]
def __init__(self):
#: A case-insensitive dictionary of headers to be sent on each
#: :class:`Request ` sent from this
#: :class:`Session `.
self.headers = default_headers()
#: Default Authentication tuple or object to attach to
#: :class:`Request `.
self.auth = None
#: Dictionary mapping protocol or protocol and host to the URL of the proxy
#: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to
#: be used on each :class:`Request `.
self.proxies = {}
#: Event-handling hooks.
self.hooks = default_hooks()
#: Dictionary of querystring data to attach to each
#: :class:`Request `. The dictionary values may be lists for
#: representing multivalued query parameters.
self.params = {}
#: Stream response content default.
self.stream = False
#: SSL Verification default.
#: Defaults to `True`, requiring requests to verify the TLS certificate at the
#: remote end.
#: If verify is set to `False`, requests will accept any TLS certificate
#: presented by the server, and will ignore hostname mismatches and/or
#: expired certificates, which will make your application vulnerable to
#: man-in-the-middle (MitM) attacks.
#: Only set this to `False` for testing.
self.verify = True
#: SSL client certificate default, if String, path to ssl client
#: cert file (.pem). If Tuple, ('cert', 'key') pair.
self.cert = None
#: Maximum number of redirects allowed. If the request exceeds this
#: limit, a :class:`TooManyRedirects` exception is raised.
#: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is
#: 30.
self.max_redirects = DEFAULT_REDIRECT_LIMIT
#: Trust environment settings for proxy configuration, default
#: authentication and similar.
self.trust_env = True
#: A CookieJar containing all currently outstanding cookies set on this
#: session. By default it is a
#: :class:`RequestsCookieJar `, but
#: may be any other ``cookielib.CookieJar`` compatible object.
self.cookies = cookiejar_from_dict({})
# Default connection adapters.
self.adapters = OrderedDict()
self.mount("https://", HTTPAdapter())
self.mount("http://", HTTPAdapter())
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
def prepare_request(self, request):
"""Constructs a :class:`PreparedRequest ` for
transmission and returns it. The :class:`PreparedRequest` has settings
merged from the :class:`Request ` instance and those of the
:class:`Session`.
:param request: :class:`Request` instance to prepare with this
session's settings.
:rtype: requests.PreparedRequest
"""
cookies = request.cookies or {}
# Bootstrap CookieJar.
if not isinstance(cookies, cookielib.CookieJar):
cookies = cookiejar_from_dict(cookies)
# Merge with session cookies
merged_cookies = merge_cookies(
merge_cookies(RequestsCookieJar(), self.cookies), cookies
)
# Set environment's basic authentication if not explicitly set.
auth = request.auth
if self.trust_env and not auth and not self.auth:
auth = get_netrc_auth(request.url)
p = PreparedRequest()
p.prepare(
method=request.method.upper(),
url=request.url,
files=request.files,
data=request.data,
json=request.json,
headers=merge_setting(
request.headers, self.headers, dict_class=CaseInsensitiveDict
),
params=merge_setting(request.params, self.params),
auth=merge_setting(auth, self.auth),
cookies=merged_cookies,
hooks=merge_hooks(request.hooks, self.hooks),
)
return p
def request(
self,
method,
url,
params=None,
data=None,
headers=None,
cookies=None,
files=None,
auth=None,
timeout=None,
allow_redirects=True,
proxies=None,
hooks=None,
stream=None,
verify=None,
cert=None,
json=None,
):
"""Constructs a :class:`Request `, prepares it and sends it.
Returns :class:`Response ` object.
:param method: method for the new :class:`Request` object.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary or bytes to be sent in the query
string for the :class:`Request`.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) json to send in the body of the
:class:`Request`.
:param headers: (optional) Dictionary of HTTP Headers to send with the
:class:`Request`.
:param cookies: (optional) Dict or CookieJar object to send with the
:class:`Request`.
:param files: (optional) Dictionary of ``'filename': file-like-objects``
for multipart encoding upload.
:param auth: (optional) Auth tuple or callable to enable
Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) ` tuple.
:type timeout: float or tuple
:param allow_redirects: (optional) Set to True by default.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol or protocol and
hostname to the URL of the proxy.
:param hooks: (optional) Dictionary mapping hook name to one event or
list of events, event must be callable.
:param stream: (optional) whether to immediately download the response
content. Defaults to ``False``.
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use. Defaults to ``True``. When set to
``False``, requests will accept any TLS certificate presented by
the server, and will ignore hostname mismatches and/or expired
certificates, which will make your application vulnerable to
man-in-the-middle (MitM) attacks. Setting verify to ``False``
may be useful during local development or testing.
:param cert: (optional) if String, path to ssl client cert file (.pem).
If Tuple, ('cert', 'key') pair.
:rtype: requests.Response
"""
# Create the Request.
req = Request(
method=method.upper(),
url=url,
headers=headers,
files=files,
data=data or {},
json=json,
params=params or {},
auth=auth,
cookies=cookies,
hooks=hooks,
)
prep = self.prepare_request(req)
proxies = proxies or {}
settings = self.merge_environment_settings(
prep.url, proxies, stream, verify, cert
)
# Send the request.
send_kwargs = {
"timeout": timeout,
"allow_redirects": allow_redirects,
}
send_kwargs.update(settings)
resp = self.send(prep, **send_kwargs)
return resp
def get(self, url, **kwargs):
r"""Sends a GET request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
"""
kwargs.setdefault("allow_redirects", True)
return self.request("GET", url, **kwargs)
def options(self, url, **kwargs):
r"""Sends a OPTIONS request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
"""
kwargs.setdefault("allow_redirects", True)
return self.request("OPTIONS", url, **kwargs)
def head(self, url, **kwargs):
r"""Sends a HEAD request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
"""
kwargs.setdefault("allow_redirects", False)
return self.request("HEAD", url, **kwargs)
def post(self, url, data=None, json=None, **kwargs):
r"""Sends a POST request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) json to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
"""
return self.request("POST", url, data=data, json=json, **kwargs)
def put(self, url, data=None, **kwargs):
r"""Sends a PUT request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
"""
return self.request("PUT", url, data=data, **kwargs)
def patch(self, url, data=None, **kwargs):
r"""Sends a PATCH request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
"""
return self.request("PATCH", url, data=data, **kwargs)
def delete(self, url, **kwargs):
r"""Sends a DELETE request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
"""
return self.request("DELETE", url, **kwargs)
def send(self, request, **kwargs):
"""Send a given PreparedRequest.
:rtype: requests.Response
"""
# Set defaults that the hooks can utilize to ensure they always have
# the correct parameters to reproduce the previous request.
kwargs.setdefault("stream", self.stream)
kwargs.setdefault("verify", self.verify)
kwargs.setdefault("cert", self.cert)
if "proxies" not in kwargs:
kwargs["proxies"] = resolve_proxies(request, self.proxies, self.trust_env)
# It's possible that users might accidentally send a Request object.
# Guard against that specific failure case.
if isinstance(request, Request):
raise ValueError("You can only send PreparedRequests.")
# Set up variables needed for resolve_redirects and dispatching of hooks
allow_redirects = kwargs.pop("allow_redirects", True)
stream = kwargs.get("stream")
hooks = request.hooks
# Get the appropriate adapter to use
adapter = self.get_adapter(url=request.url)
# Start time (approximately) of the request
start = preferred_clock()
# Send the request
r = adapter.send(request, **kwargs)
# Total elapsed time of the request (approximately)
elapsed = preferred_clock() - start
r.elapsed = timedelta(seconds=elapsed)
# Response manipulation hooks
r = dispatch_hook("response", hooks, r, **kwargs)
# Persist cookies
if r.history:
# If the hooks create history then we want those cookies too
for resp in r.history:
extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
extract_cookies_to_jar(self.cookies, request, r.raw)
# Resolve redirects if allowed.
if allow_redirects:
# Redirect resolving generator.
gen = self.resolve_redirects(r, request, **kwargs)
history = [resp for resp in gen]
else:
history = []
# Shuffle things around if there's history.
if history:
# Insert the first (original) request at the start
history.insert(0, r)
# Get the last request made
r = history.pop()
r.history = history
# If redirects aren't being followed, store the response on the Request for Response.next().
if not allow_redirects:
try:
r._next = next(
self.resolve_redirects(r, request, yield_requests=True, **kwargs)
)
except StopIteration:
pass
if not stream:
r.content
return r
def merge_environment_settings(self, url, proxies, stream, verify, cert):
"""
Check the environment and merge it with some settings.
:rtype: dict
"""
# Gather clues from the surrounding environment.
if self.trust_env:
# Set environment's proxies.
no_proxy = proxies.get("no_proxy") if proxies is not None else None
env_proxies = get_environ_proxies(url, no_proxy=no_proxy)
for k, v in env_proxies.items():
proxies.setdefault(k, v)
# Look for requests environment configuration
# and be compatible with cURL.
if verify is True or verify is None:
verify = (
os.environ.get("REQUESTS_CA_BUNDLE")
or os.environ.get("CURL_CA_BUNDLE")
or verify
)
# Merge all the kwargs.
proxies = merge_setting(proxies, self.proxies)
stream = merge_setting(stream, self.stream)
verify = merge_setting(verify, self.verify)
cert = merge_setting(cert, self.cert)
return {"proxies": proxies, "stream": stream, "verify": verify, "cert": cert}
def get_adapter(self, url):
"""
Returns the appropriate connection adapter for the given URL.
:rtype: requests.adapters.BaseAdapter
"""
for prefix, adapter in self.adapters.items():
if url.lower().startswith(prefix.lower()):
return adapter
# Nothing matches :-/
raise InvalidSchema(f"No connection adapters were found for {url!r}")
def close(self):
"""Closes all adapters and as such the session"""
for v in self.adapters.values():
v.close()
def mount(self, prefix, adapter):
"""Registers a connection adapter to a prefix.
Adapters are sorted in descending order by prefix length.
"""
self.adapters[prefix] = adapter
keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]
for key in keys_to_move:
self.adapters[key] = self.adapters.pop(key)
def __getstate__(self):
state = {attr: getattr(self, attr, None) for attr in self.__attrs__}
return state
def __setstate__(self, state):
for attr, value in state.items():
setattr(self, attr, value)
def session():
"""
Returns a :class:`Session` for context-management.
.. deprecated:: 1.0.0
This method has been deprecated since version 1.0.0 and is only kept for
backwards compatibility. New code should use :class:`~requests.sessions.Session`
to create a session. This may be removed at a future date.
:rtype: Session
"""
return Session()
PK ! è models.pynu [ """
requests.models
~~~~~~~~~~~~~~~
This module contains the primary objects that power Requests.
"""
import datetime
# Import encoding now, to avoid implicit import later.
# Implicit import within threads may cause LookupError when standard library is in a ZIP,
# such as in Embedded Python. See https://github.com/psf/requests/issues/3578.
import encodings.idna # noqa: F401
from io import UnsupportedOperation
from pip._vendor.urllib3.exceptions import (
DecodeError,
LocationParseError,
ProtocolError,
ReadTimeoutError,
SSLError,
)
from pip._vendor.urllib3.fields import RequestField
from pip._vendor.urllib3.filepost import encode_multipart_formdata
from pip._vendor.urllib3.util import parse_url
from ._internal_utils import to_native_string, unicode_is_ascii
from .auth import HTTPBasicAuth
from .compat import (
Callable,
JSONDecodeError,
Mapping,
basestring,
builtin_str,
chardet,
cookielib,
)
from .compat import json as complexjson
from .compat import urlencode, urlsplit, urlunparse
from .cookies import _copy_cookie_jar, cookiejar_from_dict, get_cookie_header
from .exceptions import (
ChunkedEncodingError,
ConnectionError,
ContentDecodingError,
HTTPError,
InvalidJSONError,
InvalidURL,
)
from .exceptions import JSONDecodeError as RequestsJSONDecodeError
from .exceptions import MissingSchema
from .exceptions import SSLError as RequestsSSLError
from .exceptions import StreamConsumedError
from .hooks import default_hooks
from .status_codes import codes
from .structures import CaseInsensitiveDict
from .utils import (
check_header_validity,
get_auth_from_url,
guess_filename,
guess_json_utf,
iter_slices,
parse_header_links,
requote_uri,
stream_decode_response_unicode,
super_len,
to_key_val_list,
)
#: The set of HTTP status codes that indicate an automatically
#: processable redirect.
REDIRECT_STATI = (
codes.moved, # 301
codes.found, # 302
codes.other, # 303
codes.temporary_redirect, # 307
codes.permanent_redirect, # 308
)
DEFAULT_REDIRECT_LIMIT = 30
CONTENT_CHUNK_SIZE = 10 * 1024
ITER_CHUNK_SIZE = 512
class RequestEncodingMixin:
@property
def path_url(self):
"""Build the path URL to use."""
url = []
p = urlsplit(self.url)
path = p.path
if not path:
path = "/"
url.append(path)
query = p.query
if query:
url.append("?")
url.append(query)
return "".join(url)
@staticmethod
def _encode_params(data):
"""Encode parameters in a piece of data.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
"""
if isinstance(data, (str, bytes)):
return data
elif hasattr(data, "read"):
return data
elif hasattr(data, "__iter__"):
result = []
for k, vs in to_key_val_list(data):
if isinstance(vs, basestring) or not hasattr(vs, "__iter__"):
vs = [vs]
for v in vs:
if v is not None:
result.append(
(
k.encode("utf-8") if isinstance(k, str) else k,
v.encode("utf-8") if isinstance(v, str) else v,
)
)
return urlencode(result, doseq=True)
else:
return data
@staticmethod
def _encode_files(files, data):
"""Build the body for a multipart/form-data request.
Will successfully encode files when passed as a dict or a list of
tuples. Order is retained if data is a list of tuples but arbitrary
if parameters are supplied as a dict.
The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
or 4-tuples (filename, fileobj, contentype, custom_headers).
"""
if not files:
raise ValueError("Files must be provided.")
elif isinstance(data, basestring):
raise ValueError("Data must not be a string.")
new_fields = []
fields = to_key_val_list(data or {})
files = to_key_val_list(files or {})
for field, val in fields:
if isinstance(val, basestring) or not hasattr(val, "__iter__"):
val = [val]
for v in val:
if v is not None:
# Don't call str() on bytestrings: in Py3 it all goes wrong.
if not isinstance(v, bytes):
v = str(v)
new_fields.append(
(
field.decode("utf-8")
if isinstance(field, bytes)
else field,
v.encode("utf-8") if isinstance(v, str) else v,
)
)
for k, v in files:
# support for explicit filename
ft = None
fh = None
if isinstance(v, (tuple, list)):
if len(v) == 2:
fn, fp = v
elif len(v) == 3:
fn, fp, ft = v
else:
fn, fp, ft, fh = v
else:
fn = guess_filename(v) or k
fp = v
if isinstance(fp, (str, bytes, bytearray)):
fdata = fp
elif hasattr(fp, "read"):
fdata = fp.read()
elif fp is None:
continue
else:
fdata = fp
rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
rf.make_multipart(content_type=ft)
new_fields.append(rf)
body, content_type = encode_multipart_formdata(new_fields)
return body, content_type
class RequestHooksMixin:
def register_hook(self, event, hook):
"""Properly register a hook."""
if event not in self.hooks:
raise ValueError(f'Unsupported event specified, with event name "{event}"')
if isinstance(hook, Callable):
self.hooks[event].append(hook)
elif hasattr(hook, "__iter__"):
self.hooks[event].extend(h for h in hook if isinstance(h, Callable))
def deregister_hook(self, event, hook):
"""Deregister a previously registered hook.
Returns True if the hook existed, False if not.
"""
try:
self.hooks[event].remove(hook)
return True
except ValueError:
return False
class Request(RequestHooksMixin):
"""A user-created :class:`Request ` object.
Used to prepare a :class:`PreparedRequest `, which is sent to the server.
:param method: HTTP method to use.
:param url: URL to send.
:param headers: dictionary of headers to send.
:param files: dictionary of {filename: fileobject} files to multipart upload.
:param data: the body to attach to the request. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param json: json for the body to attach to the request (if files or data is not specified).
:param params: URL parameters to append to the URL. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param auth: Auth handler or (user, pass) tuple.
:param cookies: dictionary or CookieJar of cookies to attach to this request.
:param hooks: dictionary of callback hooks, for internal usage.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> req.prepare()
"""
def __init__(
self,
method=None,
url=None,
headers=None,
files=None,
data=None,
params=None,
auth=None,
cookies=None,
hooks=None,
json=None,
):
# Default empty dicts for dict params.
data = [] if data is None else data
files = [] if files is None else files
headers = {} if headers is None else headers
params = {} if params is None else params
hooks = {} if hooks is None else hooks
self.hooks = default_hooks()
for k, v in list(hooks.items()):
self.register_hook(event=k, hook=v)
self.method = method
self.url = url
self.headers = headers
self.files = files
self.data = data
self.json = json
self.params = params
self.auth = auth
self.cookies = cookies
def __repr__(self):
return f""
def prepare(self):
"""Constructs a :class:`PreparedRequest ` for transmission and returns it."""
p = PreparedRequest()
p.prepare(
method=self.method,
url=self.url,
headers=self.headers,
files=self.files,
data=self.data,
json=self.json,
params=self.params,
auth=self.auth,
cookies=self.cookies,
hooks=self.hooks,
)
return p
class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
"""The fully mutable :class:`PreparedRequest ` object,
containing the exact bytes that will be sent to the server.
Instances are generated from a :class:`Request ` object, and
should not be instantiated manually; doing so may produce undesirable
effects.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> r = req.prepare()
>>> r
>>> s = requests.Session()
>>> s.send(r)
"""
def __init__(self):
#: HTTP verb to send to the server.
self.method = None
#: HTTP URL to send the request to.
self.url = None
#: dictionary of HTTP headers.
self.headers = None
# The `CookieJar` used to create the Cookie header will be stored here
# after prepare_cookies is called
self._cookies = None
#: request body to send to the server.
self.body = None
#: dictionary of callback hooks, for internal usage.
self.hooks = default_hooks()
#: integer denoting starting position of a readable file-like body.
self._body_position = None
def prepare(
self,
method=None,
url=None,
headers=None,
files=None,
data=None,
params=None,
auth=None,
cookies=None,
hooks=None,
json=None,
):
"""Prepares the entire request with the given parameters."""
self.prepare_method(method)
self.prepare_url(url, params)
self.prepare_headers(headers)
self.prepare_cookies(cookies)
self.prepare_body(data, files, json)
self.prepare_auth(auth, url)
# Note that prepare_auth must be last to enable authentication schemes
# such as OAuth to work on a fully prepared request.
# This MUST go after prepare_auth. Authenticators could add a hook
self.prepare_hooks(hooks)
def __repr__(self):
return f""
def copy(self):
p = PreparedRequest()
p.method = self.method
p.url = self.url
p.headers = self.headers.copy() if self.headers is not None else None
p._cookies = _copy_cookie_jar(self._cookies)
p.body = self.body
p.hooks = self.hooks
p._body_position = self._body_position
return p
def prepare_method(self, method):
"""Prepares the given HTTP method."""
self.method = method
if self.method is not None:
self.method = to_native_string(self.method.upper())
@staticmethod
def _get_idna_encoded_host(host):
from pip._vendor import idna
try:
host = idna.encode(host, uts46=True).decode("utf-8")
except idna.IDNAError:
raise UnicodeError
return host
def prepare_url(self, url, params):
"""Prepares the given HTTP URL."""
#: Accept objects that have string representations.
#: We're unable to blindly call unicode/str functions
#: as this will include the bytestring indicator (b'')
#: on python 3.x.
#: https://github.com/psf/requests/pull/2238
if isinstance(url, bytes):
url = url.decode("utf8")
else:
url = str(url)
# Remove leading whitespaces from url
url = url.lstrip()
# Don't do any URL preparation for non-HTTP schemes like `mailto`,
# `data` etc to work around exceptions from `url_parse`, which
# handles RFC 3986 only.
if ":" in url and not url.lower().startswith("http"):
self.url = url
return
# Support for unicode domain names and paths.
try:
scheme, auth, host, port, path, query, fragment = parse_url(url)
except LocationParseError as e:
raise InvalidURL(*e.args)
if not scheme:
raise MissingSchema(
f"Invalid URL {url!r}: No scheme supplied. "
f"Perhaps you meant https://{url}?"
)
if not host:
raise InvalidURL(f"Invalid URL {url!r}: No host supplied")
# In general, we want to try IDNA encoding the hostname if the string contains
# non-ASCII characters. This allows users to automatically get the correct IDNA
# behaviour. For strings containing only ASCII characters, we need to also verify
# it doesn't start with a wildcard (*), before allowing the unencoded hostname.
if not unicode_is_ascii(host):
try:
host = self._get_idna_encoded_host(host)
except UnicodeError:
raise InvalidURL("URL has an invalid label.")
elif host.startswith(("*", ".")):
raise InvalidURL("URL has an invalid label.")
# Carefully reconstruct the network location
netloc = auth or ""
if netloc:
netloc += "@"
netloc += host
if port:
netloc += f":{port}"
# Bare domains aren't valid URLs.
if not path:
path = "/"
if isinstance(params, (str, bytes)):
params = to_native_string(params)
enc_params = self._encode_params(params)
if enc_params:
if query:
query = f"{query}&{enc_params}"
else:
query = enc_params
url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment]))
self.url = url
def prepare_headers(self, headers):
"""Prepares the given HTTP headers."""
self.headers = CaseInsensitiveDict()
if headers:
for header in headers.items():
# Raise exception on invalid header value.
check_header_validity(header)
name, value = header
self.headers[to_native_string(name)] = value
def prepare_body(self, data, files, json=None):
"""Prepares the given HTTP body data."""
# Check if file, fo, generator, iterator.
# If not, run through normal process.
# Nottin' on you.
body = None
content_type = None
if not data and json is not None:
# urllib3 requires a bytes-like body. Python 2's json.dumps
# provides this natively, but Python 3 gives a Unicode string.
content_type = "application/json"
try:
body = complexjson.dumps(json, allow_nan=False)
except ValueError as ve:
raise InvalidJSONError(ve, request=self)
if not isinstance(body, bytes):
body = body.encode("utf-8")
is_stream = all(
[
hasattr(data, "__iter__"),
not isinstance(data, (basestring, list, tuple, Mapping)),
]
)
if is_stream:
try:
length = super_len(data)
except (TypeError, AttributeError, UnsupportedOperation):
length = None
body = data
if getattr(body, "tell", None) is not None:
# Record the current file position before reading.
# This will allow us to rewind a file in the event
# of a redirect.
try:
self._body_position = body.tell()
except OSError:
# This differentiates from None, allowing us to catch
# a failed `tell()` later when trying to rewind the body
self._body_position = object()
if files:
raise NotImplementedError(
"Streamed bodies and files are mutually exclusive."
)
if length:
self.headers["Content-Length"] = builtin_str(length)
else:
self.headers["Transfer-Encoding"] = "chunked"
else:
# Multi-part file uploads.
if files:
(body, content_type) = self._encode_files(files, data)
else:
if data:
body = self._encode_params(data)
if isinstance(data, basestring) or hasattr(data, "read"):
content_type = None
else:
content_type = "application/x-www-form-urlencoded"
self.prepare_content_length(body)
# Add content-type if it wasn't explicitly provided.
if content_type and ("content-type" not in self.headers):
self.headers["Content-Type"] = content_type
self.body = body
def prepare_content_length(self, body):
"""Prepare Content-Length header based on request method and body"""
if body is not None:
length = super_len(body)
if length:
# If length exists, set it. Otherwise, we fallback
# to Transfer-Encoding: chunked.
self.headers["Content-Length"] = builtin_str(length)
elif (
self.method not in ("GET", "HEAD")
and self.headers.get("Content-Length") is None
):
# Set Content-Length to 0 for methods that can have a body
# but don't provide one. (i.e. not GET or HEAD)
self.headers["Content-Length"] = "0"
def prepare_auth(self, auth, url=""):
"""Prepares the given HTTP auth data."""
# If no Auth is explicitly provided, extract it from the URL first.
if auth is None:
url_auth = get_auth_from_url(self.url)
auth = url_auth if any(url_auth) else None
if auth:
if isinstance(auth, tuple) and len(auth) == 2:
# special-case basic HTTP auth
auth = HTTPBasicAuth(*auth)
# Allow auth to make its changes.
r = auth(self)
# Update self to reflect the auth changes.
self.__dict__.update(r.__dict__)
# Recompute Content-Length
self.prepare_content_length(self.body)
def prepare_cookies(self, cookies):
"""Prepares the given HTTP cookie data.
This function eventually generates a ``Cookie`` header from the
given cookies using cookielib. Due to cookielib's design, the header
will not be regenerated if it already exists, meaning this function
can only be called once for the life of the
:class:`PreparedRequest ` object. Any subsequent calls
to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
header is removed beforehand.
"""
if isinstance(cookies, cookielib.CookieJar):
self._cookies = cookies
else:
self._cookies = cookiejar_from_dict(cookies)
cookie_header = get_cookie_header(self._cookies, self)
if cookie_header is not None:
self.headers["Cookie"] = cookie_header
def prepare_hooks(self, hooks):
"""Prepares the given hooks."""
# hooks can be passed as None to the prepare method and to this
# method. To prevent iterating over None, simply use an empty list
# if hooks is False-y
hooks = hooks or []
for event in hooks:
self.register_hook(event, hooks[event])
class Response:
"""The :class:`Response ` object, which contains a
server's response to an HTTP request.
"""
__attrs__ = [
"_content",
"status_code",
"headers",
"url",
"history",
"encoding",
"reason",
"cookies",
"elapsed",
"request",
]
def __init__(self):
self._content = False
self._content_consumed = False
self._next = None
#: Integer Code of responded HTTP Status, e.g. 404 or 200.
self.status_code = None
#: Case-insensitive Dictionary of Response Headers.
#: For example, ``headers['content-encoding']`` will return the
#: value of a ``'Content-Encoding'`` response header.
self.headers = CaseInsensitiveDict()
#: File-like object representation of response (for advanced usage).
#: Use of ``raw`` requires that ``stream=True`` be set on the request.
#: This requirement does not apply for use internally to Requests.
self.raw = None
#: Final URL location of Response.
self.url = None
#: Encoding to decode with when accessing r.text.
self.encoding = None
#: A list of :class:`Response ` objects from
#: the history of the Request. Any redirect responses will end
#: up here. The list is sorted from the oldest to the most recent request.
self.history = []
#: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK".
self.reason = None
#: A CookieJar of Cookies the server sent back.
self.cookies = cookiejar_from_dict({})
#: The amount of time elapsed between sending the request
#: and the arrival of the response (as a timedelta).
#: This property specifically measures the time taken between sending
#: the first byte of the request and finishing parsing the headers. It
#: is therefore unaffected by consuming the response content or the
#: value of the ``stream`` keyword argument.
self.elapsed = datetime.timedelta(0)
#: The :class:`PreparedRequest ` object to which this
#: is a response.
self.request = None
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
def __getstate__(self):
# Consume everything; accessing the content attribute makes
# sure the content has been fully read.
if not self._content_consumed:
self.content
return {attr: getattr(self, attr, None) for attr in self.__attrs__}
def __setstate__(self, state):
for name, value in state.items():
setattr(self, name, value)
# pickled objects do not have .raw
setattr(self, "_content_consumed", True)
setattr(self, "raw", None)
def __repr__(self):
return f""
def __bool__(self):
"""Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
"""
return self.ok
def __nonzero__(self):
"""Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
"""
return self.ok
def __iter__(self):
"""Allows you to use a response as an iterator."""
return self.iter_content(128)
@property
def ok(self):
"""Returns True if :attr:`status_code` is less than 400, False if not.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
"""
try:
self.raise_for_status()
except HTTPError:
return False
return True
@property
def is_redirect(self):
"""True if this Response is a well-formed HTTP redirect that could have
been processed automatically (by :meth:`Session.resolve_redirects`).
"""
return "location" in self.headers and self.status_code in REDIRECT_STATI
@property
def is_permanent_redirect(self):
"""True if this Response one of the permanent versions of redirect."""
return "location" in self.headers and self.status_code in (
codes.moved_permanently,
codes.permanent_redirect,
)
@property
def next(self):
"""Returns a PreparedRequest for the next request in a redirect chain, if there is one."""
return self._next
@property
def apparent_encoding(self):
"""The apparent encoding, provided by the charset_normalizer or chardet libraries."""
if chardet is not None:
return chardet.detect(self.content)["encoding"]
else:
# If no character detection library is available, we'll fall back
# to a standard Python utf-8 str.
return "utf-8"
def iter_content(self, chunk_size=1, decode_unicode=False):
"""Iterates over the response data. When stream=True is set on the
request, this avoids reading the content at once into memory for
large responses. The chunk size is the number of bytes it should
read into memory. This is not necessarily the length of each item
returned as decoding can take place.
chunk_size must be of type int or None. A value of None will
function differently depending on the value of `stream`.
stream=True will read data as it arrives in whatever size the
chunks are received. If stream=False, data is returned as
a single chunk.
If decode_unicode is True, content will be decoded using the best
available encoding based on the response.
"""
def generate():
# Special case for urllib3.
if hasattr(self.raw, "stream"):
try:
yield from self.raw.stream(chunk_size, decode_content=True)
except ProtocolError as e:
raise ChunkedEncodingError(e)
except DecodeError as e:
raise ContentDecodingError(e)
except ReadTimeoutError as e:
raise ConnectionError(e)
except SSLError as e:
raise RequestsSSLError(e)
else:
# Standard file-like object.
while True:
chunk = self.raw.read(chunk_size)
if not chunk:
break
yield chunk
self._content_consumed = True
if self._content_consumed and isinstance(self._content, bool):
raise StreamConsumedError()
elif chunk_size is not None and not isinstance(chunk_size, int):
raise TypeError(
f"chunk_size must be an int, it is instead a {type(chunk_size)}."
)
# simulate reading small chunks of the content
reused_chunks = iter_slices(self._content, chunk_size)
stream_chunks = generate()
chunks = reused_chunks if self._content_consumed else stream_chunks
if decode_unicode:
chunks = stream_decode_response_unicode(chunks, self)
return chunks
def iter_lines(
self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None
):
"""Iterates over the response data, one line at a time. When
stream=True is set on the request, this avoids reading the
content at once into memory for large responses.
.. note:: This method is not reentrant safe.
"""
pending = None
for chunk in self.iter_content(
chunk_size=chunk_size, decode_unicode=decode_unicode
):
if pending is not None:
chunk = pending + chunk
if delimiter:
lines = chunk.split(delimiter)
else:
lines = chunk.splitlines()
if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
pending = lines.pop()
else:
pending = None
yield from lines
if pending is not None:
yield pending
@property
def content(self):
"""Content of the response, in bytes."""
if self._content is False:
# Read the contents.
if self._content_consumed:
raise RuntimeError("The content for this response was already consumed")
if self.status_code == 0 or self.raw is None:
self._content = None
else:
self._content = b"".join(self.iter_content(CONTENT_CHUNK_SIZE)) or b""
self._content_consumed = True
# don't need to release the connection; that's been handled by urllib3
# since we exhausted the data.
return self._content
@property
def text(self):
"""Content of the response, in unicode.
If Response.encoding is None, encoding will be guessed using
``charset_normalizer`` or ``chardet``.
The encoding of the response content is determined based solely on HTTP
headers, following RFC 2616 to the letter. If you can take advantage of
non-HTTP knowledge to make a better guess at the encoding, you should
set ``r.encoding`` appropriately before accessing this property.
"""
# Try charset from content-type
content = None
encoding = self.encoding
if not self.content:
return ""
# Fallback to auto-detected encoding.
if self.encoding is None:
encoding = self.apparent_encoding
# Decode unicode from given encoding.
try:
content = str(self.content, encoding, errors="replace")
except (LookupError, TypeError):
# A LookupError is raised if the encoding was not found which could
# indicate a misspelling or similar mistake.
#
# A TypeError can be raised if encoding is None
#
# So we try blindly encoding.
content = str(self.content, errors="replace")
return content
def json(self, **kwargs):
r"""Decodes the JSON response body (if any) as a Python object.
This may return a dictionary, list, etc. depending on what is in the response.
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
:raises requests.exceptions.JSONDecodeError: If the response body does not
contain valid json.
"""
if not self.encoding and self.content and len(self.content) > 3:
# No encoding set. JSON RFC 4627 section 3 states we should expect
# UTF-8, -16 or -32. Detect which one to use; If the detection or
# decoding fails, fall back to `self.text` (using charset_normalizer to make
# a best guess).
encoding = guess_json_utf(self.content)
if encoding is not None:
try:
return complexjson.loads(self.content.decode(encoding), **kwargs)
except UnicodeDecodeError:
# Wrong UTF codec detected; usually because it's not UTF-8
# but some other 8-bit codec. This is an RFC violation,
# and the server didn't bother to tell us what codec *was*
# used.
pass
except JSONDecodeError as e:
raise RequestsJSONDecodeError(e.msg, e.doc, e.pos)
try:
return complexjson.loads(self.text, **kwargs)
except JSONDecodeError as e:
# Catch JSON-related errors and raise as requests.JSONDecodeError
# This aliases json.JSONDecodeError and simplejson.JSONDecodeError
raise RequestsJSONDecodeError(e.msg, e.doc, e.pos)
@property
def links(self):
"""Returns the parsed header links of the response, if any."""
header = self.headers.get("link")
resolved_links = {}
if header:
links = parse_header_links(header)
for link in links:
key = link.get("rel") or link.get("url")
resolved_links[key] = link
return resolved_links
def raise_for_status(self):
"""Raises :class:`HTTPError`, if one occurred."""
http_error_msg = ""
if isinstance(self.reason, bytes):
# We attempt to decode utf-8 first because some servers
# choose to localize their reason strings. If the string
# isn't utf-8, we fall back to iso-8859-1 for all other
# encodings. (See PR #3538)
try:
reason = self.reason.decode("utf-8")
except UnicodeDecodeError:
reason = self.reason.decode("iso-8859-1")
else:
reason = self.reason
if 400 <= self.status_code < 500:
http_error_msg = (
f"{self.status_code} Client Error: {reason} for url: {self.url}"
)
elif 500 <= self.status_code < 600:
http_error_msg = (
f"{self.status_code} Server Error: {reason} for url: {self.url}"
)
if http_error_msg:
raise HTTPError(http_error_msg, response=self)
def close(self):
"""Releases the connection back to the pool. Once this method has been
called the underlying ``raw`` object must not be accessed again.
*Note: Should not normally need to be called explicitly.*
"""
if not self._content_consumed:
self.raw.close()
release_conn = getattr(self.raw, "release_conn", None)
if release_conn is not None:
release_conn()
PK ! ~m __version__.pynu [ # .-. .-. .-. . . .-. .-. .-. .-.
# |( |- |.| | | |- `-. | `-.
# ' ' `-' `-`.`-' `-' `-' ' `-'
__title__ = "requests"
__description__ = "Python HTTP for Humans."
__url__ = "https://requests.readthedocs.io"
__version__ = "2.32.5"
__build__ = 0x023205
__author__ = "Kenneth Reitz"
__author_email__ = "me@kennethreitz.org"
__license__ = "Apache-2.0"
__copyright__ = "Copyright Kenneth Reitz"
__cake__ = "\u2728 \U0001f370 \u2728"
PK ! 7=g =g adapters.pynu [ """
requests.adapters
~~~~~~~~~~~~~~~~~
This module contains the transport adapters that Requests uses to define
and maintain connections.
"""
import os.path
import socket # noqa: F401
import typing
import warnings
from pip._vendor.urllib3.exceptions import ClosedPoolError, ConnectTimeoutError
from pip._vendor.urllib3.exceptions import HTTPError as _HTTPError
from pip._vendor.urllib3.exceptions import InvalidHeader as _InvalidHeader
from pip._vendor.urllib3.exceptions import (
LocationValueError,
MaxRetryError,
NewConnectionError,
ProtocolError,
)
from pip._vendor.urllib3.exceptions import ProxyError as _ProxyError
from pip._vendor.urllib3.exceptions import ReadTimeoutError, ResponseError
from pip._vendor.urllib3.exceptions import SSLError as _SSLError
from pip._vendor.urllib3.poolmanager import PoolManager, proxy_from_url
from pip._vendor.urllib3.util import Timeout as TimeoutSauce
from pip._vendor.urllib3.util import parse_url
from pip._vendor.urllib3.util.retry import Retry
from .auth import _basic_auth_str
from .compat import basestring, urlparse
from .cookies import extract_cookies_to_jar
from .exceptions import (
ConnectionError,
ConnectTimeout,
InvalidHeader,
InvalidProxyURL,
InvalidSchema,
InvalidURL,
ProxyError,
ReadTimeout,
RetryError,
SSLError,
)
from .models import Response
from .structures import CaseInsensitiveDict
from .utils import (
DEFAULT_CA_BUNDLE_PATH,
extract_zipped_paths,
get_auth_from_url,
get_encoding_from_headers,
prepend_scheme_if_needed,
select_proxy,
urldefragauth,
)
try:
from pip._vendor.urllib3.contrib.socks import SOCKSProxyManager
except ImportError:
def SOCKSProxyManager(*args, **kwargs):
raise InvalidSchema("Missing dependencies for SOCKS support.")
if typing.TYPE_CHECKING:
from .models import PreparedRequest
DEFAULT_POOLBLOCK = False
DEFAULT_POOLSIZE = 10
DEFAULT_RETRIES = 0
DEFAULT_POOL_TIMEOUT = None
def _urllib3_request_context(
request: "PreparedRequest",
verify: "bool | str | None",
client_cert: "typing.Tuple[str, str] | str | None",
poolmanager: "PoolManager",
) -> "(typing.Dict[str, typing.Any], typing.Dict[str, typing.Any])":
host_params = {}
pool_kwargs = {}
parsed_request_url = urlparse(request.url)
scheme = parsed_request_url.scheme.lower()
port = parsed_request_url.port
cert_reqs = "CERT_REQUIRED"
if verify is False:
cert_reqs = "CERT_NONE"
elif isinstance(verify, str):
if not os.path.isdir(verify):
pool_kwargs["ca_certs"] = verify
else:
pool_kwargs["ca_cert_dir"] = verify
pool_kwargs["cert_reqs"] = cert_reqs
if client_cert is not None:
if isinstance(client_cert, tuple) and len(client_cert) == 2:
pool_kwargs["cert_file"] = client_cert[0]
pool_kwargs["key_file"] = client_cert[1]
else:
# According to our docs, we allow users to specify just the client
# cert path
pool_kwargs["cert_file"] = client_cert
host_params = {
"scheme": scheme,
"host": parsed_request_url.hostname,
"port": port,
}
return host_params, pool_kwargs
class BaseAdapter:
"""The Base Transport Adapter"""
def __init__(self):
super().__init__()
def send(
self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None
):
"""Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest ` being sent.
:param stream: (optional) Whether to stream the request content.
:param timeout: (optional) How long to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) ` tuple.
:type timeout: float or tuple
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
"""
raise NotImplementedError
def close(self):
"""Cleans up adapter specific items."""
raise NotImplementedError
class HTTPAdapter(BaseAdapter):
"""The built-in HTTP Adapter for urllib3.
Provides a general-case interface for Requests sessions to contact HTTP and
HTTPS urls by implementing the Transport Adapter interface. This class will
usually be created by the :class:`Session ` class under the
covers.
:param pool_connections: The number of urllib3 connection pools to cache.
:param pool_maxsize: The maximum number of connections to save in the pool.
:param max_retries: The maximum number of retries each connection
should attempt. Note, this applies only to failed DNS lookups, socket
connections and connection timeouts, never to requests where data has
made it to the server. By default, Requests does not retry failed
connections. If you need granular control over the conditions under
which we retry a request, import urllib3's ``Retry`` class and pass
that instead.
:param pool_block: Whether the connection pool should block for connections.
Usage::
>>> import requests
>>> s = requests.Session()
>>> a = requests.adapters.HTTPAdapter(max_retries=3)
>>> s.mount('http://', a)
"""
__attrs__ = [
"max_retries",
"config",
"_pool_connections",
"_pool_maxsize",
"_pool_block",
]
def __init__(
self,
pool_connections=DEFAULT_POOLSIZE,
pool_maxsize=DEFAULT_POOLSIZE,
max_retries=DEFAULT_RETRIES,
pool_block=DEFAULT_POOLBLOCK,
):
if max_retries == DEFAULT_RETRIES:
self.max_retries = Retry(0, read=False)
else:
self.max_retries = Retry.from_int(max_retries)
self.config = {}
self.proxy_manager = {}
super().__init__()
self._pool_connections = pool_connections
self._pool_maxsize = pool_maxsize
self._pool_block = pool_block
self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block)
def __getstate__(self):
return {attr: getattr(self, attr, None) for attr in self.__attrs__}
def __setstate__(self, state):
# Can't handle by adding 'proxy_manager' to self.__attrs__ because
# self.poolmanager uses a lambda function, which isn't pickleable.
self.proxy_manager = {}
self.config = {}
for attr, value in state.items():
setattr(self, attr, value)
self.init_poolmanager(
self._pool_connections, self._pool_maxsize, block=self._pool_block
)
def init_poolmanager(
self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs
):
"""Initializes a urllib3 PoolManager.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter `.
:param connections: The number of urllib3 connection pools to cache.
:param maxsize: The maximum number of connections to save in the pool.
:param block: Block when no free connections are available.
:param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
"""
# save these values for pickling
self._pool_connections = connections
self._pool_maxsize = maxsize
self._pool_block = block
self.poolmanager = PoolManager(
num_pools=connections,
maxsize=maxsize,
block=block,
**pool_kwargs,
)
def proxy_manager_for(self, proxy, **proxy_kwargs):
"""Return urllib3 ProxyManager for the given proxy.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter `.
:param proxy: The proxy to return a urllib3 ProxyManager for.
:param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
:returns: ProxyManager
:rtype: urllib3.ProxyManager
"""
if proxy in self.proxy_manager:
manager = self.proxy_manager[proxy]
elif proxy.lower().startswith("socks"):
username, password = get_auth_from_url(proxy)
manager = self.proxy_manager[proxy] = SOCKSProxyManager(
proxy,
username=username,
password=password,
num_pools=self._pool_connections,
maxsize=self._pool_maxsize,
block=self._pool_block,
**proxy_kwargs,
)
else:
proxy_headers = self.proxy_headers(proxy)
manager = self.proxy_manager[proxy] = proxy_from_url(
proxy,
proxy_headers=proxy_headers,
num_pools=self._pool_connections,
maxsize=self._pool_maxsize,
block=self._pool_block,
**proxy_kwargs,
)
return manager
def cert_verify(self, conn, url, verify, cert):
"""Verify a SSL certificate. This method should not be called from user
code, and is only exposed for use when subclassing the
:class:`HTTPAdapter `.
:param conn: The urllib3 connection object associated with the cert.
:param url: The requested URL.
:param verify: Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use
:param cert: The SSL certificate to verify.
"""
if url.lower().startswith("https") and verify:
cert_loc = None
# Allow self-specified cert location.
if verify is not True:
cert_loc = verify
if not cert_loc:
cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
if not cert_loc or not os.path.exists(cert_loc):
raise OSError(
f"Could not find a suitable TLS CA certificate bundle, "
f"invalid path: {cert_loc}"
)
conn.cert_reqs = "CERT_REQUIRED"
if not os.path.isdir(cert_loc):
conn.ca_certs = cert_loc
else:
conn.ca_cert_dir = cert_loc
else:
conn.cert_reqs = "CERT_NONE"
conn.ca_certs = None
conn.ca_cert_dir = None
if cert:
if not isinstance(cert, basestring):
conn.cert_file = cert[0]
conn.key_file = cert[1]
else:
conn.cert_file = cert
conn.key_file = None
if conn.cert_file and not os.path.exists(conn.cert_file):
raise OSError(
f"Could not find the TLS certificate file, "
f"invalid path: {conn.cert_file}"
)
if conn.key_file and not os.path.exists(conn.key_file):
raise OSError(
f"Could not find the TLS key file, invalid path: {conn.key_file}"
)
def build_response(self, req, resp):
"""Builds a :class:`Response ` object from a urllib3
response. This should not be called from user code, and is only exposed
for use when subclassing the
:class:`HTTPAdapter `
:param req: The :class:`PreparedRequest ` used to generate the response.
:param resp: The urllib3 response object.
:rtype: requests.Response
"""
response = Response()
# Fallback to None if there's no status_code, for whatever reason.
response.status_code = getattr(resp, "status", None)
# Make headers case-insensitive.
response.headers = CaseInsensitiveDict(getattr(resp, "headers", {}))
# Set encoding.
response.encoding = get_encoding_from_headers(response.headers)
response.raw = resp
response.reason = response.raw.reason
if isinstance(req.url, bytes):
response.url = req.url.decode("utf-8")
else:
response.url = req.url
# Add new cookies from the server.
extract_cookies_to_jar(response.cookies, req, resp)
# Give the Response some context.
response.request = req
response.connection = self
return response
def build_connection_pool_key_attributes(self, request, verify, cert=None):
"""Build the PoolKey attributes used by urllib3 to return a connection.
This looks at the PreparedRequest, the user-specified verify value,
and the value of the cert parameter to determine what PoolKey values
to use to select a connection from a given urllib3 Connection Pool.
The SSL related pool key arguments are not consistently set. As of
this writing, use the following to determine what keys may be in that
dictionary:
* If ``verify`` is ``True``, ``"ssl_context"`` will be set and will be the
default Requests SSL Context
* If ``verify`` is ``False``, ``"ssl_context"`` will not be set but
``"cert_reqs"`` will be set
* If ``verify`` is a string, (i.e., it is a user-specified trust bundle)
``"ca_certs"`` will be set if the string is not a directory recognized
by :py:func:`os.path.isdir`, otherwise ``"ca_cert_dir"`` will be
set.
* If ``"cert"`` is specified, ``"cert_file"`` will always be set. If
``"cert"`` is a tuple with a second item, ``"key_file"`` will also
be present
To override these settings, one may subclass this class, call this
method and use the above logic to change parameters as desired. For
example, if one wishes to use a custom :py:class:`ssl.SSLContext` one
must both set ``"ssl_context"`` and based on what else they require,
alter the other keys to ensure the desired behaviour.
:param request:
The PreparedReqest being sent over the connection.
:type request:
:class:`~requests.models.PreparedRequest`
:param verify:
Either a boolean, in which case it controls whether
we verify the server's TLS certificate, or a string, in which case it
must be a path to a CA bundle to use.
:param cert:
(optional) Any user-provided SSL certificate for client
authentication (a.k.a., mTLS). This may be a string (i.e., just
the path to a file which holds both certificate and key) or a
tuple of length 2 with the certificate file path and key file
path.
:returns:
A tuple of two dictionaries. The first is the "host parameters"
portion of the Pool Key including scheme, hostname, and port. The
second is a dictionary of SSLContext related parameters.
"""
return _urllib3_request_context(request, verify, cert, self.poolmanager)
def get_connection_with_tls_context(self, request, verify, proxies=None, cert=None):
"""Returns a urllib3 connection for the given request and TLS settings.
This should not be called from user code, and is only exposed for use
when subclassing the :class:`HTTPAdapter `.
:param request:
The :class:`PreparedRequest ` object to be sent
over the connection.
:param verify:
Either a boolean, in which case it controls whether we verify the
server's TLS certificate, or a string, in which case it must be a
path to a CA bundle to use.
:param proxies:
(optional) The proxies dictionary to apply to the request.
:param cert:
(optional) Any user-provided SSL certificate to be used for client
authentication (a.k.a., mTLS).
:rtype:
urllib3.ConnectionPool
"""
proxy = select_proxy(request.url, proxies)
try:
host_params, pool_kwargs = self.build_connection_pool_key_attributes(
request,
verify,
cert,
)
except ValueError as e:
raise InvalidURL(e, request=request)
if proxy:
proxy = prepend_scheme_if_needed(proxy, "http")
proxy_url = parse_url(proxy)
if not proxy_url.host:
raise InvalidProxyURL(
"Please check proxy URL. It is malformed "
"and could be missing the host."
)
proxy_manager = self.proxy_manager_for(proxy)
conn = proxy_manager.connection_from_host(
**host_params, pool_kwargs=pool_kwargs
)
else:
# Only scheme should be lower case
conn = self.poolmanager.connection_from_host(
**host_params, pool_kwargs=pool_kwargs
)
return conn
def get_connection(self, url, proxies=None):
"""DEPRECATED: Users should move to `get_connection_with_tls_context`
for all subclasses of HTTPAdapter using Requests>=2.32.2.
Returns a urllib3 connection for the given URL. This should not be
called from user code, and is only exposed for use when subclassing the
:class:`HTTPAdapter `.
:param url: The URL to connect to.
:param proxies: (optional) A Requests-style dictionary of proxies used on this request.
:rtype: urllib3.ConnectionPool
"""
warnings.warn(
(
"`get_connection` has been deprecated in favor of "
"`get_connection_with_tls_context`. Custom HTTPAdapter subclasses "
"will need to migrate for Requests>=2.32.2. Please see "
"https://github.com/psf/requests/pull/6710 for more details."
),
DeprecationWarning,
)
proxy = select_proxy(url, proxies)
if proxy:
proxy = prepend_scheme_if_needed(proxy, "http")
proxy_url = parse_url(proxy)
if not proxy_url.host:
raise InvalidProxyURL(
"Please check proxy URL. It is malformed "
"and could be missing the host."
)
proxy_manager = self.proxy_manager_for(proxy)
conn = proxy_manager.connection_from_url(url)
else:
# Only scheme should be lower case
parsed = urlparse(url)
url = parsed.geturl()
conn = self.poolmanager.connection_from_url(url)
return conn
def close(self):
"""Disposes of any internal state.
Currently, this closes the PoolManager and any active ProxyManager,
which closes any pooled connections.
"""
self.poolmanager.clear()
for proxy in self.proxy_manager.values():
proxy.clear()
def request_url(self, request, proxies):
"""Obtain the url to use when making the final request.
If the message is being sent through a HTTP proxy, the full URL has to
be used. Otherwise, we should only use the path portion of the URL.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter `.
:param request: The :class:`PreparedRequest ` being sent.
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
:rtype: str
"""
proxy = select_proxy(request.url, proxies)
scheme = urlparse(request.url).scheme
is_proxied_http_request = proxy and scheme != "https"
using_socks_proxy = False
if proxy:
proxy_scheme = urlparse(proxy).scheme.lower()
using_socks_proxy = proxy_scheme.startswith("socks")
url = request.path_url
if url.startswith("//"): # Don't confuse urllib3
url = f"/{url.lstrip('/')}"
if is_proxied_http_request and not using_socks_proxy:
url = urldefragauth(request.url)
return url
def add_headers(self, request, **kwargs):
"""Add any headers needed by the connection. As of v2.0 this does
nothing by default, but is left for overriding by users that subclass
the :class:`HTTPAdapter `.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter `.
:param request: The :class:`PreparedRequest ` to add headers to.
:param kwargs: The keyword arguments from the call to send().
"""
pass
def proxy_headers(self, proxy):
"""Returns a dictionary of the headers to add to any request sent
through a proxy. This works with urllib3 magic to ensure that they are
correctly sent to the proxy, rather than in a tunnelled request if
CONNECT is being used.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter `.
:param proxy: The url of the proxy being used for this request.
:rtype: dict
"""
headers = {}
username, password = get_auth_from_url(proxy)
if username:
headers["Proxy-Authorization"] = _basic_auth_str(username, password)
return headers
def send(
self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None
):
"""Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest ` being sent.
:param stream: (optional) Whether to stream the request content.
:param timeout: (optional) How long to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) ` tuple.
:type timeout: float or tuple or urllib3 Timeout object
:param verify: (optional) Either a boolean, in which case it controls whether
we verify the server's TLS certificate, or a string, in which case it
must be a path to a CA bundle to use
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
:rtype: requests.Response
"""
try:
conn = self.get_connection_with_tls_context(
request, verify, proxies=proxies, cert=cert
)
except LocationValueError as e:
raise InvalidURL(e, request=request)
self.cert_verify(conn, request.url, verify, cert)
url = self.request_url(request, proxies)
self.add_headers(
request,
stream=stream,
timeout=timeout,
verify=verify,
cert=cert,
proxies=proxies,
)
chunked = not (request.body is None or "Content-Length" in request.headers)
if isinstance(timeout, tuple):
try:
connect, read = timeout
timeout = TimeoutSauce(connect=connect, read=read)
except ValueError:
raise ValueError(
f"Invalid timeout {timeout}. Pass a (connect, read) timeout tuple, "
f"or a single float to set both timeouts to the same value."
)
elif isinstance(timeout, TimeoutSauce):
pass
else:
timeout = TimeoutSauce(connect=timeout, read=timeout)
try:
resp = conn.urlopen(
method=request.method,
url=url,
body=request.body,
headers=request.headers,
redirect=False,
assert_same_host=False,
preload_content=False,
decode_content=False,
retries=self.max_retries,
timeout=timeout,
chunked=chunked,
)
except (ProtocolError, OSError) as err:
raise ConnectionError(err, request=request)
except MaxRetryError as e:
if isinstance(e.reason, ConnectTimeoutError):
# TODO: Remove this in 3.0.0: see #2811
if not isinstance(e.reason, NewConnectionError):
raise ConnectTimeout(e, request=request)
if isinstance(e.reason, ResponseError):
raise RetryError(e, request=request)
if isinstance(e.reason, _ProxyError):
raise ProxyError(e, request=request)
if isinstance(e.reason, _SSLError):
# This branch is for urllib3 v1.22 and later.
raise SSLError(e, request=request)
raise ConnectionError(e, request=request)
except ClosedPoolError as e:
raise ConnectionError(e, request=request)
except _ProxyError as e:
raise ProxyError(e)
except (_SSLError, _HTTPError) as e:
if isinstance(e, _SSLError):
# This branch is for urllib3 versions earlier than v1.22
raise SSLError(e, request=request)
elif isinstance(e, ReadTimeoutError):
raise ReadTimeout(e, request=request)
elif isinstance(e, _InvalidHeader):
raise InvalidHeader(e, request=request)
else:
raise
return self.build_response(request, resp)
PK ! :Q ( __pycache__/status_codes.cpython-312.pycnu [
9r*j U d a ddlmZ i ddddddd d
d d d
ddddddddddddddd d d d d d!d"d#d$i d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFi dGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhi didjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~ddddddddddddZ ed Zee ed< d Z e y)a
The ``codes`` object defines a mapping from common names for HTTP statuses
to their numerical codes, accessible either as attributes or as dictionary
items.
Example::
>>> import requests
>>> requests.codes['temporary_redirect']
307
>>> requests.codes.teapot
418
>>> requests.codes['\o/']
200
Some codes have multiple names, and both upper- and lower-case versions of
the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
``codes.okay`` all correspond to the HTTP status code 200.
)
LookupDictd )continuee )switching_protocolsf )
processingz early-hintsg )
checkpointz ) uri_too_longrequest_uri_too_long )okokayall_okall_okayall_goodz\o/u ✓ )created )accepted )non_authoritative_info non_authoritative_information )
no_content )
reset_contentreset )partial_contentpartial ) multi_statusmultiple_status multi_statimultiple_stati )already_reported )im_usedi, )multiple_choicesi- )moved_permanentlymovedz\o-i. )foundi/ ) see_otherotheri0 ) not_modifiedi1 ) use_proxyi2 ) switch_proxyi3 )temporary_redirecttemporary_moved temporaryi4 )permanent_redirectresume_incompleteresumei ) bad_requestbadi ) unauthorizedi )payment_requiredpaymenti ) forbiddeni ) not_foundz-o-i )method_not_allowed not_allowedi )not_acceptablei ) proxy_authentication_required
proxy_authproxy_authenticationi )request_timeouttimeouti )conflicti )gonei )length_requiredi )precondition_failed preconditioni )request_entity_too_largecontent_too_largei )request_uri_too_larger
i )unsupported_media_typeunsupported_media
media_typei ) requested_range_not_satisfiablerequested_rangerange_not_satisfiablei )expectation_failedi ) im_a_teapotteapot
i_am_a_teapoti )misdirected_requesti )unprocessable_entity
unprocessableunprocessable_contenti )lockedi )failed_dependency
dependencyi )unordered_collection unordered too_earlyi )upgrade_requiredupgradei )precondition_requiredrO i )too_many_requeststoo_manyi )header_fields_too_largefields_too_largei ) no_responsenonei )
retry_withretryi )$blocked_by_windows_parental_controlsparental_controlsi ) unavailable_for_legal_reasons
legal_reasonsi )client_closed_requesti )internal_server_error server_errorz/o\u ✗i )not_implementedi ) bad_gatewayi )service_unavailable unavailablei )gateway_timeouti )http_version_not_supported http_versioni )variant_also_negotiatesi )insufficient_storagei )bandwidth_limit_exceeded bandwidthi ) not_extendedi ) network_authentication_required network_authnetwork_authentication status_codes)namecodesc d t j D ]N \ } }|D ]D }t t || |j d r&t t |j | F P dt dt fdt 2t dz dj fdt t D z ay d ay )N)\/codereturnc N dj d t | D }d| |fz S )Nz, c 3 ( K | ]
}d | d yw)z``N ).0ns D/opt/hc_python/lib/python3.12/site-packages/requests/status_codes.py z%_init..doc..u s ;lBqc*ls z* %d: %s)join_codes)r namess r docz_init..doct s) ;fTl;;T5M))
c 3 . K | ] } | y w)Nr )r r r s r r z_init..z s "H 3t9 s ) r itemssetattrr
startswithupperintstr__doc__r sorted)r titlestitler s @r _initr m s fE E5$ '##K0u{{}d3 ' *# *# * $"H "HHH r N)r
structuresr r r r __annotations__r r r r r s? ( #Q
Q
!Q
& Q
Q
1
Q
HQ
Q
Q
DQ
Q
#Q
'Q
M Q
Q
!Q
$ %Q
& /'Q
( )Q
* +Q
, -Q
. /Q
0 1Q
2 ?3Q
4
5Q
@ AQ
B CQ
D (EQ
F GQ
H IQ
J .KQ
L MQ
N POQ
P 'QQ
R SQ
T UQ
V WQ
X 0YQ
Z :[Q
\ 2]Q
^ F_Q
`
aQ
j kQ
l 3mQ
n !oQ
p KqQ
r sQ
t ,uQ
v ;wQ
x (yQ
z 2{Q
| *}Q
~ 8Q
@ AQ
B CQ
D FEQ
F ;GQ
H #IQ
L AMQ
N OQ
P QQ
R /SQ
T UQ
V 7WQ
X %YQ
Z "[Q
\ 2]Q
^ _Q
` VaQ
f $ 8z# 8& r PK ! K ! __pycache__/hooks.cpython-312.pycnu [
9r*jr U d Z ddlmZ ddlmZmZ ddlmZmZ er ddl m
Z ddl m
Z
dgZd ed
< dd Z dd Zy
)z
requests.hooks
~~~~~~~~~~~~~~
This module provides the capabilities for the Requests hooks system.
Available hooks:
``response``:
The response generated from a Request.
) annotations)CallableIterable)
TYPE_CHECKINGAny )_types)Responseresponsez list[str]HOOKSc 6 t D ci c] } | g c} S c c} w )N)r )events =/opt/hc_python/lib/python3.12/site-packages/requests/hooks.py
default_hooksr s #( )5%E2I5 )) )s
c |xs i }|j | }|r(t |t r|g}|D ] } ||fi |}||} |S )z6Dispatches a hook dictionary on a given piece of data.)get
isinstancer )keyhooks hook_datakwargs
hooks_dict hook_listhook
_hook_datas r
dispatch_hookr s[ "Jr) sb
# . % <y * #
r PK ! ^*P P __pycache__/api.cpython-312.pycnu [
9r*j d Z ddlmZ ddlmZ ddlmZ ddlmZ er ddl m
Z
ddlm Z dd Z
d dd Zdd Zdd
Z d ddZ d ddZ d ddZddZy
)z
requests.api
~~~~~~~~~~~~
This module implements the Requests API.
:copyright: (c) 2012 by Kenneth Reitz.
:license: Apache2, see LICENSE for more details.
) annotations)
TYPE_CHECKING )sessions)Response)Unpack)_typesc t j 5 } |j d| |d|cddd S # 1 sw Y yxY w)a Constructs and sends a :class:`Request `.
:param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the query string for the :class:`Request`.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
:param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
:param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content_type'`` is a string
defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
to add for the file.
:param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds to wait for the server to send data
before giving up, as a float, or a :ref:`(connect timeout, read
timeout) ` tuple.
:type timeout: float or tuple
:param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use. Defaults to ``True``.
:param stream: (optional) if ``False``, the response content will be immediately downloaded.
:param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
:return: :class:`Response ` object
:rtype: requests.Response
Usage::
>>> import requests
>>> req = requests.request('GET', 'https://httpbin.org/get')
>>> req
)methodurlN )r Sessionrequest)r r kwargssessions ;/opt/hc_python/lib/python3.12/site-packages/requests/api.pyr r s7 \
w w@f#@@
s 4=Nc t d| fd|i|S )ad Sends a GET request.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the query string for the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
getparamsr )r r r s r r r J s 5# 7f 7 77 c t d| fi |S )zSends an OPTIONS request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
optionsr r r s r r r Z s 9c ,V ,,r c @ |j dd t d| fi |S )ak Sends a HEAD request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes. If
`allow_redirects` is not provided, it will be set to `False` (as
opposed to the default :meth:`request` behavior).
:return: :class:`Response ` object
:rtype: requests.Response
allow_redirectsFhead)
setdefaultr r s r r r f s' '/ 63 )& ))r c " t d| f||d|S )a Sends a POST request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
post)datajsonr )r r! r" r s r r r u s " 63 ?T ? ??r c t d| fd|i|S )a Sends a PUT request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
putr! r r r! r s r r$ r$ s 5# 3D 3F 33r c t d| fd|i|S )a Sends a PATCH request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
patchr! r r% s r r' r' s 7C 5d 5f 55r c t d| fi |S )zSends a DELETE request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
deleter r s r r) r) s 8S +F ++r )r strr
_t.UriTyper Unpack[_t.RequestKwargs]returnr )N)r r+ r z
_t.ParamsTyper zUnpack[_t.GetKwargs]r- r )r r+ r r, r- r )NN)
r r+ r! _t.DataTyper" z _t.JsonTyper zUnpack[_t.PostKwargs]r- r )r r+ r! r. r zUnpack[_t.DataKwargs]r- r )__doc__
__future__r typingr r modelsr typing_extensionsr r _tr r r r r r$ r' r) r
r r r6 s # ( /A /A /A,D/A
/Af .2
8
8 *
8=Q
8
8 - *" @ @
@ @ $ @
@* *.4 4&49N4
4$ *.6 6&69N6
6" ,r PK ! ZИs s $ __pycache__/adapters.cpython-312.pycnu [
9r*jm 2 d Z ddlmZ ddlZddlZddlZddlZddlmZ ddl m
Z
m Z m Z m
Z
mZmZmZmZ ddl mZ ddl mZ ddl mZ dd l mZ dd
lmZm Z dd l m Z dd l m Z dd
l!m"Z" ddl#m$Z$ ddl%m&Z&m'Z' ddl(m)Z) ddl*m+Z+m,Z,mZm-Z-m.Z.m/Z/mZm0Z0m1Z1mZ ddl2m3Z3 ddl4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z:m;Z;mZ> ej rddlAmBZB ddlmZC ddlDmEZF ddl2mGZG dd lEmHZI d ZJd ZKdZLdZM d%d ZN G d d! ZO G d" d#eO ZPy# e?$ r d$dZ>Y aw xY w)&z
requests.adapters
~~~~~~~~~~~~~~~~~
This module contains the transport adapters that Requests uses to define
and maintain connections.
) annotationsN)Any)ClosedPoolErrorConnectTimeoutErrorLocationValueError
MaxRetryErrorNewConnectionError
ProtocolErrorReadTimeoutError
ResponseError) HTTPError)
InvalidHeader)
ProxyError)SSLError) PoolManagerproxy_from_url)Timeout) parse_url)Retry )_basic_auth_str)
basestringurlparse)extract_cookies_to_jar)
ConnectionErrorConnectTimeoutr InvalidProxyURL
InvalidSchema
InvalidURLr ReadTimeout
RetryErrorr )Response)CaseInsensitiveDict)DEFAULT_CA_BUNDLE_PATHget_auth_from_urlget_encoding_from_headersprepend_scheme_if_needed select_proxy
urldefragauth)SOCKSProxyManagerc t d )Nz'Missing dependencies for SOCKS support.)r )argskwargss @/opt/hc_python/lib/python3.12/site-packages/requests/adapters.pyr* r* B s EFF )HTTPConnectionPool)r )_types)PreparedRequest) is_preparedF
c i }i }t | j }|j j }|j }d} |du rd} n:t |t r*t j j | s||d< n||d< | |d< |4t |t r t | dk( r|d |d < |d
|d < n||d < ||j |d }||fS )
N
CERT_REQUIREDF CERT_NONEca_certs ca_cert_dir cert_reqs r cert_filer key_file)schemehostport)
r urlr> lowerr@
isinstancestrospathisdirtuplelenhostname)
requestverify client_cert poolmanager host_params pool_kwargsparsed_request_urlr> r@ r: s
r. _urllib3_request_contextrR U s #%K"$K!'++.
&
&
,
,
.F " "D I
FC ww}}V$&,K
#)/K
& (K k5 )c+.>!.C'21~K $&1!nK
# (3K $"++K
##r/ c Z e Zd ZdZd fd Z d ddZddZ xZS ) BaseAdapterzThe Base Transport Adapterc " t | y N)super__init__)self __class__s r. rX zBaseAdapter.__init__} s
r/ c t )aC Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest ` being sent.
:param stream: (optional) Whether to stream the request content.
:param timeout: (optional) How long to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) ` tuple.
:type timeout: float or tuple
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
NotImplementedError)rY rK streamtimeoutrL certproxiess r. sendzBaseAdapter.send s
. "!r/ c t )z!Cleans up adapter specific items.r\ )rY s r. closezBaseAdapter.close s !!r/ returnNoneFNTNNrK r2 r^ boolr_ z_t.TimeoutTyperL
_t.VerifyTyper` _t.CertTypera dict[str, str] | Nonerf r" )__name__
__module__ __qualname____doc__rX rb rd
__classcell__rZ s @r. rT rT z sj $ "& $ )-" " " "
"
" '"
"2"r/ rT c e Zd ZU dZg dZded< ded< ded< ded < d
ed < d
ed < d
ed< ded< eeeef d fd
Z d!dZ
d"dZ ef d#dZ d$dZ
d%dZd&dZ d' d(dZ d) d*dZ d' d+dZd,dZ d-d Zd.d Zd/d Z d0 d1d Z xZS )2 HTTPAdaptera The built-in HTTP Adapter for urllib3.
Provides a general-case interface for Requests sessions to contact HTTP and
HTTPS urls by implementing the Transport Adapter interface. This class will
usually be created by the :class:`Session ` class under the
covers.
:param pool_connections: The number of urllib3 connection pools to cache.
:param pool_maxsize: The maximum number of connections to save in the pool.
:param max_retries: The maximum number of retries each connection
should attempt. Note, this applies only to failed DNS lookups, socket
connections and connection timeouts, never to requests where data has
made it to the server. By default, Requests does not retry failed
connections. If you need granular control over the conditions under
which we retry a request, import urllib3's ``Retry`` class and pass
that instead.
:param pool_block: Whether the connection pool should block for connections.
Usage::
>>> import requests
>>> s = requests.Session()
>>> a = requests.adapters.HTTPAdapter(max_retries=3)
>>> s.mount('http://', a)
) max_retriesconfig_pool_connections
_pool_maxsize _pool_blockz list[str] __attrs__r rv dict[str, Any]rw
proxy_managerintrx ry rj rz _PoolManagerrN c |t k( rt dd | _ nt j | | _ i | _ i | _ t | || _ || _ || _
| j ||| y )Nr F)readblock) DEFAULT_RETRIESr rv from_intrw r} rW rX rx ry rz init_poolmanager)rY pool_connections pool_maxsizerv
pool_blockrZ s r. rX zHTTPAdapter.__init__ su / ) $QU 3D $~~k :D
!1 )% . J Or/ c X | j D ci c] }|t | |d c}S c c}w rV )r{ getattr)rY attrs r. __getstate__zHTTPAdapter.__getstate__ s, <@NNKNDgdD$//NKKKs 'c i | _ i | _ |j D ] \ }}t | || | j | j
| j | j y )Nr )r} rw itemssetattrr rx ry rz )rY stater values r. __setstate__zHTTPAdapter.__setstate__ sa ;;=KD% D$ & )
" "D$6$6d>N>N
r/ c V || _ || _ || _ t d|||d|| _ y)a Initializes a urllib3 PoolManager.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter `.
:param connections: The number of urllib3 connection pools to cache.
:param maxsize: The maximum number of connections to save in the pool.
:param block: Block when no free connections are available.
:param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager.
) num_poolsmaxsizer N )rx ry rz r rN )rY connectionsr r rP s r. r z HTTPAdapter.init_poolmanager sA & "- $ &
!
r/ c || j v r| j | }|S |j j d rOt | \ }}t |f||| j
| j | j d|x}| j |< |S | j | }t |f|| j
| j | j d|x}| j |< |S )a Return urllib3 ProxyManager for the given proxy.
This method should not be called from user code, and is only
exposed for use when subclassing the
:class:`HTTPAdapter `.
:param proxy: The proxy to return a urllib3 ProxyManager for.
:param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager.
:returns: ProxyManager
:rtype: urllib3.ProxyManager
socks)usernamepasswordr r r )
proxy_headersr r r )
r} rB
startswithr% r* rx ry rz r r )rY proxy proxy_kwargsmanagerr r r s r. proxy_manager_forz HTTPAdapter.proxy_manager_for
s D&& &((/G. - [[]
%
%g
.!25!9 Hh2C3!! 00 **&&
3 3
Gd((/( ! . .u 5M2@3 + 00 **&& 3
3
Gd((/ r/ c |j j d rw|rud}|dur|}|st }|r t j j | st
d| d|_ t j j | s||_ n ||_
nd|_ d|_ d|_
|rt |t s|d |_
|d |_ n||_
d|_ |j rAt j j |j st
d |j |j rBt j j |j st
d
|j yyy) aA Verify a SSL certificate. This method should not be called from user
code, and is only exposed for use when subclassing the
:class:`HTTPAdapter `.
:param conn: The urllib3 connection object associated with the cert.
:param url: The requested URL.
:param verify: Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use
:param cert: The SSL certificate to verify.
httpsNTzCCould not find a suitable TLS CA certificate bundle, invalid path: r6 r7 r r z7Could not find the TLS certificate file, invalid path: z/Could not find the TLS key file, invalid path: )rB r r$ rE rF existsOSErrorr: rG r8 r9 rC r r< r= )rY connrA rL r` cert_locs r. cert_verifyzHTTPAdapter.cert_verify3 sR 99; ! !' *vH T!!1277>>(#; %%-J0
-DN77==* (
#+ (DN DM #D dJ/!%a $Q
!% $
~~bggnnT^^&D %%)^^$46 }}RWW^^DMM%B Edmm_U &C} r/ c t | sJ t }t |dd |_ t t |di |_ t
|j
|_ ||_ |j j |_ t |j t r!|j j d |_ n|j |_ t |j || ||_ | |_ |S )a Builds a :class:`Response ` object from a urllib3
response. This should not be called from user code, and is only exposed
for use when subclassing the
:class:`HTTPAdapter `
:param req: The :class:`PreparedRequest ` used to generate the response.
:param resp: The urllib3 response object.
:rtype: requests.Response
statusNheaderszutf-8) _is_preparedr" r status_coder# r r& encodingrawreasonrC rA bytesdecoder cookiesrK
connection)rY reqrespresponses r. build_responsezHTTPAdapter.build_responsem s C : 'tXt < /wtY/KL 6h6F6F G ",,-- cggu % 77>>'2HL 77HL x / /d; "r/ c 2 t |||| j S )a Build the PoolKey attributes used by urllib3 to return a connection.
This looks at the PreparedRequest, the user-specified verify value,
and the value of the cert parameter to determine what PoolKey values
to use to select a connection from a given urllib3 Connection Pool.
The SSL related pool key arguments are not consistently set. As of
this writing, use the following to determine what keys may be in that
dictionary:
* If ``verify`` is ``True``, ``"ssl_context"`` will be set and will be the
default Requests SSL Context
* If ``verify`` is ``False``, ``"ssl_context"`` will not be set but
``"cert_reqs"`` will be set
* If ``verify`` is a string, (i.e., it is a user-specified trust bundle)
``"ca_certs"`` will be set if the string is not a directory recognized
by :py:func:`os.path.isdir`, otherwise ``"ca_cert_dir"`` will be
set.
* If ``"cert"`` is specified, ``"cert_file"`` will always be set. If
``"cert"`` is a tuple with a second item, ``"key_file"`` will also
be present
To override these settings, one may subclass this class, call this
method and use the above logic to change parameters as desired. For
example, if one wishes to use a custom :py:class:`ssl.SSLContext` one
must both set ``"ssl_context"`` and based on what else they require,
alter the other keys to ensure the desired behaviour.
:param request:
The PreparedRequest being sent over the connection.
:type request:
:class:`~requests.models.PreparedRequest`
:param verify:
Either a boolean, in which case it controls whether
we verify the server's TLS certificate, or a string, in which case it
must be a path to a CA bundle to use.
:param cert:
(optional) Any user-provided SSL certificate for client
authentication (a.k.a., mTLS). This may be a string (i.e., just
the path to a file which holds both certificate and key) or a
tuple of length 2 with the certificate file path and key file
path.
:returns:
A tuple of two dictionaries. The first is the "host parameters"
portion of the Pool Key including scheme, hostname, and port. The
second is a dictionary of SSLContext related parameters.
)rR rN )rY rK rL r` s r. $build_connection_pool_key_attributesz0HTTPAdapter.build_connection_pool_key_attributes s d (t?O?OPPr/ c t | sJ t |j | } | j ||| \ }}|rWt
|d }t | } | j s t d | j | }
|
j di |d|i} | S | j j di |d|i} | S # t $ r}t || d}~ww xY w)au Returns a urllib3 connection for the given request and TLS settings.
This should not be called from user code, and is only exposed for use
when subclassing the :class:`HTTPAdapter `.
:param request:
The :class:`PreparedRequest ` object to be sent
over the connection.
:param verify:
Either a boolean, in which case it controls whether we verify the
server's TLS certificate, or a string, in which case it must be a
path to a CA bundle to use.
:param proxies:
(optional) The proxies dictionary to apply to the request.
:param cert:
(optional) Any user-provided SSL certificate to be used for client
authentication (a.k.a., mTLS).
:rtype:
urllib3.HTTPConnectionPool
rK NhttpFPlease check proxy URL. It is malformed and could be missing the host.rP r )
r r( rA r
ValueErrorr r' r r? r r connection_from_hostrN ) rY rK rL ra r` r rO rP e proxy_urlr} r s r. get_connection_with_tls_contextz+HTTPAdapter.get_connection_with_tls_context s 4 G$$$ W[['2 1'+'P'P( $K ,UF;E!%(I >>%5 ! 2 25 9M5=55 +6D 94##88 +6D ) 1 Q0 0 1s B6 6 C?
C Cc f t j dt t || }|rRt |d }t | }|j s t d | j | }|j | }|S t | }|j }| j j | }|S )a DEPRECATED: Users should move to `get_connection_with_tls_context`
for all subclasses of HTTPAdapter using Requests>=2.32.2.
Returns a urllib3 connection for the given URL. This should not be
called from user code, and is only exposed for use when subclassing the
:class:`HTTPAdapter `.
:param url: The URL to connect to.
:param proxies: (optional) A Requests-style dictionary of proxies used on this request.
:rtype: urllib3.HTTPConnectionPool
z`get_connection` has been deprecated in favor of `get_connection_with_tls_context`. Custom HTTPAdapter subclasses will need to migrate for Requests>=2.32.2. Please see https://github.com/psf/requests/pull/6710 for more details.r r )
warningswarnDeprecationWarningr( r' r r? r r connection_from_urlr geturlrN )rY rA ra r r r} r parseds r. get_connectionzHTTPAdapter.get_connection s
N
S'* ,UF;E!%(I >>%5 ! 2 25 9M 44S9D c]F--/C##77`.
:param request: The :class:`PreparedRequest ` being sent.
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs.
:rtype: str
r Fr ) r r( rA r r> rB r path_urlr) ) rY rK ra r r> is_proxied_http_requestusing_socks_proxy proxy_schemerA s r. request_urlzHTTPAdapter.request_url5 s G$$$ W[['2'++&--"'"=Fg,= ! #E?11779L , 7 7 @ "+< ,C
r/ c y)a" Add any headers needed by the connection. As of v2.0 this does
nothing by default, but is left for overriding by users that subclass
the :class:`HTTPAdapter `.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter `.
:param request: The :class:`PreparedRequest ` to add headers to.
:param kwargs: The keyword arguments from the call to send().
Nr )rY rK r- s r. add_headerszHTTPAdapter.add_headersW s
r/ c H i }t | \ }}|rt || |d< |S )a Returns a dictionary of the headers to add to any request sent
through a proxy. This works with urllib3 magic to ensure that they are
correctly sent to the proxy, rather than in a tunnelled request if
CONNECT is being used.
This should not be called from user code, and is only exposed for use
when subclassing the
:class:`HTTPAdapter `.
:param proxy: The url of the proxy being used for this request.
:rtype: dict
zProxy-Authorization)r% r )rY r r r r s r. r zHTTPAdapter.proxy_headerse s2 #% .u 5( - $ r}t' || d}~wt6 $ r}t9 | d}~wt: t@ f$ r]}t |t: r
t= || t |tB r
tE || t |tF r
tI || d}~ww xY w) a Sends PreparedRequest object. Returns Response object.
:param request: The :class:`PreparedRequest ` being sent.
:param stream: (optional) Whether to stream the request content.
:param timeout: (optional) How long to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) ` tuple.
:type timeout: float or tuple or urllib3 Timeout object
:param verify: (optional) Either a boolean, in which case it controls whether
we verify the server's TLS certificate, or a string, in which case it
must be a path to a CA bundle to use
:param cert: (optional) Any user-provided SSL certificate to be trusted.
:param proxies: (optional) The proxies dictionary to apply to the request.
:rtype: requests.Response
)ra r` r N)r^ r_ rL r` ra zContent-Length)connectr zInvalid timeout za. Pass a (connect, read) timeout tuple, or a single float to set both timeouts to the same value.F) methodrA bodyr redirectassert_same_hostpreload_contentdecode_contentretriesr_ chunked)&r r r r r rA r r r r rC rH TimeoutSaucer urlopenr rv r
r r r r r r r r r! _ProxyErrorr _SSLErrorr r
_HTTPErrorr r _InvalidHeaderr r )rY rK r^ r_ rL r` ra r r rA r r r resolved_timeoutr errs r. rb zHTTPAdapter.sendz s 2 G$$$ 177t 8 D
w{{FD9 w0
||t+R/?7??/RS gu %
'
#/d#K
. & +G' J 3 << ~~ \\ !& % $ ((( Dh ""7D11g " 1 Q0 0 1(
&wi 0P Q
2 w' 8!#w7 7 6!(($78!!((,>?(G<<!((M2 G44!((K0 G44!((I. q'22!!W5 5 6!!W5 5 Q- :& !Y' q'22A /0!!W55A~.#Aw77 sn D% E AE % E .
D;;E E K).
E;; K)CI
K)
I## K)/ I::K) AK$$K))
r r~ r r~ rv z int | Retryr rj rf rg )rf r| )r r| rf rg )
r r~ r r~ r rj rP r rf rg )r rD r r rf r )
r r rA rD rL rk r` rl rf rg )r r2 r r rf r" rV )rK r2 rL rk r` rl rf %tuple[dict[str, Any], dict[str, Any]])NN)
rK r2 rL rk ra rm r` rl rf r0 )rA rD ra rm rf r0 re )rK r2 ra rm rf rD )rK r2 r- r rf rg )r rD rf zdict[str, str]rh ri )rn ro rp rq r{ __annotations__DEFAULT_POOLSIZEr DEFAULT_POOLBLOCKrX r r r r r r r r r rd r r r rb rr rs s @r. ru ru s, 4 Iy !! !1 ,#2, P P P ! P
P
P,L
" (
<$L88 !8+88@K8
8t$N TX2Q&2Q0=2QEP2Q .2Qp *. 7 7 7 ' 7
7
7t :>))!6) )V & 1F D
0 "& $ )-r2 r2 r2 r2
r2
r2 'r2
r2r/ ru )r, r r- r rf rg )
rK r2 rL zbool | str | NonerM z tuple[str, str] | str | NonerN r rf r )Qrq
__future__r os.pathrE sockettypingr r urllib3.exceptionsr r r r r r
r r r
r r r r r r r urllib3.poolmanagerr r urllib3.utilr r r urllib3.util.retryr authr compatr r r r
exceptionsr r r r r r r! modelsr"
structuresr# utilsr$ r% r& r' r( r) urllib3.contrib.socksr* ImportError
TYPE_CHECKINGurllib3.connectionpoolr0 r r1 _tr2 r3 r r r r DEFAULT_POOL_TIMEOUTrR rT ru r r/ r. r s #
7 > 8 4 ; 0 " $ ! ( + + G7
9? ' / "$
"$ "$ ."$ "$
+ "$J!" !"HN 2+ N 2} GGGs .D
DDPK ! R`~ 2 2 + __pycache__/_internal_utils.cpython-312.pycnu [
9r*j d Z ddlZddlmZ ej d Z ej d Z ej d Z ej d ZeefZ eefZ
e e
e e iZ
dd e e z d
e d e fd Zd
e d efdZy)z
requests._internal_utils
~~~~~~~~~~~~~~
Provides utility functions that are consumed internally by Requests
which depend on extremely few external helpers (such as compat)
N ) builtin_strs ^[^:\s][^:\r\n]*\Zz^[^:\s][^:\r\n]*\Zs ^\S[^\r\n]*\Z|^\Zz^\S[^\r\n]*\Z|^\Zstringencodingreturnc P t | t r| }|S | j | }|S )zGiven a string object, regardless of type, returns a representation of
that string in the native string type, encoding and decoding where
necessary. This assumes ASCII unless told otherwise.
)
isinstancer decode)r r outs G/opt/hc_python/lib/python3.12/site-packages/requests/_internal_utils.pyto_native_stringr
s/
&+& J mmH% J u_stringc j t | t sJ | j d y# t $ r Y yw xY w)zDetermine if unicode string only contains ASCII characters.
:param str u_string: unicode string to check. Must be unicode
and not Python 2 `str`.
:rtype: bool
asciiTF)r strencodeUnicodeEncodeError)r s r unicode_is_asciir ' s: h $$ $ s & 22)r )__doc__recompatr compile_VALID_HEADER_NAME_RE_BYTE_VALID_HEADER_NAME_RE_STR_VALID_HEADER_VALUE_RE_BYTE_VALID_HEADER_VALUE_RE_STR_HEADER_VALIDATORS_STR_HEADER_VALIDATORS_BYTEbytesr HEADER_VALIDATORSr
boolr r r r$ s
'RZZ(> ? &BJJ'< = (bjj)> ? 'RZZ(< = 35OP 57RS "
S5[
C
c
s t r PK ! {9
? ? ! __pycache__/utils.cpython-312.pycnu [
9r*j B U d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl Z ddl
Z
ddl Z ddl Z ddl
Z
ddlmZ ddlmZmZ ddlmZmZmZmZmZmZ ddlmZm Z dd l m Z dd
l m Z dd l m!Z!m"Z"m#Z#m$Z$ dd l%m&Z' dd
l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl(m6Z7 ddl8m9Z9 ddl:m;Z;mZ> ddl?m@Z@ er ddlAmBZB ddlmCZC ddl m%ZD ddlEmFZFmGZGmHZH dZIdeJd< e j ZLdeJd< dd d ZMdeJd < ed ZN ed ZOd!j ej d" ed#$ d% ZRdeJd&< e
j d'k( rd\d(ZTd\d)Z/ d]d*ZUd^d+ZV d_ d`d,ZWdad-ZXdbd.ZYej dcd/ Z[ ddd0Z\eded1 Z]e dfd2 Z] dgd3Z]dhd4Z^did5Z_d_djd6Z`dkd7Zadld8Zbdmd9Zcdnd:Zddod;Ze dpd<Zfe dqd= Zge drd> Zg dsd?Zgdtd@Zh eidA ZjdeJdB< dudCZkdudDZldvdEZmdwdFZndxdGZodydHZpej dzdI Zqd{dJZrd|d}dKZsd~dLZt d ddMZudddNZvddOZwddPZxdQj dR ZzezdSz Z{ezdTz Z|ddUZ}ddVZ~ddWZddXZ ddYZddZZdd[Zy)z
requests.utils
~~~~~~~~~~~~~~
This module provides utility functions that are used within Requests
that are also useful for external consumption.
) annotationsN) OrderedDict) GeneratorIterable)
TYPE_CHECKINGAnyFinalTypeVarcastoverload) make_headers parse_url )certs __version__)_HEADER_VALIDATORS_BYTE_HEADER_VALIDATORS_STRHEADER_VALIDATORSto_native_string)
SupportsItems)
Mappingbytes
getproxiesgetproxies_environment
integer_types is_urllib3_1 proxy_bypassproxy_bypass_environmentquotestrunquoteurlparse
urlunparse)parse_http_listcookiejar_from_dict)FileModeWarning
InvalidHeader
InvalidURLUnrewindableBodyError)CaseInsensitiveDict) CookieJar)BufferedWriter)_types)PreparedRequestRequestResponse)z.netrc_netrcr NETRC_FILESr! DEFAULT_CA_BUNDLE_PATHP i )httphttps
DEFAULT_PORTS_KT_VTz, z,\s*T)accept_encodingzaccept-encodingDEFAULT_ACCEPT_ENCODINGwin32c dd l } |j |j d }t |j |d d }|j |d d }|r|sy|j d }t d | }|D ]j }|dk( rd| vr y |j dd
}|j d d }|j d
d }t j || t j sj y y# t $ r Y yw xY w# t t f$ r Y yw xY w)Nr Fz;Software\Microsoft\Windows\CurrentVersion\Internet Settings ProxyEnable
ProxyOverride;z.Tz\.*z.*?)winreg ImportErrorOpenKeyHKEY_CURRENT_USERint QueryValueExOSError
ValueErrorsplitfilterreplacerematchI)hostrF internetSettings proxyEnable
proxyOverridetests =/opt/hc_python/lib/python3.12/site-packages/requests/utils.pyproxy_bypass_registryrZ c s
%~~((N
f 1 12BM RST UVK " / /0@/ RST UM -
&++C0
t]3
!Dy d? <<U+D<<U+D<<T*DxxdBDD) " C $ s# C( AC7 ( C43C47D D c B t r t | S t | S )zReturn True, if the host should be bypassed.
Checks proxy settings gathered from the environment, if specified,
or the registry.
)r r rZ )rT s rY r r s " #+D1 1(. . c F t | t r| j S | S )z/Returns an internal sequence dictionary update.)
isinstance_SupportsItemsitems)ds rY dict_to_sequencerb s
!^$wwy Hr\ c d }d}t s!t | t r| j d } t | d r t | }n~t | d r
| j
}net | d rY | j
}t j | j }d| j vrt j dt t | d rW | j# }t | d r:|8 | j% dd
| j# }| j% |xs d |d}t) d||z
S # t j t f$ r Y w xY w# t& $ r d}Y ?w xY w# t& $ r ||}Y Rw xY w) Nr utf-8__len__lenfilenoba% Requests has determined the content-length for this request using the binary size of the file: however, the file has been opened in text mode (i.e. without the 'b' flag in the mode). This may lead to an incorrect content-length. In Requests 3.0, support will be removed for files in text mode.tellseek )r r^ r! encodehasattrrf rg osfstatst_sizemodewarningswarnr( ioUnsupportedOperationAttributeErrorri rj rL max)o total_lengthcurrent_positionrg s rY super_lenr{ sy L Jq# .
HHW q) 1v E uu H XXZF 88F+33L !&&
2 $
q& % vvx q&!l&: %FF1aL#$668L FF+0q1 q,!11 22e '' 8
X %#$L%% 0
'#/
0s6 *D8 E( .7E 8EE E%$E%(
E87E8c ` t | t r| j d } t j j d }||f}n
d t D } ddlm}m} d}|D ]D }t j j | }t j j | sB|} n |yt | } | j }
|
y || j |
} | r't | r| d rdnd} | | xs d| d xs dfS yy# |t f$ r |r Y yw xY w# t" t$ f$ r Y yw xY w)
z;Returns the Requests tuple auth for a given url from netrc.rd NETRCNc 3 & K | ] }d | yw)z~/N ).0fs rY z!get_netrc_auth.. s 9[Rs8[s r )NetrcParseErrornetrcr rk )r^ r decodern environgetr4 r r path
expanduserexistsr# hostnameauthenticatorsanyrL rG rv )
url raise_errors
netrc_filenetrc_locationsr r
netrc_pathr locrirT r3 login_is
rY get_netrc_authr s;
#u jj! (J %-9[9#
0
A''$$Q'Cww~~c"
!
c]{{ <
:&55d;F#f+ %ay!a w-2vayB?? &v )
(
s= A
D #D +D >D DD DD D-,D-c t | dd }|rHt |t t f r1|d dk7 r(|d dk7 r t j
j
| S yyyy)z0Tries to guess the filename of the given object.nameNr <>)getattrr^ r! r rn r basename)objr s rY guess_filenamer sX 3 %D
4#u .47c>d2hRUoww %% GV>.tr\ c F t j j | r| S t j j | \ }}|ryt j j | sZt j j | \ }}|sn5dj ||g }|r t j j | sZt j | s| S t j | }||j vr| S t j j |j d d d }t j | \ }} t j ||j | t j | |S # t j | w xY w)zReplace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
/r )suffix)rn r r rN joinzipfile
is_zipfileZipFilenamelistsplitexttempfilemkstempwritereadclose)r archivememberprefixzip_filer fdextracted_paths rY extract_zipped_pathsr " s;
ww~~d ggmmD)OGV
"''..1 ''--0
66*+
"''..1 g & w'H
X&&(( WW
fll3 / 3
4R
8F!))8B
X]]6*+
s
%F F c # J K t j t j j | \ }} t j
|d 5 }| ddd t j || y# 1 sw Y xY w# t $ r t j | w xY ww)z-Write a file to the disk in an atomic fashion)dirwbN) r r rn r dirnamefdopenrP
BaseExceptionremove)filenametmp_descriptortmp_name tmp_handlers rY atomic_openr H s ( / /BGGOOH4M N NH
YY~t
, -
8X& -
,
(
s4 7B#B A4 B 3B#4A=9B B B#c t | yt | t t t t f r t d t
| S )a Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
Traceback (most recent call last):
...
ValueError: cannot encode objects that are not 2-tuples
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
N+cannot encode objects that are not 2-tuples)r^ r! r boolrJ rM r values rY from_key_val_listr U s6 (
}%#udC01FGG u r\ c y Nr r s rY to_key_val_listr r s *-r\ c y r r r s rY r r t s r\ c | yt | t t t t f r t d t | t rt | j S t | S )a Take an object and test to see if it can be represented as a
dictionary. If it can be, return a list of tuples, e.g.,
::
>>> to_key_val_list([('key', 'val')])
[('key', 'val')]
>>> to_key_val_list({'key': 'val'})
[('key', 'val')]
>>> to_key_val_list('string')
Traceback (most recent call last):
...
ValueError: cannot encode objects that are not 2-tuples
:rtype: list
Nr ) r^ r! r r rJ rM r_ listr` r s rY r r x sP &
}%#udC01FGG% (EKKM"" ;r\ c g }t | D ]5 }|dd |dd cxk( rdk( rn nt |dd }|j | 7 |S )a Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
Nr r ")_parse_list_headerunquote_header_valueappend)r resultitems rY parse_list_headerr sT . F"5) 8tBCy 'C ''Qr
3D
d * Mr\ c i }t | D ]H }d|vrd||<
|j dd \ }} | dd | dd cxk( rdk( rn nt | dd } | ||< J |S )a^ Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
=Nr r r )r rN r )r r r r s rY parse_dict_headerr sx , %'F"5) d? F4L jja( e !9bc
)c )(q5E t * Mr\ c | rF| d | d cxk( rdk( r5n | S | dd } |r| dd dk7 r"| j dd j d d S | S )
zUnquotes a header value. (Reversal of :func:`quote_header_value`).
This does not use the real unquoting but what browsers are actually
using for quoting.
:param value: the header value to unquote.
:rtype: str
r r r r Nrk z\\\z\")rP )r is_filenames rY r r sd
qU2Y-#- L a eBQi6 1==.66ucB B Lr\ c X | D ci c] }|j |j }}|S c c}w )zReturns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
)r r )cjcookie cookie_dicts rY dict_from_cookiejarr s0 <>>26;; ,2K> ?s 'c t || S )zReturns a CookieJar from a key/value dictionary.
:param cj: CookieJar to insert cookies into.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:rtype: CookieJar
r& )r r s rY add_dict_to_cookiejarr s {B //r\ c ^ t j dt t j dt j
}t j dt j
}t j d }|j
| |j
| z |j
| z S )zlReturns encodings from given content string.
:param content: bytestring to extract encodings from.
zIn requests 3.0, get_encodings_from_content will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)z!])flagsz+]z$^<\?xml.*?encoding=["\']*(.+?)["\'>])rr rs DeprecationWarningrQ compilerS findall)content
charset_re pragma_rexml_res rY get_encodings_from_contentr
s
MM
1
@MJ
IQSQUQUVI
ZZ?
@F 7#
G
$ %
..
! "r\ c B | j d }|d j |dd }}i }d}|D ]j }|j }|s|j d x}dk7 s-|d| j | }||dz d j | } | ||j < l ||fS )zReturns content type and parameters from given header.
:param header: string
:return: tuple containing content type and dictionary of
parameters.
rB r r Nz"' r r )rN stripfindlower)
headertokens content_typeparams params_dict strip_charsparamidxkeyr s
rY _parse_content_type_headerr # s \\#
F!!9??,fQRj&L)+KK
UZZ_,c3+##K0C#')$**;7E',K $ $$r\ c | j d }|syt | \ }}d|v r|d j d S d|v ryd|v ryy) z}Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
z content-typeNcharsetz'"textz
ISO-8859-1zapplication/jsonrd )r r r )headersr r s rY get_encoding_from_headersr 9 s` ;;~.L 5lCL&Fi &&u--
\) *r\ c # K |j | E d{ y t j |j d }| D ] }|j | }|s| |j dd }|r| yy7 ew)zStream decodes an iterator.NrP errorsr\ T)final)encodingcodecsgetincrementaldecoderr )iteratorrdecoderchunkrvs rY stream_decode_response_unicoder R s
zz6f**1::6iHG
^^E
"
H
4 (B
s A<A:AA<"A<c y r r string slice_lengths rY iter_slicesr e s $'r\ c y r r r s rY r r i s "%r\ c # K d}||dk r t | }|t | k r | |||z ||z
}|t | k r yyw)z Iterate over slices of a string.r N)rf )r r poss rY r r m sY C|q 06{
F
S3 -.. | F
s A AAc ` t j dt | j yg }t | j
}|r t
| j | S t
| j |xs dd S # t $ r |j | Y 9w xY w# t $ r | j cY S w xY w)zReturns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
zIn requests 3.0, get_unicode_from_response will be removed. For more information, please see the discussion on issue #2266. (This warning should only appear once.)Nrd rP r )
rr rs r r r r r! UnicodeErrorr TypeError)r tried_encodingsr s rY get_unicode_from_responser y s
MM
1
yy!#O )3H -qyy(+ +
199h 1')DD - " "8 , - yys$ A5 B 5BBB-,B-zBABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~UNRESERVED_SETc | j d }t dt | D ]l }|| dd }t | dk( rI|j r9 t t |d }|t v r||| dd z ||< Vd|| ||< bd|| ||< n d j | S # t $ r t d| d w xY w)
zUn-escape any percent-escape sequences in a URI that are unreserved
characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
:rtype: str
%r r rk z"Invalid percent-escape sequence: ''Nr )
rN rangerf isalnumchrrJ rM r* r r )uripartsihcs rY unquote_unreservedr' s
IIcNE
1c%j
! !HQqM q6Q;199;
LAr
O N" uQx|+a uQxj>a58*~E!H " 775>
L #EaS!JKK
Ls B''C c p d}d} t t | | S # t $ r t | | cY S w xY w)zRe-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
z!#$%&'()*+,/:;=?@[]~z!#$&'()*+,/:;=?@[]~)safe)r r' r* )r" safe_with_percentsafe_without_percents rY requote_urir, sJ /0 5 ',3DEE 5 S 344 5s 55c
r t j dt j | d }|j d \ }}t j dt j t t
| d }t j dt j | d |z }||z ||z k( S )zThis function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
z=Lr r )structunpacksocket inet_atonrN dotted_netmaskrJ )ipnetipaddrnetaddrbitsnetmasknetworks rY address_in_networkr: s ]]4!1!1"!5
6q
9FIIcNMGTmmD&"2"2>#d)3L"MNqQGmmD&"2"27";I)r0 inet_ntoar. pack)maskr7 s rY r2 r2 s7 b4i 1, ,D FKKd 3 44r\ c N t j | y# t $ r Y yw xY w)z
:rtype: bool
FT)r0 r1 rL ) string_ips rY is_ipv4_addressrB s. # s $$c | j d dk( rR t | j d d }|dk s|dkD ry t j
| j d d yy# t $ r Y yw xY w# t $ r Y yw xY w)zV
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
r r Fr< r T)countrJ rN rM r0 r1 rL )string_networkr? s rY
is_valid_cidrrF s C A% ~++C034D !8tby ^ 1 1# 6q 9 :
s" A( 'A7 ( A43A47 BBc # < K |du}d}|r2t j j | }|t j | < d |r(|t j | = y|t j | < yy# |r(|t j | = w |t j | < w w xY ww)zSet the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothingN)rn r r )env_namer
value_changed old_values rY set_environrK s %M IJJNN8, $
8 1
JJx('0
8$ = JJx('0
8$ s ;B A- +B -,BB c d d}|}| |d }t | }|j }|y|rd |j dd j d D }t | r)|D ]# }t | rt
|| s y||k( s# y nm|}|j r|d |j z
}|D ]H } | j d
} || k( s|| k( r yd
| z } |j | s|j | sH y t d| 5 t | }
ddd
ryy # t t j f$ r d }
Y )w xY w# 1 sw Y .xY w)
zL
Returns whether we should bypass proxies or not.
:rtype: bool
c t j j | xs- t j j | j S r )rn r r upper)r s rY get_proxyz(should_bypass_proxies..get_proxy3 s- zz~~c"AbjjnnSYY[&AAr\ Nno_proxyTc 3 & K | ] }|s| y wr r )r rT s rY r z(should_bypass_proxies..E s X+O4SW$+Os r ,:rC F)r r! return
str | None)r# r rP rN rB rF r: portlstripendswithrK r r r0 gaierror) r rP rO no_proxy_argparsedr no_proxy_hostsproxy_iphost_with_portrT bypasss rY should_bypass_proxiesra * s] B
L Z(
c]FH Y8+;+;C+D+J+J3+OX 8 $ * *)(H= # ) + &N{{ Afkk]"33&{{3't#~'= Tz$$T*n.E.Ed.K
'
Z . !(+F
/
6??+ F
/ .s* D< DD96D<8D99D<<Ec 4 t | | ri S t S )zA
Return a dict of environment proxies.
:rtype: dict
rP )ra r )r rP s rY get_environ_proxiesrd i s S84 |r\ c . |xs i }t | }|j +|j |j |j d S |j dz |j z |j d|j z dg}d}|D ] }||v s|| } |S |S )zSelect a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
Nallz://zall://)r# r r scheme)r proxiesurlparts
proxy_keysproxy proxy_keys rY select_proxyrm u s mG}H {{8??GKK,>?? % ("3"338$$$
J
E I&E L
Lr\ c T ||ni }t t | j }t | j }|j d }|j
}|rOt || sBt || }|j ||j d }|r|j || |S )a This method takes proxy information from a request and configuration
input to resolve a mapping of target proxies. This will consider settings
such as NO_PROXY to strip proxy configurations.
:param request: Request or PreparedRequest
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
:param trust_env: Boolean declaring whether to trust environment configs
:rtype: dict
rP rc rf )
r r! r r# rg r copyra rd
setdefault) requestrh trust_envr rg rP new_proxiesenviron_proxiesrk s rY resolve_proxiesru s !,g"G
sGKK
C
c]
!
!F{{:&H,,.K.sXF-cHE ##FO,?,?,FG " "65 1 r\ c | dt S )zO
Return a string representing the default user agent.
:rtype: str
r r )r s rY default_user_agentrw s V1[M ""r\ c : t t t ddd S )z9
:rtype: requests.structures.CaseInsensitiveDict
z*/*z
keep-alive)z
User-AgentzAccept-EncodingAccept
Connection)r, rw r= r r\ rY default_headersr{ s% ,. 6&
r\ c g }d}| j | } | s|S t j d| D ] } |j dd \ }}d|j d i}|j d D ]: } |j d \ }} | j | ||j | < < |j | |S # t $ r |d}}Y w xY w# t $ r Y 4w xY w) zReturn a list of parsed link headers proxies.
i.e. Link: ; rel=front; type="image/jpeg",; rel=back;type="image/jpeg"
:rtype: list
z '"z, * '"r )r rQ rN rM r ) r links
replace_charsvalr r linkr r s rY parse_header_linksr s #%EM KK
&E xx& " ))C+KC !&syy': ;\\#&E
"[[ -
U .3[[ -GD=) *
' T! '$ L " rC "
s# B?1C?
CC C C asciirk c | dd }|t j t j fv ry|dd t j k( ry|dd t j t j
fv ry|j
t }|dk( ry |dk( r |ddd t k( ry
|d dd t k( ry |dk( r|dd t k( ry
|d d t k( ryy)z
:rtype: str
N zutf-32r z utf-8-sigrk zutf-16r rd z utf-16-ber z utf-16-lez utf-32-bez utf-32-le)
r BOM_UTF32_LE BOM_UTF32_BEBOM_UTF8 BOM_UTF16_LE BOM_UTF16_BErD _null_null2_null3)datasample nullcounts rY guess_json_utfr s "1XF
&%%v':':;;
bqzV__$
bqzf))6+>+>?? U#IA~A~ #A#;& !$Q$<6 ! A~ "1: !": r\ c t | }|\ }}}}}}} |j }
|
s||
}}
|r#t t |
}
dj ||
g }
||}|d}t ||
|d|| f S )zGiven a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
@r )r netlocr r! r r$ ) r
new_schemer\ rg auth_host_portr queryfragmentr s rY prepend_scheme_if_neededr s s^F8>5FD%eX ]]F V c6"4.)
~ | vvtRA BBr\ c t | } t |j t |j f}|S # t t
f$ r d}Y |S w xY w)z{Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
)r r )r# r" usernamepasswordrv r )r r\ r s rY get_auth_from_urlr . sU c]F('&//*BC K
I & Ks *9 A
Ac B | \ }}t | |d t | |d y)zVerifies that header parts don't contain leading whitespace
reserved characters, or return characters.
:param header: tuple, in the format (name, value).
r r N)_validate_header_part)r r r s rY check_header_validityr ? s% KD%&$*&%+r\ c
t |t r
t | }n7t |t r
t | }n t d|d| dt
| |j | s|dk( rdnd}t d| d| y ) Nz
Header part (z) from z# must be of type str or bytes, not r r r zTInvalid leading whitespace, reserved character(s), or return character(s) in header z: )r^ r! r r r r) typerR )r header_partheader_validator_index validator header_kinds rY r r J s
+s#*+AB K '+,BC K?'& :115k1B0C
E
??; ' 6! ;f &&1]"[O
E
(r\ c ~ t | \ }}}}}}|s||}}|j dd d }t |||||df S )zW
Given a url remove the fragment and the authentication part.
:rtype: str
r r r r )r# rsplitr$ )r rg r r r r _fragments rY
urldefragauthr b sU 6>c]2FFD&% V
]]3
"2
&F vvtVUB? @@r\ c t | j dd }|.t | j t r || j yt
d # t
$ r t
d w xY w)zfMove file pointer back to its recorded starting position
so it can be read again on redirect.
rj Nz;An error occurred when rewinding request body for redirect.z+Unable to rewind request body for redirect.)r bodyr^ _body_positionr rL r+ )prepared_request body_seeks rY rewind_bodyr s su (--vtr s #
# / 1 $ 4 : ( ,(! ::) U ) *ekkm + !#S1
u 1
en
en "& BHHWl489JKL"
<<7$L /
=
D3P +01
1
#'1
1
h&#L ? :
-
- A
H ! @ @ F202%,2 "*'&
' '!+'!'
'
% % )% %
% '1 ' &T "M
05, 5 50 1 1,<~ :
&
" ># "L
g @C<",
+
0A"Sr\ PK ! m= = __pycache__/auth.cpython-312.pycnu [
9r*j/ L U d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl m
Z
ddl m Z m
Z
mZmZmZ ddlmZ ddlmZmZmZ dd lmZ dd
lmZ e rdd lm Z dd l m
Z
dd
l m Z m Z dZ de!d< dZ"de!d< d dZ# G d d Z$ G d de$ Z% G d de% Z& G d de$ Z'y) z]
requests.auth
~~~~~~~~~~~~~
This module contains the authentication handlers for Requests.
) annotationsN) b64encode)
TYPE_CHECKINGAnyFinalcastoverload )to_native_string)
basestringstrurlparse)extract_cookies_to_jar)parse_dict_header) CookieJar)r )PreparedRequestResponsez!application/x-www-form-urlencodedr CONTENT_TYPE_FORM_URLENCODEDzmultipart/form-dataCONTENT_TYPE_MULTI_PARTc t | t s*t j d| dt t | } t |t s3t j dt
| dt t | }t | t
r| j d } t |t
r|j d }dt t dj | |f j z }|S )z Returns a Basic Auth string.zpNon-string usernames will no longer be supported in Requests 3.0.0. Please convert the object you've passed in (zC) to a string or bytes object in the near future to avoid problems.)categoryzpNon-string passwords will no longer be supported in Requests 3.0.0. Please convert the object you've passed in (latin1zBasic :)
isinstancer warningswarnDeprecationWarningr
typeencoder r joinstrip)usernamepasswordauthstrs Br' r) c j e Zd ZU dZded< ded< ed d Zed
d ZddZddZdd Zdd
Z y )
HTTPBasicAuthz?Attaches HTTP Basic Authentication to the given Request object. bytes | strr" r# c y Nr7 r- r" r# s r% __init__zHTTPBasicAuth.__init__[ >Ar' c y r< r7 r= s r% r> zHTTPBasicAuth.__init__] BEr' c || _ || _ y r< )r" r# r= s r% r> zHTTPBasicAuth.__init__` s
r' c | t | j t |dd k( | j t |dd k( g S Nr" r# allr" getattrr# r- others r% __eq__zHTTPBasicAuth.__eq__d >
D!AA
D!AA
r' c | |k( S r< r7 rH s r% __ne__zHTTPBasicAuth.__ne__l 5= r' c ` t | j | j |j d< |S )N
Authorizationr& r" r# headersr, s r% r/ zHTTPBasicAuth.__call__o s$ %4T]]DMM%R /"r' Nr" r
r# r
r1 Noner" bytesr# rV r1 rT r" r: r# r: r1 rT rI objectr1 boolrI r r1 rZ r0 )
r3 r4 r5 r6 __annotations__r r> rJ rM r/ r7 r' r% r9 r9 U sA I
A A
E E!
!r' r9 c e Zd ZdZddZy)
HTTPProxyAuthz=Attaches HTTP Proxy Authentication to a given Request object.c ` t | j | j |j d< |S )NzProxy-AuthorizationrQ r, s r% r/ zHTTPProxyAuth.__call__w s% +:4==$--+X '(r' Nr0 r2 r7 r' r% r^ r^ t s
Gr' r^ c e Zd ZU dZded< ded< ded< ded< d ed
< d ed < d
ed< d
ed< edd Zed d Zd dZd dZd dZd dZ d!dZ
d"dZ d#dZ d$dZ
y)%HTTPDigestAuthz@Attaches HTTP Digest Authentication to the given Request object.r: r" r# zthreading.local
_thread_localr
last_nonceint nonce_countzdict[str, str]chalz
int | Nonepos
num_401_callsc y r< r7 r= s r% r> zHTTPDigestAuth.__init__ r? r' c y r< r7 r= s r% r> zHTTPDigestAuth.__init__ rA r' c R || _ || _ t j | _ y r< )r" r# threadinglocalrb r= s r% r> zHTTPDigestAuth.__init__ s
&__ .r' c t | j d sgd| j _ d| j _ d| j _ i | j _ d | j _ d | j _ y y )NinitT r )hasattrrb ro rc re rf rg rh )r- s r% init_per_thread_statez$HTTPDigestAuth.init_per_thread_state sk t))62&*D #,.D )-.D *&(D #%)D "/3D ,
3r' c P | j j d }| j j d }| j j j d }| j j j d }| j j j d }d|d}n|j }|dk( s|dk( rd*d } | n#|d
k( rd*d }
|
n|d k( rd*d
} | n |dk( rd*d} | yd+fd }
d}t | }|j
xs d}|j r|d|j z
}| j d| d| j }| d| } | } | }|| j j k( r | j xj dz
c_
nd| j _
| j j d}t | j j j d }||j d z
}|t j j d z
}|t j d z
}t# j$ |d j' dd }|dk( r | d| d| }|s |
|| d| }n0|dk( sd|j) d v r| d| d| d | } |
|| }ny|| j _ d | j d | d | d!| d"| d# }|r |d$| d#z
}|r |d%| d#z
}|r |d&| d#z
}|r |d'| d(| d#z
}d)| S ),z
:rtype: str
realmnonceqop algorithmopaqueNMD5zMD5-SESSc t | t r| j d } t j | d j S Nutf-8Fusedforsecurity)r r
r hashlibmd5 hexdigestxs r% md5_utf8z4HTTPDigestAuth.build_digest_header..md5_utf8 s4 a%)A {{1e<FFHHr' SHAc t | t r| j d } t j | d j S r{ )r r
r r sha1r r s r% sha_utf8z4HTTPDigestAuth.build_digest_header..sha_utf8 s4 a%)A ||Au=GGIIr' zSHA-256c t | t r| j d } t j | d j S r{ )r r
r r sha256r r s r% sha256_utf8z7HTTPDigestAuth.build_digest_header..sha256_utf8 4 a%)A ~~a?IIKKr' zSHA-512c t | t r| j d } t j | d j S r{ )r r
r r sha512r r s r% sha512_utf8z7HTTPDigestAuth.build_digest_header..sha512_utf8 r r' c | d| S )N:r7 )sd hash_utf8s r% KDz.HTTPDigestAuth.build_digest_header..KD s s!A3Z( (r' /?r r
08xr| Fr} auth,z:auth:z
username="z
", realm="z
", nonce="z", uri="z
", response=""z
, opaque="z
, algorithm="z
, digest="z, qop="auth", nc=z
, cnonce="zDigest )r z str | bytesr1 r
)r r
r r
r1 r
)rb rf getupperr pathqueryr" r# rc re r
r timectimeosurandomr r r split) r- methodurlrt ru rv rw rx
_algorithmr r r r r entdigp_parsedr A1A2HA1HA2ncvaluer cnoncerespdignoncebitbaser s @r% build_digest_headerz"HTTPDigestAuth.build_digest_header s
""''0""''0 %%))%0&&++// < ##((,,X6 J" *J *
":
I
!I
5
J
!I
9
$
L
$I
9
$
L
$I ) C=}}# >> a'( (D
awa
7xq
mm D&&11 1 * *a / *-.D *''33C8 "".. / 6 6w ? U\\'
"" TZZ\
)) RZZ] a7AACCRH #se1UG1VH 56Cq ./G
F]f # 6 '!F86#?Hh'G (-% z%
5' J6 wiq
2
j* *D mI;a0 0D j* *D 'y
6(!D DD r' c @ |j rd| j _ yy)z)Reset num_401_calls counter on redirects.r
N) is_redirectrb rh )r- r. kwargss r% handle_redirectz HTTPDigestAuth.handle_redirect s ==/0D , r' c d|j cxk rdk sn d| j _ |S | j j ?t |j
j dd x} || j j |j j dd }d|j v r| j j d k r| j xj dz
c_ t j d
t j }t |j d|d | j _ |j |j# |j
j% }t' d
|j( }t+ ||j
|j, |j/ | | j1 t' t2 |j4 t' t2 |j6 }|r||j d< |j8 j: |fi |} | j< j? | || _ | S d| j _ |S )zo
Takes the given response and tries digest-auth, if needed.
:rtype: requests.Response
i i r
Nseekzwww-authenticaterp digest zdigest )flags)countr rP ) status_coderb rh rg rG requestbodyrR r lowerrecompile
IGNORECASEr subrf contentclosecopyr _cookiesr rawprepare_cookiesr r
r r
connectionsendhistoryappend)
r- r. r r s_authpatprep
cookie_jar _digest_auth_rs
r%
handle_401zHTTPDigestAuth.handle_401 s amm)c)/0D ,H ! ! - ==JT''++, 126 v||~ %$*<*<*J*JQ*N , , 1 ,**Zr}}=C&7FRS8T&UD #
II
GGI99>>#D k4==9J ":qyy!%% @ , 33S$++&S$(((; L 0< _-" ""4262B JJ a BJI+,(r' c | j | j j rS| j t t
|j t t
|j }|r||j d< t |j dd x} | | j _ nd | j _ |j d| j |j d| j d| j _ |S )NrP tellresponser
)rr rb rc r r r
r r rR rG r rg
register_hookr r rh )r- r. r r s r% r/ zHTTPDigestAuth.__call__A s ""$ ( ( 33S!((#T#quu%5 L -9 /*AFFFD1 1D >%)VD " &*D "
DOO4
D$8$89+,(r' c | t | j t |dd k( | j t |dd k( g S rD rE rH s r% rJ zHTTPDigestAuth.__eq__Y rK r' c | |k( S r< r7 rH s r% rM zHTTPDigestAuth.__ne__a rN r' NrS rU rW )r1 rT )r r
r r
r1 z
str | None)r. r r r r1 rT )r. r r r r1 r r0 rX r[ )r3 r4 r5 r6 r\ r r> rr r r r r/ rJ rM r7 r' r% ra ra | sz J""O
O
A A
E E/ 4m ^1
.`0
!r' ra )r" r: r# r: r1 r
)(r6
__future__r r r r rl r r base64r typingr r r r r _internal_utilsr compatr r
r cookiesr utilsr http.cookiejarr modelsr r r r\ r r& r) r9 r^ ra r7 r' r% r s # < < - - - + $(1&I e I!6 6)XB B H >M f!X f!r' PK ! 7K " __pycache__/compat.cpython-312.pycnu [
9r*j d Z ddlmZ ddlZddlZddlmZ ddlmZ e
e j d d dk( Z dd Z e Zej" Zed d
k( Zed d k( Zd Z ddlZdZerdd
lmZ ndd
lmZ ddlmZ ddl m Z m Z m Z ddl m!Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3m4Z4m5Z5m6Z6m7Z7 e8Z9e8Z8e:Z:e8e:fZ;e
ey# e
ef$ r dZ Y w xY w# e$ r ddlZY w xY w)z
requests.compat
~~~~~~~~~~~~~~~
This module previously handled import compatibility issues
between Python 2 and Python 3. It remains for backwards
compatibility until the next major version.
) annotationsN)
ModuleType) __version__. Tc h d} dD ] }| t j | } | S # t $ r Y +w xY w)z-Find supported character detection libraries.N)chardetcharset_normalizer) importlib
import_module ImportError)r libs >/opt/hc_python/lib/python3.12/site-packages/requests/compat.py_resolve_char_detectionr % sF G0 ?
#11#6 1 N
s % 11 F)JSONDecodeError) OrderedDict)CallableMappingMutableMapping) cookiejar)Morsel)StringIO)
quote
quote_plusunquote unquote_plus urldefrag urlencodeurljoinurlparseurlsplit
urlunparse)
getproxiesgetproxies_environmentparse_http_list proxy_bypassproxy_bypass_environment)returnzModuleType | None)?__doc__
__future__r r systypesr urllib3r urllib3_versionintsplit is_urllib3_1 TypeErrorAttributeErrorr r version_info_veris_py2is_py3has_simplejson
simplejsonjsonr
r collectionsr collections.abcr r r httpr cookielib http.cookiesr ior urllib.parser r r r r r r! r" r# r$ urllib.requestr% r& r' r( r) str builtin_strbytes
basestringfloat
numeric_types
integer_types r rN s$ #
,,,S1!45:L "
#
aA
aA N *$ $ = = '
5\
e
k >" LT s# C &C$ C! C!$ C0/C0PK ! H4 " __pycache__/models.cpython-312.pycnu [
9r*j7 U d Z ddlmZ ddlZddlZddlmZmZm Z m
Z
m Z ddl m
Z
ddlmZmZmZmZmZmZ ddlmZmZmZmZmZ ddlm Z dd l m Z dd
l m Z d d l!m"Z"m#Z# d d
l$m%Z& d dl'm(Z( d dl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl)m2Z3 d dl4m5Z5m6Z6m7Z7 d dl8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@ d dl8m*ZA d dl8mZB d dlCmDZD d dlEmFZF d dlGmHZH d dlImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZS er ddlTmUZU ddlVmWZW d dlXm$ZY d d lZm[Z[ d d l4m\Z\ eFj eFj eFj eFj eFj fZbd ecd < d Zdd!ecd"< d#Zed!ecd$< d%Zfd!ecd&< G d' d( Zg G d) d* Zh G d+ d,eh Zi G d- d.egeh Zj G d/ d0 Zky)1z`
requests.models
~~~~~~~~~~~~~~~
This module contains the primary objects that power Requests.
) annotationsN)Callable GeneratorIterableIteratorMapping)UnsupportedOperation)
TYPE_CHECKINGAnyFinalLiteralcastoverload) DecodeErrorLocationParseError
ProtocolErrorReadTimeoutErrorSSLError) RequestField)encode_multipart_formdata) parse_url )to_native_stringunicode_is_ascii) SupportsRead)
HTTPBasicAuth)JSONDecodeError
basestring builtin_strchardet cookielib urlencodeurlsplit
urlunparse)json)_copy_cookie_jarcookiejar_from_dictget_cookie_header)ChunkedEncodingErrorConnectionErrorContentDecodingError HTTPErrorInvalidJSONError
InvalidURL
MissingSchemaStreamConsumedError)r )r )
default_hooks)codes)CaseInsensitiveDict)
check_header_validityget_auth_from_urlguess_filenameguess_json_utf iter_slicesparse_header_links requote_uri stream_decode_response_unicode super_lento_key_val_list) CookieJar)Self)_types) HTTPAdapter)RequestsCookieJarzFinal[tuple[int, ...]]REDIRECT_STATI intDEFAULT_REDIRECT_LIMITi ( CONTENT_CHUNK_SIZEi ITER_CHUNK_SIZEc e Zd ZU ded< ed d Zeed d Zeed
d Zee dd Zeedd Ze dd Ze dd Z y
)RequestEncodingMixin
str | Noneurlc g }t t t | j }|j }|sd}|j | |j }|r"|j d |j | dj | S )zBuild the path URL to use./? )r# r strrL pathappendqueryjoin)selfrL prR rT s >/opt/hc_python/lib/python3.12/site-packages/requests/models.pypath_urlz RequestEncodingMixin.path_urlp sl T#txx( )vvD
4 JJsO JJu wws| c y N datas rX _encode_paramsz#RequestEncodingMixin._encode_params s *-rZ c y r\ r] r^ s rX r` z#RequestEncodingMixin._encode_params s .1rZ c y r\ r] r^ s rX r` z#RequestEncodingMixin._encode_params s (+rZ c y r\ r] r^ s rX r` z#RequestEncodingMixin._encode_params s 47rZ c t | t t f r| S t | t r| S t | d rg }t | D ] \ }}t |t s t |d s|g}|D ]Z }||j t |t r|j d n|t |t r|j d n|f \ t |d S | S )zEncode parameters in a piece of data.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
__iter__utf-8T)doseq)
isinstancerQ bytes
_SupportsReadhasattrr= r rS encoder" )r_ resultkvsvs rX r` z#RequestEncodingMixin._encode_params s dS%L )K
m
,K
T:
&02F(.2 b*-WR5L BA}
5?35G 1Q5?35G 1Q / V40 0KrZ c | s t d t |t r t d g }t |xs i }t | xs i } |D ] \ }}t |t s t |d s|g}|D ]u }|t |t
s t
| }|j t |t
r|j d n|t |t r|j d n|f w | D ] \ }}d}d} t |t t f r1t | dk( r|\ }
} n.t | dk( r|\ }
} }n|\ }
} }} nt | xs |}
|} t | t t
t f r| } n&t | t r| j! } n| | } t# || |
| }
|
j% | |j |
t' | \ }}||fS )
a Build the body for a multipart/form-data request.
Will successfully encode files when passed as a dict or a list of
tuples. Order is retained if data is a list of tuples but arbitrary
if parameters are supplied as a dict.
The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
or 4-tuples (filename, fileobj, contentype, custom_headers).
zFiles must be provided.zData must not be a string.re Nrf )namer_ filenameheaders) content_type)
ValueErrorrh r r= rk ri rQ rS decoderl tuplelistlenr6 bytearrayrj readr make_multipartr )filesr_
new_fieldsfieldsfieldvalrp rn ftfhfnfpfdatarfbodyrw s rX
_encode_filesz"RequestEncodingMixin._encode_files s 67 7
j
) 9: :=?
, , JE3#z*'#z2Je=%a/ F %% *% 7 "LL 1!&1;As1CAHHW -
!$ DAqBB!eT]+q6Q; FBVq[!"JBB%&NBB#A&+!"sE9 56B
. 152rJB 2 . b !5 8 7z Bl\!!rZ NreturnrQ )r_ rQ r rQ )r_ ri r ri )r_ _t.SupportsRead[str | bytes]r r )r_ z
_t.KVDataTyper rQ )r_ z_t.EncodableDataTyper z*str | bytes | _t.SupportsRead[str | bytes])r _t.FilesTyper_ _t.RawDataType | Noner ztuple[bytes, str])
__name__
__module__ __qualname____annotations__propertyrY r staticmethodr` r r] rZ rX rJ rJ m s O
( - -
1 1
+*+ %+ + 7 7 " 3 > D"D"#8D" D" D"rZ rJ c 4 e Zd ZU ded< ddZddZy)RequestHooksMixin dict[str, list[_t.HookType]]hooksc || j vrt d| d t |t r | j | j | yt |d r&| j | j
d |D yy)zProperly register a hook.z.Unsupported event specified, with event name ""re c 3 B K | ] }t |t s| y wr\ )rh r ).0hs rX z2RequestHooksMixin.register_hook..
s $P1
1h8OQs N)r rx rh r rS rk extendrV eventhooks rX
register_hookz RequestHooksMixin.register_hook ss
" MeWTU VW W dH % JJu $ $T *
T:
& JJu $ $$P$P P 'rZ c ` | j | j | y# t $ r Y yw xY w)ziDeregister a previously registered hook.
Returns True if the hook existed, False if not.
TF)r removerx r s rX deregister_hookz!RequestHooksMixin.deregister_hook s3
JJu $ $T * s ! --N)r rQ r z#Iterable[_t.HookType] | _t.HookTyper None)r rQ r z _t.HookTyper bool)r r r r r r r] rZ rX r r s. '' Q Q C Q
Q rZ r c e Zd ZU dZded< ded< ded< ded < d
ed < d ed
< ded< ded< ded< d ddZddZddZy) Requesta{ A user-created :class:`Request ` object.
Used to prepare a :class:`PreparedRequest `, which is sent to the server.
:param method: HTTP method to use.
:param url: URL to send.
:param headers: dictionary of headers to send.
:param files: dictionary of {filename: fileobject} files to multipart upload.
:param data: the body to attach to the request. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param json: json for the body to attach to the request (if files or data is not specified).
:param params: URL parameters to append to the URL. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param auth: Auth handler or (user, pass) tuple.
:param cookies: dictionary or CookieJar of cookies to attach to this request.
:param hooks: dictionary of callback hooks, for internal usage.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> req.prepare()
rK method_t.UriType | NonerL zMapping[str, str | bytes]rv r r _t.DataTyper_ _t.JsonTyper%
_t.ParamsTypeparams _t.AuthTypeauth5RequestsCookieJar | CookieJar | dict[str, str] | NonecookiesNc D |g n|}|g n|}|i n|}|i n|}| i n| } t | _ t | j D ] \ } } | j | | || _ || _ || _ || _ || _ |
| _
|| _ || _ || _
y )N)r r )r1 r r{ itemsr r rL rv r r_ r% r r r )
rV r rL rv r r_ r r r r r% rn rp s
rX __init__zRequest.__init__A s \rtm "W ~6m"_
'DAq QQ / (
rZ c " d| j dS )Nz
r rV s rX __repr__zRequest.__repr__c s DKK=++rZ c t }|j | j | j | j | j
| j | j | j | j | j | j
|S )zXConstructs a :class:`PreparedRequest ` for transmission and returns it.)
r rL rv r r_ r% r r r r ) PreparedRequestpreparer rL rv r r_ r% r r r r rV rW s rX r zRequest.preparef sh ;;LL**;;LL**
rZ
NNNNNNNNNN)r rK rL r rv z_t.HeadersTyper r r_ r r r r r r r r _t.HooksInputType | Noner% r r r r r r )r r r __doc__r r r r r] rZ rX r r s 6
&&
BB "!%"& " $ IM*.
G (
D,rZ r c > e Zd ZU dZded< ded< ded< ded< d ed
< d ed < d
ed< d dZ d d dZd dZd!dZd"dZ e
d#d Z d$dZ d%dZ
d& d'dZd(dZ d) d*dZ d+dZd,d Zy)-r a) The fully mutable :class:`PreparedRequest ` object,
containing the exact bytes that will be sent to the server.
Instances are generated from a :class:`Request ` object, and
should not be instantiated manually; doing so may produce undesirable
effects.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> r = req.prepare()
>>> r
>>> s = requests.Session()
>>> s.send(r)
rK r rL z CaseInsensitiveDict[str | bytes]rv z$RequestsCookieJar | CookieJar | None_cookies _t.BodyTyper r r zint | object | None_body_positionc v d | _ d | _ d | _ d | _ d | _ t | _ d | _ y r\ )r rL rv r r r1 r r r s rX r zPreparedRequest.__init__ s8
"_
"rZ Nc t d| }| j | | j || | j | | j | | j |||
| j
|| | j | y)z6Prepares the entire request with the given parameters.
_t.UriTypeN)r prepare_method prepare_urlprepare_headersprepare_cookies prepare_body prepare_auth
prepare_hooks) rV r rL rv r r_ r r r r r% s rX r zPreparedRequest.prepare s| <% F# f% W% W% $t, $$
5!rZ c " d| j dS )Nz?DK #rZ c dd l } |j | d j d } | S # |j $ r t w xY w)Nr T)uts46rf )idnarl ry IDNAError UnicodeError)hostr s rX _get_idna_encoded_hostz&PreparedRequest._get_idna_encoded_host sI ;;t4;077@D ~~ s "* A c
< t |t r|j d }n t | }|j }d|v r'|j j
d s|| _ y t | \ }}}}}}} |st d|d| d |st d|d t | s | j | }n |j
d
r t d |xs d } | r| d z
} | |z
} |r| d| z
} |sd
}t |t t f r t! | }|| j# | } nd } | r |r| d| }n| }t% t' || |d || f }|| _ y# t $ r}
t |
j d}
~
ww xY w# t $ r t d w xY w)z Prepares the given HTTP URL.utf8:httpNz Invalid URL z0: No scheme supplied. Perhaps you meant https://rO z: No host suppliedzURL has an invalid label.)*.rP @rN &)rh ri ry rQ lstriplower
startswithrL r r r. argsr/ r r r r r` r: r$ )
rV rL r schemer r portrR rT fragmentenetloc
enc_paramss
rX r zPreparedRequest.prepare_url s c5 !**V$Cc(C jjl
#:ciik 4 4V <DH &>Gn ;FD$dE8 sg &--0E4
|C72D EF F %
>2248 __Z
( 89 9 cMF$ $j F D fsEl +%f-F ,,V4JJ ':,/"*ffdBx%PQRg " & aff% % &&
> !<==
>s$ *E# .F # F,E>>FFc t | _ |r>|j D ]* }t | |\ }}|| j t | < , yy)z Prepares the given HTTP headers.N)r3 rv r r4 r )rV rv headerrt values rX r z PreparedRequest.prepare_headers3 sK +, !--/%f- $ e7< -d 34 * rZ c d}d}|s=|;d} t j |d }t |t
s|j
d }t |t xs t |d }|rt |t t
t t t f sw t | }|}t# |dd |j% | _ |r t- d |r t/ | | j0 d
< || _ yd | j0 d < || _ yt3 d
| } |r| j5 || \ }}n8| r6| j7 | }t |t8 st |t: rd}nd}| j= | |r d| j0 vr|| j0 d< || _ y# t $ r}t || d}~ww xY w# t t t f$ r d}Y 6w xY w# t( $ r t+ | _ Y 0w xY w)z"Prepares the given HTTP body data.Nzapplication/jsonF) allow_nan)requestrf re tellz1Streamed bodies and files are mutually exclusive.Content-LengthchunkedzTransfer-Encodingr z!application/x-www-form-urlencodedz content-typez Content-Type) complexjsondumpsrx r- rh ri rl r rk rQ r{ rz r r< TypeErrorAttributeErrorr getattrr r OSErrorobjectNotImplementedErrorr rv r r r` r rj prepare_content_lengthr )
rV r_ r r% r rw ve is_iterablelengthraw_datas
rX r z PreparedRequest.prepare_body> s ( .L
9"((? dE*{{7+ !x0MGD*4M z$eT5'0R S
"4 DtVT*63*.))+D' )G 1 01, ' 3T:H '+'9'9%'J$| ..x8D!$
3z$
7V'+ 'J ' ' - t||!C/; ^, s
9&r488
9 ~/CD
3 +1(D'3s; F
F2 %G F/
F**F/2G G G+*G+c |'t | }|rt | | j d< yy| j dvr,| j j d d| j d< yyy)z>Prepare Content-Length header based on request method and bodyNr )GETHEAD0)r< r rv r get)rV r r s rX r z&PreparedRequest.prepare_content_length sn t_F 2=V1D -.
KK . !12: .1DLL) * ;
/rZ c h |2t t t | j }t | r|nd}|r|t |t rt | dk( r t | }n t d| } || }| j j |j | j | j yy)z"Prepares the given HTTP auth data.Nrr z Callable[..., PreparedRequest])
r5 r rQ rL anyrh rz r| r __dict__updater r )rV r rL url_auth auth_handlerrs rX r z PreparedRequest.prepare_auth s <(c488)<=H "8}8$D $&3t9> ,d 3 $$Dd K T"A
MM ,
' ' 2 rZ c t |t j r|| _ nt | | _ t d| j }t
|| }||| j d< yy)a Prepares the given HTTP cookie data.
This function eventually generates a ``Cookie`` header from the
given cookies using cookielib. Due to cookielib's design, the header
will not be regenerated if it already exists, meaning this function
can only be called once for the life of the
:class:`PreparedRequest ` object. Any subsequent calls
to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
header is removed beforehand.
r> NCookie)rh r! r> r r' r r( rv )rV r cookies_jar
cookie_headers rX r z PreparedRequest.prepare_cookies s\ gy 2 2 3 #DM / 8DM;
6 )+t<
$%2DLL " %rZ c H |xs i }|D ] }| j ||| y)zPrepares the given hooks.N)r )rV r r s rX r z PreparedRequest.prepare_hooks s+
E ueEl 3 rZ r r r )r rK rL r rv Mapping[str, str | bytes] | Noner r r_ r r r r r r r r r r% r r r r r )r rK r r )r rQ r rQ )rL r r r r r )rv r r r r\ )r_ r r r r% r r r )r r r r )rP )r r rL r r r )r r r r )r r r r )r r r r r r r r r r r r r r r r r r r r] rZ rX r r x s (
O
--22
''''#& "!%48 " $ IM*. "" " 2 "
"
" " " G" (" "
":4 @ P
P P
Pd = KOL L(4Ld!Zd?d"Zd@d#Z dAd$Z
dBd%Z dCd&Z dCd'Z
dDd(ZedCd) ZedCd* ZedCd+ ZedEd, ZedFd- Ze dG dHd/ Ze dI dJd0 Z dG dKd1Zeed.d2f dLd3 Zeefd2d4 dMd5 Zed.d2f dNd6ZedOd7 ZedBd8 ZdPd9ZedQd: Z d=d;Z d=d<Z y2)RResponsezhThe :class:`Response ` object, which contains a
server's response to an HTTP request.
z bytes | Literal[False] | None_contentr _content_consumedPreparedRequest | None_nextrE status_codezCaseInsensitiveDict[str]rv r rawrQ rL rK encodingzlist[Response]historyreasonrB r zdatetime.timedeltaelapsedr r rA
connection)
r r# rv rL r& r% r' r r( r z list[str] __attrs__c d| _ d| _ d | _ d | _ t | _ d | _ d | _ d | _ g | _ d | _
t i | _ t j d | _ d | _ y )NFr )r r r" r# r3 rv r$ rL r% r& r' r' r datetime timedeltar( r r s rX r zResponse.__init__ s
!&
+,
+2. ))!, rZ c | S r\ r] r s rX __enter__zResponse.__enter__* s rZ c $ | j y r\ )close)rV r s rX __exit__zResponse.__exit__- s
rZ c | j s | j | j D ci c] }|t | |d c}S c c}w r\ )r contentr* r )rV attrs rX __getstate__zResponse.__getstate__0 s> %% LL<@NNKNDgdD$//NKKKs ?c |j D ] \ }}t | || t | dd t | dd y )Nr Tr$ )r setattr)rV statert r s rX __setstate__zResponse.__setstate__8 s= ;;=KD% D$ & ) )40eT"rZ c " d| j dS )Nz r s rX __nonzero__zResponse.__nonzero__M rA rZ c $ | j d S )z,Allows you to use a response as an iterator. ) iter_contentr s rX re zResponse.__iter__W s %%rZ c D | j y# t $ r Y yw xY w)ax Returns True if :attr:`status_code` is less than 400, False if not.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
FT)raise_for_statusr, r s rX r? z Response.ok[ s, ! ! # s c F d| j v xr | j t v S )zTrue if this Response is a well-formed HTTP redirect that could have
been processed automatically (by :meth:`Session.resolve_redirects`).
location)rv r# rC r s rX is_redirectzResponse.is_redirectj s#
T\\)Pd.>.>..PPrZ c z d| j v xr, | j t j t j fv S )z@True if this Response one of the permanent versions of redirect.rJ )rv r# r2 moved_permanentlypermanent_redirectr s rX is_permanent_redirectz Response.is_permanent_redirectq s? T\\)
d.>.> # # $ $C
/
rZ c | j S )zTReturns a PreparedRequest for the next request in a redirect chain, if there is one.)r" r s rX nextz
Response.nexty s zzrZ c T t "t j | j d S y)zOThe apparent encoding, provided by the charset_normalizer or chardet libraries.r% rf )r detectr4 r s rX apparent_encodingzResponse.apparent_encoding~ s' >>$,,/
; ; rZ Fc y r\ r] rV
chunk_sizedecode_unicodes rX rF zResponse.iter_content s rZ c y r\ r] rV s rX rF zResponse.iter_content s !$rZ c \ d fd } j r$t j t r
t (t t
st
dt d j r't t j }t | }n | }|r t | }|S )a Iterates over the response data. When stream=True is set on the
request, this avoids reading the content at once into memory for
large responses. The chunk size is the number of bytes it should
read into memory. This is not necessarily the length of each item
returned as decoding can take place.
chunk_size must be of type int or None. A value of None will
function differently depending on the value of `stream`.
stream=True will read data as it arrives in whatever size the
chunks are received. If stream=False, data is returned as
a single chunk.
If decode_unicode is True, content will be decoded using encoding
information from the response. If no encoding information is available,
bytes will be returned. This can be bypassed by manually setting
`encoding` on the response.
c 3 K t j d r. j j d E d { d_ y j j }|s d_ y | +7 8# t $ r} t | d } ~ wt
$ r} t
| d } ~ wt $ r} t | d } ~ wt $ r} t | d } ~ ww xY ww)NstreamT)decode_content)
rk r$ r\ r r) r r+ r r* r RequestsSSLErrorr~ r )r chunkrW rV s rX generatez'Response.iter_content..generate s txx* . #xxz$ OOO" &*D "
HHMM* 5E &*D " K P$ 2.q11" 2.q11' -)!,, .*1--.s\ C A6 A4A6 4C4A6 6 C? B
C B!! C- B88 C CCCz+chunk_size must be an int, it is instead a r )r z Generator[bytes, None, None]) r rh r r r0 rE r typer ri r8 r; )rV rW rX r` r4 chunkss `` rX rF zResponse.iter_content s * *. ! !j &E%' '
#Jz3,G=d:>N=OqQ
! !5$--0G *5F ZF 3FDAF
rZ Nc y r\ r] rV rW rX delimiters rX
iter_lineszResponse.iter_lines s rZ )re c y r\ r] rd s rX rf zResponse.iter_lines s !$rZ c # $ K d}| j || D ]k }|t d||z }|r|j | }n|j }|r&|d r!|r |d d |d k( r|j }nd}|E d{ m || yy7 w)a[ Iterates over the response data, one line at a time. When
stream=True is set on the request, this avoids reading the
content at once into memory for large responses.
The decode_unicode param works the same as in `iter_content`, with the
same caveats.
.. note:: This method is not reentrant safe.
N)rW rX z str | bytes)rF r split
splitlinespop)rV rW rX re pendingr_ liness rX rf zResponse.iter_lines s '+&&!. '
E " ]GeO< I. ((*rur2 %)1K ))+ #
& M
s A=B?B Bc | j du rg| j r t d | j dk( s | j d| _ n-dj | j
t xs d| _ d| _ | j S )z"Content of the response, in bytes.Fz2The content for this response was already consumedr NrZ T)r r RuntimeErrorr# r$ rU rF rG r s rX r4 zResponse.content sy ==E !%%"#WXX 1$(8 $
#):):;M)N O VSV
!% }} rZ c d}| j }| j sy| j | j } t | j |xs dd }|S # t t
f$ r t | j d }Y |S w xY w)a Content of the response, in unicode.
If Response.encoding is None, encoding will be guessed using
``charset_normalizer`` or ``chardet``.
The encoding of the response content is determined based solely on HTTP
headers, following RFC 2616 to the letter. If you can take advantage of
non-HTTP knowledge to make a better guess at the encoding, you should
set ``r.encoding`` appropriately before accessing this property.
NrP rf replace)errors)r% r4 rT rQ LookupErrorr )rV r4 r% s rX textz
Response.text s ==|| == --H :$,,(;GING Y' : $,,y9G :s A &A=<A=c 6 | j sk| j r_t | j dkD rGt | j }|0 t j
| j j
| fi |S t j
| j fi |S # t $ r Y ,t $ r0}t |j |j |j d}~ww xY w# t $ r0}t |j |j |j d}~ww xY w)aY Decodes the JSON response body (if any) as a Python object.
This may return a dictionary, list, etc. depending on what is in the response.
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
:raises requests.exceptions.JSONDecodeError: If the response body does not
contain valid json.
rs N)r% r4 r| r7 r loadsry UnicodeDecodeErrorr RequestsJSONDecodeErrormsgdocposru )rV kwargsr% r s rX r% z
Response.json? s }} #dll2Ca2G
&dll3H# G&,,T\\-@-@-JUfUU ? $$TYY9&9 9 *
& G1!%%FFG
? *!%%> > ?s6 .B 9 C C $C ,+CC D(+DDc | j j d }i }|r>t | }|D ]. }|j d xs |j d }|*|||< 0 |S )z8Returns the parsed header links of the response, if any.linkrelrL )rv r r9 )rV r resolved_linkslinksr keys rX r zResponse.linksb se !!&)46 &v.E hhuo8% ?*.N3'
rZ c d}t | j t r | j j d }n | j }d| j
cxk rdk r"n n | j
d| d| j }n6d| j
cxk rdk r!n n | j
d | d| j }|r
t ||
y # t $ r | j j d }Y w xY w) z+Raises :class:`HTTPError`, if one occurred.rP rf z
iso-8859-1i i z Client Error: z
for url: iX z Server Error: )responseN)rh r' ri ry rx r# rL r, )rV http_error_msgr' s rX rH zResponse.raise_for_statust s dkk5 )
: ++G4 [[F $"" (S (##$OF8:dhhZP
D$$
*s
*##$OF8:dhhZP
NT: : &
: ++L9
:s C $C*)C*c | j s| j j t | j dd }| | yy)zReleases the connection back to the pool. Once this method has been
called the underlying ``raw`` object must not be accessed again.
*Note: Should not normally need to be called explicitly.*
release_connN)r r$ r1 r )rV r s rX r1 zResponse.close s= %% HHNN txx > # N $rZ r )r r? )r r r r )r dict[str, Any])r9 r r r r )r r )r Iterator[bytes])r r! )r rK )r F)rW
int | NonerX Literal[False]r r )r )rW r rX
Literal[True]r Iterator[str | bytes])rW r rX r r r )rW rE rX r re z bytes | Noner r )rW rE rX r re str | bytes | Noner r )rW rE rX r re r r r )r ri )r} r r r )r zdict[str, dict[str, str]]) r r r r r r* r r/ r2 r6 r: r r@ rC re r r? rK rO rQ rT r rF rH rf r4 ru r% r rH r1 r] rZ rX r r s ,+ !!
%% H H
K
Iy - ^L#2& Q Q
KP $ :H '($$$=J$ $ $ BG=$=:>= =~ *)."& '
*$
)- $$ & $
& $
$ $ * $(, && & & &
&P $ # #J!?F ";: rZ r )lr
__future__r r, encodings.idna encodingscollections.abcr r r r r ior typingr
r r r
r r urllib3.exceptionsr r r r r urllib3.fieldsr urllib3.filepostr urllib3.utilr _internal_utilsr r r@ r rj r r compatr r r r r! r" r# r$ r% r r r& r' r(
exceptionsr) r* r+ r, r- r. r/ r0 ry r^ r r1 status_codesr2
structuresr3 utilsr4 r5 r6 r7 r8 r9 r: r; r< r= http.cookiejarr> typing_extensionsr? rP _tadaptersrA rB movedfoundothertemporary_redirectrN rC r rF rG rH rJ r r r r r] rZ rX r sJ #
L L # ( 6 " ? 1 (
C 4 + (& %*
KK KK KK *& ! # C # O" O"d 8Z Zz_4*,= _4D B BrZ PK ! -s| | $ __pycache__/sessions.cpython-312.pycnu [
9r*jȅ B d Z ddlmZ ddlZddlZddlZddlmZ ddlm Z m
Z
m Z ddl m
Z
ddlmZmZmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lm Z m Z m Z ddl m Z m!Z!m"Z"m#Z# ddl$m%Z%m&Z&m'Z'm(Z( ddl)m*Z*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3 ddl4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@ erddlAmBZB ddlCmDZDmEZE ddlFmZG ddlmHZH ej dk( r
ej ZKn ej
ZKef d!dZLef d"dZM G d d ZN G d d eN ZOd#d ZPy)$z
requests.sessions
~~~~~~~~~~~~~~~~~
This module provides a Session object to manage and persist settings across
requests (cookies, auth, proxies).
) annotationsN) OrderedDict) GeneratorMappingMutableMapping) timedelta)
TYPE_CHECKINGAnycast )to_native_string) is_prepared) HTTPAdapter)_basic_auth_str) cookieliburljoinurlparse)RequestsCookieJarcookiejar_from_dictextract_cookies_to_jar
merge_cookies)ChunkedEncodingErrorContentDecodingError
InvalidSchemaTooManyRedirects)
default_hooks
dispatch_hook)DEFAULT_REDIRECT_LIMITREDIRECT_STATIPreparedRequestRequestResponse)codes)CaseInsensitiveDict)
DEFAULT_PORTSdefault_headersget_auth_from_urlget_environ_proxiesget_netrc_auth requote_uriresolve_proxies rewind_bodyshould_bypass_proxiesto_key_val_list) CookieJar)SelfUnpack)_types) BaseAdapterwin32c || S | |S t |t rt | t s| S |t | }|j t | |j D cg c]
\ }}| | }}}|D ] }||= |S c c}}w )zDetermines appropriate setting for a given request, taking into account
the explicit setting on that request, and the setting in the session. If a
setting is a dictionary, they will be merged together using `dict_class`
)
isinstancer r. updateitems)request_settingsession_setting
dict_classmerged_settingkv none_keyskeys @/opt/hc_python/lib/python3.12/site-packages/requests/sessions.py
merge_settingrB L s ?G,OW1U @AN//:; "0!5!5!7E!7v119!7IE 3 Fs )
B4Bc | ||j d g k( r| S | | j d g k( r|S t | || S )zProperly merges both requests and session hooks.
This is necessary because when request_hooks == {'response': []}, the
merge breaks Session hooks entirely.
response)getrB )
request_hooks
session_hooksr; s rA merge_hooksrH l sO
1 1* = C
1 1* = C
z BB c e Zd ZU ded< ded< ded< ddZddZdd Z d dd Z dd Z dd
Z ddZ
y
)SessionRedirectMixinint
max_redirectsbool trust_envr cookiesc y N )selfrequestkwargss rA sendzSessionRedirectMixin.send s rI c t |j r,|j d }|j d }t |d S y)z7Receives a Response. Returns a redirect URI or ``None``locationlatin1utf8N) is_redirectheadersencoder
)rT resprY s rA get_redirect_targetz(SessionRedirectMixin.get_redirect_target s; ||J/H x0H#Hf5 5rI c t | }t | }|j |j k7 ry|j dk( r,|j dv r |j dk( r|j dv ry|j |j k7 }|j |j k7 }t j
|j d df}|s |j |v r|j |v ry|xs |S )zFDecide whether Authorization header should be removed when redirectingThttp)P Nhttps)i NFN)r hostnameschemeportr% rE )rT old_urlnew_url
old_parsed
new_parsed changed_portchanged_scheme default_ports rA should_strip_authz&SessionRedirectMixin.should_strip_auth s g&
g&
*"5"5 5
':-!!W,;. "*//9 #**j.?.??%))**;*;TBDI </</ -~-rI Nc
+ K g }
| j | } t |j j } | r|j }
|
dd |_ |
j
| |j t |j
| j k\ rt d| j d| |j! | j# d r;t |j }dj% t' |j( | g } t | }|j d k( r| r|j+ |
}n|j r |j } |j- } |j. s t1 |j t3 | } n t3 | } t' | |
_ | j5 |
| |j6 t8 j: t8 j< fvr,d }|D ] }|
j> jA |d d|
_! |
j> }|jA d d tE d
|
jF }tI |||j tK || jL |
jO | | jQ |
| }| jS |
| |
jT duxr
d|v xs d|v }|r tW |
|
}|r| nP | jX |f|||||dd| }tI | jL |
|j | j | } | | ryy# t t t f$ r |j j d Y w xY ww)zBReceives a Response. Returns a generator of Responses or Requests.NF)decode_contentz Exceeded z redirects.)rD z//: )fragment)Content-Lengthz Content-TypeTransfer-EncodingCookier/ ru rv )streamtimeoutverifycertproxiesallow_redirects)-r` r urlrt copyhistoryappendcontentr r RuntimeErrorrawreadlenrM r close
startswithjoinr
rf _replacegeturlnetlocr r* rebuild_method status_coder# temporary_redirectpermanent_redirectr] popbodyr _cookiesr r rP prepare_cookiesrebuild_proxies rebuild_auth_body_positionr, rW )rT r_ reqrx ry rz r{ r| yield_requestsadapter_kwargshistr~ previous_fragmentprepared_request parsed_rurlparsedpurged_headersheaderr]
cookie_jar
rewindables rA resolve_redirectsz&SessionRedirectMixin.resolve_redirects s) "&&t, $SWW - 6 6 "xxz 7DL KK
4 4<< D$6$66& 2 2 3;?$
JJL ~~d# &txx 0 hh 01C1C Dc JK c]F"$): 2C D $*OO!--/C
== dhh C(89!#C#8 0$ 7 (((((
"Y ,F$,,00> -(, %&..G KK$ '
k+;+D+DEJ ":sDHH = *dll 3 , ,Z 8 **+;WEG . 5
*88D G+M/Bg/M
,- #C tyy ! #! #$) % 't||5EtxxP ..t4
O )*> M
4
U
3
4s1 A!M$$ L- 0J9M$+M$-0M! M$ M!!M$c $ |j }t | sJ t | sJ |j }|j }|j }d|v r| j || r|d= | j
r t
| nd}||j | yy)zWhen being redirected we may want to strip authentication from the
request to avoid leaking credentials. This method intelligently removes
and reapplies authentication where possible to avoid credential loss.
AuthorizationN)rU _is_preparedr] r~ ro rO r) prepare_auth)rT r rD original_requestr] original_urlr~ new_auths rA r z!SessionRedirectMixin.rebuild_auth5 s $++ ,--- ,---"**'++ "" g %$*@*@ s*S ( +/..>#&d ) )( 3 rI c F t | sJ |j }t |j j }t ||| j }d|v r|d= t || \ }}|j d s|r|rt || |d< |S # t $ r d\ }}Y 6w xY w)a This method re-evaluates the proxy configuration by considering the
environment variables. If we are redirected to a URL covered by
NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
proxy keys for this URL (in case they were stripped by a previous
redirect).
This method also replaces the Proxy-Authorization header where
necessary.
:rtype: dict
zProxy-AuthorizationNNrd ) r r] r r~ rf r+ rO r' KeyErrorr r )rT r r| r] rf new_proxiesusernamepasswords rA r z$SessionRedirectMixin.rebuild_proxiesN s ,---"***../66%&6 P G +-. ,!2;v3F!G Hh )h8-d+Zd0d,Zd?d-Zd@d.ZdAd/Zy )BSessiona A Requests session.
Provides cookie persistence, connection-pooling, and configuration.
Basic Usage::
>>> import requests
>>> s = requests.Session()
>>> s.get('https://httpbin.org/get')
Or as a context manager::
>>> with requests.Session() as s:
... s.get('https://httpbin.org/get')
zCaseInsensitiveDict[str]r] _t.AuthTypeauthr r| z dict[str, list[_t.HookType]]hookszMutableMapping[str, Any]paramsrN rx r rz r r{ rL rM rO r rP z MutableMapping[str, BaseAdapter]adapters) r] rP r r| r r rz r{ r rx rO rM z list[str] __attrs__c ^ t | _ d | _ i | _ t | _ i | _ d| _ d| _ d | _ t | _ d| _ t i | _ t | _ | j# dt% | j# dt% y )NFTzhttps://zhttp://)r& r] r r| r r r rx rz r{ r rM rO r rP r r mountr rT s rA __init__zSession.__init__ s '(
#_
4 +2. $
:{}-
9km,rI c | S rR rS r s rA __enter__zSession.__enter__ s rI c $ | j y rR )r )rT argss rA __exit__zSession.__exit__ s
rI c t d|j }t t |j }|j xs i }t |t j s t | }t t t | j | }|j }| j r|s| j s t | }t }|j |j! ||j" |j$ |j& t) |j* | j* t, t) |j. | j. t) || j |t1 |j2 | j2
|S )a Constructs a :class:`PreparedRequest ` for
transmission and returns it. The :class:`PreparedRequest` has settings
merged from the :class:`Request ` instance and those of the
:class:`Session`.
:param request: :class:`Request` instance to prepare with this
session's settings.
:rtype: requests.PreparedRequest
_t.UriType)r; )
r r~ filesdatajsonr] r r rP r )r r~ r r rP r6 r r/ r r r r rO r) r prepareupperr r r rB r] r$ r rH r )rT rU r~ r rP merged_cookiesr ps rA prepare_requestzSession.prepare_request s" <-c7>>*//'R '9#6#67)'2G ' +-t|| >$tyy!#&D <<>-- ! :M ! = tTYY/" gmmTZZ8
rI Nc v t |t r|j d }t |j ||||xs i ||xs i |||
}| j | }t
| sJ | xs i } | j |j | |
|| }| |
d}|j | | j |fi |}|S )a
Constructs a :class:`Request `, prepares it and sends it.
Returns :class:`Response ` object.
:param method: method for the new :class:`Request` object.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary or bytes to be sent in the query
string for the :class:`Request`.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) json to send in the body of the
:class:`Request`.
:param headers: (optional) Dictionary of HTTP Headers to send with the
:class:`Request`.
:param cookies: (optional) Dict or CookieJar object to send with the
:class:`Request`.
:param files: (optional) Dictionary of ``'filename': file-like-objects``
for multipart encoding upload.
:param auth: (optional) Auth tuple or callable to enable
Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds to wait for the server to send
data before giving up, as a float, or a :ref:`(connect timeout,
read timeout) ` tuple.
:type timeout: float or tuple
:param allow_redirects: (optional) Set to True by default.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol or protocol and
hostname to the URL of the proxy.
:param hooks: (optional) Dictionary mapping hook name to one event or
list of events, event must be callable.
:param stream: (optional) whether to immediately download the response
content. Defaults to ``False``.
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use. Defaults to ``True``. When set to
``False``, requests will accept any TLS certificate presented by
the server, and will ignore hostname mismatches and/or expired
certificates, which will make your application vulnerable to
man-in-the-middle (MitM) attacks. Setting verify to ``False``
may be useful during local development or testing.
:param cert: (optional) if String, path to ssl client cert file (.pem).
If Tuple, ('cert', 'key') pair.
:rtype: requests.Response
zutf-8)
r r~ r] r r r r r rP r )ry r} ) r6 bytesdecoder! r r r merge_environment_settingsr~ r7 rW )rT r r~ r r r] rP r r ry r} r| r rx rz r{ r r prepsettings send_kwargsr_ s rA rU zSession.request- s | c5 !**W%C <<>t>v>>rI c * | j d|fi |S )zSends a DELETE request. Returns :class:`Response` object.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:rtype: requests.Response
DELETEr r s rA deletezSession.delete s t||Hc4V44rI c |j d| j |j d| j |j d| j d|vr$t || j
| j |d< t |t r t d t | sJ |j dd }|j d }|j }| j |j }t! } |j" |fi |}t! |z
} t% | |_ t) d
||fi |}|j* r<|j* D ]- }
t- | j. |
j0 |
j2 / t- | j. ||j2 |r$ | j4 ||fi |} | D
cg c] }
|
} }
ng } | r)| j7 d | | j }| |_ |s% t9 | j4 ||fd di| |_ |s |j> |S c c}
w # t< $ r Y w xY w)
zISend a given PreparedRequest.
:rtype: requests.Response
rx rz r{ r| z#You can only send PreparedRequests.r} T)r~ )secondsrD r r ) r rx rz r{ r+ r| rO r6 r!
ValueErrorr r rE r get_adapterr~ preferred_clockrW r elapsedr r r rP rU r r insertnext_next
StopIterationr )
rT rU rV r} rx r adapterstartrr r_ genr s
rA rW z Session.send s (DKK0(DKK0&$)), F " / t~~ VF9 gw ' BC CG$$$ !**%6=H%
""w{{"3 !
GLL +F + "#e+ g.
*eQ 9& 9
99 &t||T\\488L " t||Waee< ($((G>v>C(+,tG,G NN1a
A AI
*D**1gUdUfU
II1 -$ !
s < H,8$H1 1 H=<H=c | j r||j d nd}t || }|*|j D ] \ }} |j || |du s|Dt
j j d xs# t
j j d xs |}t || j }t || j }t || j }t || j }||||dS )z^
Check the environment and merge it with some settings.
:rtype: dict
Nno_proxy)r TREQUESTS_CA_BUNDLECURL_CA_BUNDLE)r| rx rz r{ ) rO rE r( r8 r osenvironrB r| rx rz r{ )
rT r~ r| rx rz r{ r env_proxiesr= r> s
rA r z"Session.merge_environment_settings? s >>292Ew{{:.4H-cHEK" ' - - /DAq&&q!, 0
~ JJNN#78 zz~~&67 6 vt{{3 vt{{3 T499-"fPTUUrI c | j j D ]6 \ }}|j j |j s4|c S t d| )z~
Returns the appropriate connection adapter for the given URL.
:rtype: requests.adapters.BaseAdapter
z&No connection adapters were found for )r r8 lowerr r )rT r~ prefixr s rA r zSession.get_adapterf sS $}} 2 2 4OFGyy{%%flln5 5
DSG LMMrI c b | j j D ] }|j y)z+Closes all adapters and as such the sessionN)r valuesr )rT r> s rA r z
Session.closes s" %%'A
GGI (rI c || j |< | j D cg c] }t | t | k s| }}|D ]* }| j j | | j |< , yc c}w )zwRegisters a connection adapter to a prefix.
Adapters are sorted in descending order by prefix length.
N)r r r )rT r r r= keys_to_mover@ s rA r z
Session.mountx sf
!(
f #'==I=aCFS[4H= I C!% !2!23!7DMM# Js
A1A1c Z | j D ci c] }|t | |d }}|S c c}w rR )r getattr)rT attrstates rA __getstate__zSession.__getstate__ s3 =A^^L^TwtT400^L Ms (c N |j D ] \ }}t | || y rR )r8 setattr)rT r r values rA __setstate__zSession.__setstate__ s" ;;=KD% D$ & )rI )r r )r r0 )r r
r r )rU r! r r )NNNNNNNTNNNNNN)"r r r~ r r
_t.ParamsTyper _t.DataTyper] z_t.HeadersTyperP z5RequestsCookieJar | CookieJar | dict[str, str] | Noner z _t.FilesTyper r ry r r} rN r| r r z_t.HooksInputType | Nonerx bool | Nonerz _t.VerifyType | Noner{ r r _t.JsonTyper r" rR )r~ r r r$ rV zUnpack[_t.GetKwargs]r r" )r~ r rV zUnpack[_t.RequestKwargs]r r" r )
r~ r r r% r r( rV zUnpack[_t.PostKwargs]r r" )r~ r r r% rV zUnpack[_t.DataKwargs]r r" r ) r~ r r| r rx r& rz r' r{ r r dict[str, Any])r~ r r r3 )r r r r3 r r )r r) )r r) r r )r r r __doc__r r r r r r rU rE r r r r r r rW r r r r r r# rS rI rA r r s $ &%
'' $$ L
O
..
Iy
=-~,d !% "&IM " "& $)-*. "'+ #`` ` `
`
` G` ` ` ` ` '` (` ` % ` !`" #`$
%`J !%A
A A ' A
A$ 6 3 ! I
I I I
( I
I( 48 = =%0 =CX = = 48 ? ?%0 ?CX ? ? 5M^%V
%V '%V %V
% %V
%V
%VN N
8'rI r c t S )aZ
Returns a :class:`Session` for context-management.
.. deprecated:: 1.0.0
This method has been deprecated since version 1.0.0 and is only kept for
backwards compatibility. New code should use :class:`~requests.sessions.Session`
to create a session. This may be removed at a future date.
:rtype: Session
)r rS rI rA sessionr, s 9rI )r9 r
r: r
r; typer r
)rF _t.HooksTyperG r. r; r- r r. )r r )Qr*
__future__r r systime collectionsr collections.abcr r r datetimer typingr r
r _internal_utilsr
r2 r r r r r r compatr r r rP r r r r
exceptionsr r r r r r r modelsr r r r! r" status_codesr#
structuresr$ utilsr% r& r' r( r) r* r+ r, r- r. http.cookiejarr/ typing_extensionsr0 r1 rs _tr3 platform perf_counterr rB rH rK r r, rS rI rA rB s+ #
# > > + + - / ! ! 0 0 0 + (. % <<7''OiiO DO +. <@ F #C C C C C&I) I)X~'" ~'B rI PK ! +An n # __pycache__/cookies.cpython-312.pycnu [
9r*j-T d Z ddlmZ ddlZddlZddlZddlmZmZ ddl m
Z
m Z m Z ddl
mZmZmZmZ ddlmZ dd lmZ dd
lmZmZmZmZ er dd l m Z dd l m Z ddl Z G d
d Z! G d d Z" d!dZ#d"dZ$ d# d$dZ% G d de& Z' G d de ee(e(dz f Z)d%dZ*d&dZ+d'dZ, ede Z-e d( d)d Z.e d* d+d Z. d( d,d Z. d-d Z/y).z
requests.cookies
~~~~~~~~~~~~~~~~
Compatibility code to be able to use `http.cookiejar.CookieJar` with requests.
requests.utils imports from here, so be careful with imports.
) annotationsN)IteratorMutableMapping)Cookie CookieJar CookiePolicy)
TYPE_CHECKINGAnyTypeVaroverload )to_native_string) is_prepared)Morsel cookieliburlparse
urlunparse)SupportsKeysAndGetItem)PreparedRequestc e Zd ZU dZded< ddZddZddZddZddZ dd Z
dd
Z ddd Z dd
Z
ddZddZedd Zedd Zedd Zy ) MockRequesta Wraps a `requests.PreparedRequest` to mimic a `urllib2.Request`.
The code in `http.cookiejar.CookieJar` expects this interface in order to correctly
manage cookie policies, i.e., determine whether a cookie can be set, given the
domains of the request and the cookie.
The original request object is read-only. The client is responsible for collecting
the new headers via `get_new_headers()` and interpreting them appropriately. You
probably want `get_cookie_header`, defined below.
strtypec t | sJ || _ i | _ t | j j j
| _ y N) _is_prepared_r _new_headersr urlschemer )selfrequests ?/opt/hc_python/lib/python3.12/site-packages/requests/cookies.py__init__zMockRequest.__init__- s9 G$$$,. TWW[[)00 c | j S r )r r! s r# get_typezMockRequest.get_type3 s yyr% c T t | j j j S r )r r r netlocr' s r# get_hostzMockRequest.get_host6 s $+++r% c " | j S r r+ r' s r# get_origin_req_hostz MockRequest.get_origin_req_host9 s }} r% c | j j j d s| j j S t | j j d d }t | j j }t
|j ||j |j |j |j g S )NHostzutf-8)encoding) r headersgetr r r r r pathparamsqueryfragment)r! hostparseds r# get_full_urlzMockRequest.get_full_url< s ww""6*77;; 7'J$''++&
r% c yNT r' s r# is_unverifiablezMockRequest.is_unverifiableP s r% c R || j j v xs || j v S r )r r2 r r! names r#
has_headerzMockRequest.has_headerS s% tww&C$$2C2C*CCr% Nc | j j j || j j || S r )r r2 r3 r )r! rA defaults r#
get_headerzMockRequest.get_headerV s0 ww""4):):)>)>tW)MNNr% c t d )zMcookiejar has no legitimate use for this method; add it back if you find one.z=Cookie headers should be added with add_unredirected_header())NotImplementedError)r! keyvals r#
add_headerzMockRequest.add_headerY s ! K
r% c " || j |< y r r r! rA values r# add_unredirected_headerz#MockRequest.add_unredirected_header_ s "'$ r% c | j S r rL r' s r# get_new_headerszMockRequest.get_new_headersb s r% c " | j S r )r> r' s r# unverifiablezMockRequest.unverifiablee s ##%%r% c " | j S r )r. r' s r# origin_req_hostzMockRequest.origin_req_hosti s ''))r% c " | j S r r- r' s r# r8 zMockRequest.hostm s }} r% )r" r returnNone)rW r rW bool)rA r rW rZ r )rA r rD
str | NonerW r[ )rH r rI r rW rX )rA r rN r rW rX )rW zdict[str, str])__name__
__module__ __qualname____doc____annotations__r$ r( r+ r. r: r> rB rE rJ rO rQ propertyrS rU r8 r= r% r# r r s I1 ,
(DO
(! & & * * r% r c ( e Zd ZdZddZddZddZy) MockResponsezWraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
...what? Basically, expose the parsed HTTP headers from the server response
the way `http.cookiejar` expects to see them.
c || _ y)zMake a MockResponse for `cookiejar` to read.
:param headers: a httplib.HTTPMessage or analogous carrying the headers
N_headers)r! r2 s r# r$ zMockResponse.__init__y s
r% c | j S r re r' s r# infozMockResponse.info s }} r% c : | j j | y r )rf
getheadersr@ s r# rj zMockResponse.getheaders s
&r% N)r2 r
rW rX )rW r
)rA r rW r
)r\ r] r^ r_ r$ rh rj r= r% r# rc rc r s 'r% rc c t |d r |j syt | }t |j j }| j || y)zExtract the cookies from the response into a CookieJar.
:param jar: http.cookiejar.CookieJar (not necessarily a RequestsCookieJar)
:param request: our own requests.Request object
:param response: urllib3.HTTPResponse object
_original_responseN)hasattrrl r rc msgextract_cookies)jarr" responsereqress r# extract_cookies_to_jarrt sJ
H 2 38S8S
g
C
x2266
7CS!r% c x t | }| j | |j j d S )zj
Produce an appropriate Cookie header string to be sent with `request`, or None.
:rtype: str
r )r add_cookie_headerrQ r3 )rp r" rs r# get_cookie_headerrx s6 G A! " "8 ,,r% c g }| D ]h }|j |k7 r|||j k7 r%|||j k7 r7|j |j |j |j f j |D ] \ }}}| j ||| y)zkUnsets a cookie by name, by default over all domains and paths.
Wraps CookieJar.clear(), is O(n).
N)rA domainr4 appendclear) cookiejarrA rz r4
clearablescookies r# remove_cookie_by_namer s .0J ;;$ &FMM"9 3 6==&++v{{CD )dd+ )r% c e Zd ZdZy)CookieConflictErrorzThere are two cookies that meet the criteria specified in the cookie jar.
Use .get and .set and include domain and path args in order to be more specific.
N)r\ r] r^ r_ r= r% r# r r s r% r c l e Zd ZU dZded< d d dZ d dZd dZd!dZd"dZ d#d Z
d$d
Z d%d Z d!d Z
d!d
Zd&dZ d' d(dZd) fd Zd* fd Zd+dZ d,dZd-dZd. fd Z d/ fd Z d' d0dZ d' d1dZd2dZd3dZd4dZ d5d Z xZ S )6RequestsCookieJara Compatibility class; is a http.cookiejar.CookieJar, but exposes a dict
interface.
This is the CookieJar we create by default for requests and sessions that
don't specify one, since some clients may expect response.cookies and
session.cookies to support dict operations.
Requests does not use the dict interface internally; it's just for
compatibility with external client code. All requests code should work
out of the box with externally provided instances of ``CookieJar``, e.g.
``LWPCookieJar`` and ``FileCookieJar``.
Unlike a regular CookieJar, this class is pickleable.
.. warning:: dictionary operations that are normally O(1) may be O(n).
r _policyc L | j ||| S # t $ r |cY S w xY w)zDict-like get() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
.. warning:: operation is O(n), not O(1).
)_find_no_duplicatesKeyError)r! rA rD rz r4 s r# r3 zRequestsCookieJar.get s0 ++D&$? ? N s ##c |.t | ||j d |j d yt |t r t | }n
t ||fi |}| j
| |S )zDict-like set() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
Nrz r4 )rz r4 )r r3
isinstancer morsel_to_cookie
create_cookie
set_cookie)r! rA rN kwargscs r# setzRequestsCookieJar.set sg = !d6::h#7fjj>P
eV $ 'A dE4V4A r% c # H K t | D ] }|j yw)zDict-like iterkeys() that returns an iterator of names of cookies
from the jar.
.. seealso:: itervalues() and iteritems().
N)iterrA r! r s r# iterkeyszRequestsCookieJar.iterkeys s 4jF++ ! "c 4 t | j S )zDict-like keys() that returns a list of names of cookies from the
jar.
.. seealso:: values() and items().
)listr r' s r# keyszRequestsCookieJar.keys s DMMO$$r% c # H K t | D ] }|j yw)zDict-like itervalues() that returns an iterator of values of cookies
from the jar.
.. seealso:: iterkeys() and iteritems().
N)r rN r s r#
itervaluesz RequestsCookieJar.itervalues s 4jF,, !r c 4 t | j S )zDict-like values() that returns a list of values of cookies from the
jar.
.. seealso:: keys() and items().
)r r r' s r# valueszRequestsCookieJar.values s DOO%&&r% c # ` K t | D ] }|j |j f yw)zDict-like iteritems() that returns an iterator of name-value tuples
from the jar.
.. seealso:: iterkeys() and itervalues().
N)r rA rN r s r# iteritemszRequestsCookieJar.iteritems s) 4jF++v||+ + !s ,.c 4 t | j S )zDict-like items() that returns a list of name-value tuples from the
jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
vanilla python dict of key value pairs.
.. seealso:: keys() and values().
)r r r' s r# itemszRequestsCookieJar.items% s DNN$%%r% c ~ g }t | D ], }|j |vs|j |j . |S )z2Utility method to list all the domains in the jar.r rz r{ r! domainsr s r# list_domainsz RequestsCookieJar.list_domains. s8 4jF}}G+v}}- ! r% c ~ g }t | D ], }|j |vs|j |j . |S )z0Utility method to list all the paths in the jar.)r r4 r{ )r! pathsr s r#
list_pathsz RequestsCookieJar.list_paths6 s8 4jF{{%' V[[) ! r% c g }t | D ]9 }|j |j |v r y|j |j ; y)zvReturns True if there are multiple domains in the jar.
Returns False otherwise.
:rtype: bool
TFr r s r# multiple_domainsz"RequestsCookieJar.multiple_domains> sD 4jF}}(V]]g-E NN6== ) ! r% c i }t | D ]? }||j |k( s||j |k( s'|j ||j < A |S )zTakes as an argument an optional domain and path and returns a plain
old Python dict of name-value pairs of cookies that meet the
requirements.
:rtype: dict
)r rz r4 rN rA )r! rz r4
dictionaryr s r# get_dictzRequestsCookieJar.get_dictK sQ -/
4jF&--6"9 t 3*0,,
6;;' !
r% c t | S )zDRequestCookieJar's __iter__ comes from CookieJar not MutableMapping.)super__iter__)r! __class__s r# r zRequestsCookieJar.__iter__\ s w !!r% c B t | | S # t $ r Y yw xY wr< )r __contains__r )r! rA r s r# r z RequestsCookieJar.__contains__` s* 7'- -" s c $ | j | S )zDict-like __getitem__() for compatibility with client code. Throws
exception if there are more than one cookie with name. In that case,
use the more explicit get() method instead.
.. warning:: operation is O(n), not O(1).
)r r@ s r# __getitem__z RequestsCookieJar.__getitem__f s ''--r% c ( | j || y)zDict-like __setitem__ for compatibility with client code. Throws
exception if there is already a cookie of that name in the jar. In that
case, use the more explicit set() method instead.
N)r rM s r# __setitem__z RequestsCookieJar.__setitem__o s
u r% c t | | y)zqDeletes a cookie given a name. Wraps ``http.cookiejar.CookieJar``'s
``remove_cookie_by_name()``.
N)r r@ s r# __delitem__z RequestsCookieJar.__delitem__x s dD)r% c |j x}9|j d r(|j d r|j dd |_ t | |g|i |S )N"z\" )rN
startswithendswithreplacer r )r! r argsr rN r s r# r z RequestsCookieJar.set_cookie~ sX ll
"U / %s# ==3FLw!&:4:6::r% c t |t j r,|D ]& }| j t j | ( yt
| | y)zAUpdates this jar with cookies from another CookieJar or dict-likeN)r r r r copyr update)r! otherr r s r# r zRequestsCookieJar.update sB eY 0 0 1 & 12
GN5 !r% c t | D ]C }|j |k( s||j |k( s%||j |k( s7|j c S t d|d|d| )a Requests uses this method internally to get cookie values.
If there are conflicting cookies, _find arbitrarily chooses one.
See _find_no_duplicates if you want an exception thrown if there are
conflicting cookies.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:return: cookie.value
name= , domain=, path=)r rA rz r4 rN r )r! rA rz r4 r s r# _findzRequestsCookieJar._find sh 4jF{{d">V]]f%<|v{{d': %||+ ! thizIJJr% c d}t | D ]R }|j |k( s||j |k( s%||j |k( s7|t d| |j
}T ||S t
d|d|d| )a Both ``__get_item__`` and ``get`` call this function: it's never
used elsewhere in Requests.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:raises KeyError: if cookie is not found
:raises CookieConflictError: if there are multiple cookies
that match name and optionally domain and path
:return: cookie.value
Nz&There are multiple cookies with name, r r r )r rA rz r4 r rN r )r! rA rz r4 toReturnr s r# r z%RequestsCookieJar._find_no_duplicates s 4jF{{d">V]]f%<|v{{d':#/"5"H Q# $*<< ! OthizIJJr% c \ | j j }|j d |S )4Unlike a normal CookieJar, this class is pickleable.
_cookies_lock)__dict__r popr! states r# __getstate__z RequestsCookieJar.__getstate__ s%
""$
/" r% c | j j | d| j vrt j | _ yy)r r N)r r threadingRLockr r s r# __setstate__z RequestsCookieJar.__setstate__ s4
U# $-- /!* !2D 0r% c z t }|j | j |j | |S )z(Return a copy of this RequestsCookieJar.)r
set_policy
get_policyr )r! new_cjs r# r zRequestsCookieJar.copy s0 "$$//+,
d
r% c | j S )z&Return the CookiePolicy instance used.)r r' s r# r z RequestsCookieJar.get_policy s ||r% )NNN)
rA r rD r[ rz r[ r4 r[ rW r[ )rA r rN #str | Morsel[dict[str, str]] | Noner r
rW z
Cookie | None)rW z
Iterator[str])rW z list[str])rW zIterator[str | None])rW zlist[str | None])rW z Iterator[tuple[str, str | None]])rW z list[tuple[str, str | None]]rY NN)rz r[ r4 r[ rW zdict[str, str | None])rW zIterator[Cookie])rA objectrW rZ )rA r rW r[ )rA r rN r rW rX )rA r rW rX )r r r r
r r
rW rX )r z,CookieJar | SupportsKeysAndGetItem[str, str]rW rX )rA r rz r[ r4 r[ rW r[ )rA r rz r[ r4 r[ rW r )rW dict[str, Any])r r rW rX )rW r )rW r ) r\ r] r^ r_ r` r3 r r r r r r r r r r r r r r r r r r r r r r r r
__classcell__)r s @r# r r s "
# !
$ COR * % ',& =A /9 "" . C
* ;"A"
" HLKK!+K:DK K. HL K K!+ K:D K K>3 r% r c | y t | dd x}r | S t j | }|j | D ]& }|j t j | ( |S )Nr )getattrr r| r )rp copy_methodnew_jarr s r# _copy_cookie_jarr sb
{ c6400{0} iinG MMO499V,- Nr% c f d| |ddddddddddidd
}t | t | z
}|rt d t | |j | t |d
|d < t |d |d
< |d j d |d< t |d |d< t
j di |S )zMake a cookie from underspecified parameters.
By default, the pair of `name` and `value` will be set for the domain ''
and sent on every request (this is sometimes called a "supercookie").
r Nr /FTHttpOnly)
versionrA rN portrz r4 secureexpiresdiscardcomment comment_urlrestrfc2109z2create_cookie() got unexpected keyword arguments: r port_specifiedrz domain_specified.domain_initial_dotr4 path_specifiedr= )r TypeErrorr r rZ r r r )rA rN r resultbadargss r# r r s T" F &kCK'G@g P
MM& #F6N 3F !%fX&6!7F #)(#3#>#>s#CF #F6N 3F %f %%r% c d}| d r. t t j t | d z }n3| d r.d}t j
t j | d | }t | d t | d d| d || j | d
dd | d idt | d
| j | d xs d
S # t $ r t d| d d w xY w)zBConvert a Morsel object into a Cookie containing the one k/v pair.Nzmax-agez max-age: z must be integerr z%a, %d-%b-%Y %H:%M:%S GMTr Frz r4 r httponlyr r r )
r r r rz r rA r4 r r r r rN r ) inttime
ValueErrorr calendartimegmstrptimer rZ rH rN )morselr
time_templates r# r r s G
i M$))+F9,=(>>?G
3
//$--y0A="QR y! *+h
ZZ
F^
&,
-F8$%lly!&Q Miy(9'::J KL L Ms ,C C _CookieJarT)boundc y r r= cookie_dictr} overwrites r# cookiejar_from_dictr 3 s
r% c y r r= r s r# r r ; s
r% c |
t }| E|D cg c] }|j }}| D ]' }|s||vs
|j t || | ) |S c c}w )aC Returns a CookieJar from a key/value dictionary.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:param cookiejar: (optional) A cookiejar to add the cookies to.
:param overwrite: (optional) If False, will not replace cookies
already in the jar with new ones.
:rtype: CookieJar
)r rA r r )r r} r
r names_from_jarrA s r# r r C sk %' 4=>I&&++I> DT 7$$]4T9J%KL ?s Ac & t | t j s t d t |t rt || d } | S t |t j r1t
| dd x}r
|| | S |D ] }| j | | S )zAdd cookies to cookiejar and returns a merged CookieJar.
:param cookiejar: CookieJar object to add the cookies to.
:param cookies: Dictionary or CookieJar object to be added.
:rtype: CookieJar
z!You can only merge into CookieJarF)r} r
r N)r r r r dictr r r )r} cookies
update_method
cookie_in_jars r#
merge_cookiesr \ s i!4!4 5<=='4 '9PUV
GY 0 0 1 #Ix > >= > ' "
")
$$]3 ") r% )rp r r" r rq r
rW rX )rp r r" r rW r[ r )
r} r rA r rz r[ r4 r[ rW rX )rp CookieJar | NonerW r )rA r rN r r r
rW r )r z Morsel[Any]rW r r< )r dict[str, str] | Noner} rX r
rZ rW r )T)r r r} r r
rZ rW r )r r r} r r
rZ rW r )r} r r z!dict[str, str] | CookieJar | NonerW r )0r_
__future__r r r r collections.abcr r http.cookiejarr r r typingr r
r r _internal_utilsr _typesr r compatr r r r _typeshedr modelsr r r rc rt rx r RuntimeErrorr r r r r r r r r r= r% r# r! s # 4 : : 8 8 - / ; ;0' P P f' '*" " ,"8;" "$- TX,, #,-7,FP, ,*, ] >#sTz/#B ] @ "&J: m95
&
&
#'& 2#Dr% PK ! qѵ@ @ $ __pycache__/packages.cpython-312.pycnu [
9r*j d dl Z ddlmZ dD ]b Z ee e e< ee j D ]; Zeek( sej e d s e j e e j de < = d eej Z ee j D ]a Zee k( sej e d s e j e Z e e j de < ej e d Ze e j de < c yy) N )chardet)urllib3idna.zrequests.packages.r )syscompatr package
__import__localslistmodulesmod
startswith__name__target imported_modreplace @/opt/hc_python/lib/python3.12/site-packages/requests/packages.pyr s
#G"7+FHW CKK '>S^^wiqM :69kk#6FCKK,SE2 3 ! #
FCKK &=CNNfXQ< 8 ;;s+L6BCKK,SE2 3++fi0C6BCKK,SE2 3 ! r PK ! MzD D " __pycache__/_types.cpython-312.pycnu [
9r*j D U d Z ddlmZ ddlmZmZmZmZmZ ddl m
Z
m Z m Z m
Z
mZmZ edd Z edd Z ed d Ze G d
d e e Ze G d d
e eef Zedge f Zded< eeee ez f Zded< dEdZe
rddlmZ ddl m
Z
m Z ddl m Z m Z ddl m!Z! ddl"m#Z# ddl$m%Z%m&Z& ddl'm(Z( G d d e% Z)ee*z Z+ded < ee*z e,z e-z Z.ded < ee*z e,z e-z eee*z e,z e-z z d z Z/ded < ee.e/f e0e0e.e/f d!f z ee0e.e/f z ez e*z d z Z1ded"< ee0e e f ee e f z Z2ded#< e2ez e*z Z3ded$< eee*z Z4ded%< e3e4z Z5ded&< e2ee*ez z ez e*z e z eee*z z d z Z6ded'< e*ez ee*ez z ee*ez z d z Z7ded(< eeee*z f d z Z8ded)< e#eeef z Z9ded*< ed z Z:ded+< eee*z ez e*z Z;ded,< e0e:e;f Zded/< e;ez Z?ded0< eee?f ee0ee?f z d z Z@ded1< e0eef e!z ee%ge%f z d z ZAded2< e-e0e-d z e-d z f z d z ZBded3< eeef ZCded4< eDeeEe f d z ZFded5< eGez ZHded6< ee0eef z d z ZIded7< d eGz e,z e-z ez ed8 z eed8f z ZJded8< G d9 d:e d;< ZK G d= d>eKd;< ZL G d? d@eKd;< ZM G dA dBeKd;< ZN G dC dDeKd;< ZOy y )Fz
requests._types
~~~~~~~~~~~~~~~
This module contains type aliases used internally by the Requests library.
These types are not part of the public API and must not be relied upon
by external code.
) annotations)CallableIterableMappingMutableMappingSequence)
TYPE_CHECKINGAnyProtocol TypeAliasTypeVarruntime_checkable_T_coT) covariant_KT_co_VT_coc e Zd ZdddZy) SupportsReadc y N )selflengths >/opt/hc_python/lib/python3.12/site-packages/requests/_types.pyreadzSupportsRead.read s 3 N).)r intreturnr )__name__
__module__ __qualname__r r r r r r s 6r r c e Zd ZddZy)
SupportsItemsc y r r )r s r itemszSupportsItems.items" s r N)r z Iterable[tuple[_KT_co, _VT_co]])r r r! r% r r r r# r# s ;r r# Responser HookTypeHooksInputTypec L t r | j duxr | j duS y)z1Verify a PreparedRequest has been fully prepared.NT)r urlmethod)requests r is_preparedr- * s% {{$&E7>>+EE r ) CookieJar)r TypedDict)BufferTypeIs )AuthBase)RequestsCookieJar)PreparedRequestr& )CaseInsensitiveDictc & e Zd ZU dZded< ded< y)_ValidatedRequesta{ Subtype asserting a PreparedRequest has been fully prepared before calling.
The override suppression is required because mutable attribute types are
invariant (Liskov), but we only narrow after preparation is complete. This
is the explicit contract for Requests but Python's typing doesn't have a
better way to represent the requirement.
strr* r+ Nr r r! __doc____annotations__r r r r8 r8 @ s r r8 UriType_ParamsMappingKeyTypeN_ParamsMappingValueType.
ParamsType
KVDataType RawDataTypeStreamDataTypeEncodableDataTypeDataTypeBodyType HeadersType CookiesType _FileName _FileContent_FileSpecBasic_FileSpecWithContentType_FileSpecWithHeaders _FileSpec FilesTypeAuthType TimeoutType ProxiesType HooksType
VerifyTypeCertTypeJsonTypec | e Zd ZU ded< ded< ded< ded< d ed
< d ed < d
ed< ded< ded< ded< ded< y)BaseRequestKwargsrG headersz5RequestsCookieJar | CookieJar | dict[str, str] | NonecookiesrO filesrP authrQ timeoutboolallow_redirectszdict[str, str] | NoneproxieszHooksInputType | Nonehooksz bool | NonestreamzVerifyType | NoneverifyrU certNr r r! r< r r r rX rX sB FF &&$$!!r rX F)totalc 0 e Zd ZU dZded< ded< ded< y)
RequestKwargsz2kwargs for request(), options(), head(), delete().r@ paramsrE datarV jsonNr: r r r rh rh s @r rh c " e Zd ZU ded< ded< y) GetKwargsrE rj rV rk Nre r r r rm rm s r rm c e Zd ZU ded< y)
PostKwargsr@ ri Nre r r r ro ro s r ro c & e Zd ZU dZded< ded< y)
DataKwargszkwargs for put(), patch().r@ ri rV rk Nr: r r r rq rq s (r rq )r, r5 r zTypeIs[_ValidatedRequest])Pr;
__future__r collections.abcr r r r r typingr r
r r r
r r r r r r# r' r< r9 r( r- http.cookiejarr. r/ typing_extensionsr0 r1 r\ r3 rZ r4 modelsr5 r&
structuresr6 r8 bytesr= r floatr> r? tupler@ rA rB rC rD rE rF rG rH rI rJ rK rL rM rN rO rP rQ rR dictlistrS r^ rT rU rV rX rh rm ro rq r r r r~ s% # Q Q 4( T * T * 78E? 7 7 -F$GG$N Y +-DDE
+-DDEsJ
K L
5.0GGH
I J
%U38_ 5
c3h8O OJ O '# - 5K5 ,S5[ 9NI9#. #?y?
53;
sU{
# $
i hus{++l53;.GG$N
i %S#+%5 6 =K= .c1B BKB :Iy% *3; 7# = EL)E %i &= >NI>*/ <0L*M iM&+<&9#&>cAR&RR') ~%(@@CWW y Y (5i +@"AADH y
c3h("X.? .P%QQTXX
i #U54< +E%F F MKM +CH 5K5 T(^ 34t;Iy; 3JJ & c3h/$6Hi6
:
#z/
"
#
i IU ) %U &e &e C r PK ! '8W W & __pycache__/structures.cpython-312.pycnu [
9r*j& d Z ddlmZ ddlmZ ddlmZmZmZ ddl m
Z
m Z m Z m
Z
ddlmZ e d Z e d Z G d
d eeef e e Z G d d
eeef Zy)zO
requests.structures
~~~~~~~~~~~~~~~~~~~
Data structures that power Requests.
) annotations) OrderedDict)IterableIteratorMapping)AnyGenericTypeVaroverload )MutableMapping_VT_Dc z e Zd ZU dZded< d ddZddZddZddZdd Z dd
Z
dd Z dd Z dd
Z
ddZy)CaseInsensitiveDicta A case-insensitive ``dict``-like object.
Implements all methods and operations of
``MutableMapping`` as well as dict's ``copy``. Also
provides ``lower_items``.
All keys are expected to be strings. The structure remembers the
case of the last key to be set, and ``iter(instance)``,
``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
will contain case-sensitive keys. However, querying and contains
testing is case insensitive::
cid = CaseInsensitiveDict()
cid['Accept'] = 'application/json'
cid['aCCEPT'] == 'application/json' # True
list(cid) == ['Accept'] # True
For example, ``headers['content-encoding']`` will return the
value of a ``'Content-Encoding'`` response header, regardless
of how the header name was originally stored.
If the constructor, ``.update``, or equality comparison
operations are given keys that have equal ``.lower()``s, the
behavior is undefined.
z!OrderedDict[str, tuple[str, _VT]]_storeNc P t | _ |i } | j |fi | y N)r r update)selfdatakwargss B/opt/hc_python/lib/python3.12/site-packages/requests/structures.py__init__z CaseInsensitiveDict.__init__1 s*
"m <D D#F# c B ||f| j |j < y r r lower)r keyvalues r __setitem__z CaseInsensitiveDict.__setitem__; s %(< CIIK r c B | j |j d S )Nr r r r s r __getitem__z CaseInsensitiveDict.__getitem__@ s {{399;'**r c : | j |j = y r r r# s r __delitem__z CaseInsensitiveDict.__delitem__C s KK $r c D d | j j D S )Nc 3 & K | ] \ }}| y wr ).0casedkey_s r z/CaseInsensitiveDict.__iter__..G s A,@[Xq,@s )r valuesr s r __iter__z CaseInsensitiveDict.__iter__F s ADKK,>,>,@AAr c , t | j S r )lenr r/ s r __len__zCaseInsensitiveDict.__len__I s 4;; r c D d | j j D S )z.Like iteritems(), but with all lowercase keys.c 3 0 K | ] \ }}||d f yw)r Nr) )r* lowerkeykeyvals r r- z2CaseInsensitiveDict.lower_items..N s! T@S*<8V6!9%@Ss )r itemsr/ s r lower_itemsz CaseInsensitiveDict.lower_itemsL s T @Q@Q@STTr c t |t r t | }nt S t | j t |j k( S r )
isinstancer r NotImplementeddictr9 )r other
other_dicts r __eq__zCaseInsensitiveDict.__eq__P sC eW %3Fu3MJ! !D$$&'4
0F0F0H+IIIr c H t | j j S r )r r r. r/ s r copyzCaseInsensitiveDict.copyY s "4;;#5#5#788r c F t t | j S r )strr= r8 r/ s r __repr__z CaseInsensitiveDict.__repr__\ s 4
%&&r r )r z4Mapping[str, _VT] | Iterable[tuple[str, _VT]] | Noner r returnNone)r rD r r rF rG )r rD rF r )r rD rF rG )rF z
Iterator[str])rF int)rF zIterator[tuple[str, _VT]])r> objectrF bool)rF zCaseInsensitiveDict[_VT]rF rD )__name__
__module__ __qualname____doc____annotations__r r! r$ r& r0 r3 r9 r@ rB rE r) r r r r sg 4
.- FJ$B$ $
$0
+%B UJ9'r r c z e Zd ZU dZded< d d fd
Zd
dZddZddZe d dd Z
e dd Z
d dd
Z
xZ S )
LookupDictzDictionary lookup object.r namec 0 || _ t | y r )rS superr )r rS __class__s r r zLookupDict.__init__e s
r c " d| j dS )Nz )rS r/ s r rE zLookupDict.__repr__i s 499+R((r c || j v r| j | S t dt | j d| d )N'z' object has no attribute ')__dict__AttributeErrortyperL r# s r __getattr__zLookupDict.__getattr__l sJ $-- ==% % DJ''((CC5J
r c : | j j |d S r rZ getr# s r r$ zLookupDict.__getitem__v s }} d++r c y r r) r r defaults r r` zLookupDict.get{ s ADr c y r r) rb s r r` zLookupDict.get~ s rn se # # 7 7 2 2 "
en T]I'.c2GCL I'X"/c3h "/r PK ! u]b & __pycache__/exceptions.cpython-312.pycnu [
9r*j d Z ddlmZ ddlmZmZ ddlmZ ddl m
Z er
ddl m
Z
mZmZ G d d e Z G d
d e Z G d d
ee Z
G d de Z G d de Z G d de Z G d de Z G d de Z G d dee Z G d de Z G d d e Z G d d e Z G d d!ee Z G d" d#ee Z G d$ d%ee Z G d& d'ee Z G d( d)e Z G d* d+e Z! G d, d-ee Z" G d. d/ee# Z$ G d0 d1e Z% G d2 d3e Z& G d4 d5e' Z( G d6 d7e(e) Z* G d8 d9e( Z+y:);z`
requests.exceptions
~~~~~~~~~~~~~~~~~~~
This module contains the set of Requests' exceptions.
) annotations)
TYPE_CHECKINGAny) HTTPError )JSONDecodeError)PreparedRequestRequestResponsec : e Zd ZU dZded< ded< d fd Z xZS )RequestExceptionzTThere was an ambiguous exception that occurred while handling your
request.
zResponse | Noneresponsez Request | PreparedRequest | Nonerequestc |j dd }|| _ |j dd | _ |)| j s t |d r|j | _ t | |i | y)zBInitialize RequestException with `request` and `response` objects.r Nr )popr r hasattrsuper__init__)selfargskwargsr __class__s B/opt/hc_python/lib/python3.12/site-packages/requests/exceptions.pyr zRequestException.__init__ s` $*JJz4$@
zz)T2 99U#++DL
$)&) r r r r returnNone)__name__
__module__ __qualname____doc____annotations__r
__classcell__)r s @r r
r
s
--* *r r
c e Zd ZdZy)InvalidJSONErrorzA JSON error occurred.Nr r r r! r r r% r% & r r% c e Zd ZdZddZddZy)r z"Couldn't decode the text into jsonc v t j | g| t j | g| j i | y)a
Construct the JSONDecodeError instance first with all
args. Then use it's args to construct the IOError so that
the json specific args aren't used as IOError specific args
and the error message from JSONDecodeError is preserved.
N)CompatJSONDecodeErrorr r% r )r r r s r r zJSONDecodeError.__init__- s3 &&t3d3!!$==f=r c , t j | S )aa
The __reduce__ method called when pickling the object must
be the one from the JSONDecodeError (be it json/simplejson)
as it expects all the arguments for instantiation, not just
one like the IOError, and the MRO would by default call the
__reduce__ method from the IOError due to the inheritance order.
)r+
__reduce__)r s r r- zJSONDecodeError.__reduce__7 s %//55r Nr )r ztuple[Any, ...] | str)r r r r! r r- r' r r r r * s ,>6r r c e Zd ZdZy)r zAn HTTP error occurred.Nr& r' r r r r B !r r c e Zd ZdZy)ConnectionErrorz A Connection error occurred.Nr& r' r r r1 r1 F s &r r1 c e Zd ZdZy)
ProxyErrorzA proxy error occurred.Nr& r' r r r3 r3 J r/ r r3 c e Zd ZdZy)SSLErrorzAn SSL error occurred.Nr& r' r r r5 r5 N r( r r5 c e Zd ZdZy)TimeoutzThe request timed out.
Catching this error will catch both
:exc:`~requests.exceptions.ConnectTimeout` and
:exc:`~requests.exceptions.ReadTimeout` errors.
Nr& r' r r r7 r7 R s r r7 c e Zd ZdZy)ConnectTimeoutzThe request timed out while trying to connect to the remote server.
Requests that produced this error are safe to retry.
Nr& r' r r r9 r9 [ s r r9 c e Zd ZdZy) ReadTimeoutz@The server did not send any data in the allotted amount of time.Nr& r' r r r; r; b Jr r; c e Zd ZdZy) URLRequiredz*A valid URL is required to make a request.Nr& r' r r r> r> f s 4r r> c e Zd ZdZy)TooManyRedirectszToo many redirects.Nr& r' r r r@ r@ j s r r@ c e Zd ZdZy)
MissingSchemaz/The URL scheme (e.g. http or https) is missing.Nr& r' r r rB rB n s 9r rB c e Zd ZdZy)
InvalidSchemaz9The URL scheme provided is either invalid or unsupported.Nr& r' r r rD rD r s Cr rD c e Zd ZdZy)
InvalidURLz%The URL provided was somehow invalid.Nr& r' r r rF rF v s /r rF c e Zd ZdZy)
InvalidHeaderz.The header value provided was somehow invalid.Nr& r' r r rH rH z s 8r rH c e Zd ZdZy)InvalidProxyURLz"The proxy URL provided is invalid.Nr& r' r r rJ rJ ~ ,r rJ c e Zd ZdZy)ChunkedEncodingErrorz?The server declared chunked encoding but sent an invalid chunk.Nr& r' r r rM rM s Ir rM c e Zd ZdZy)ContentDecodingErrorz"Failed to decode response content.Nr& r' r r rO rO rK r rO c e Zd ZdZy)StreamConsumedErrorz3The content for this response was already consumed.Nr& r' r r rQ rQ s =r rQ c e Zd ZdZy)
RetryErrorzCustom retries logic failedNr& r' r r rS rS s %r rS c e Zd ZdZy)UnrewindableBodyErrorz;Requests encountered an error when trying to rewind a body.Nr& r' r r rU rU s Er rU c e Zd ZdZy)RequestsWarningzBase warning for Requests.Nr& r' r r rW rW s $r rW c e Zd ZdZy)FileModeWarningzJA file was opened in text mode, but Requests determined its binary length.Nr& r' r r rY rY s Tr rY c e Zd ZdZy)RequestsDependencyWarningz@An imported dependency doesn't match the expected version range.Nr& r' r r r[ r[ r< r r[ N),r!
__future__r typingr r urllib3.exceptionsr
BaseHTTPErrorcompatr r+ modelsr r
r IOErrorr
r% r1 r3 r5 r7 r9 r; r> r@
ValueErrorrB rD rF rH rJ rM rO TypeErrorrQ rS rU WarningrW DeprecationWarningrY r[ r' r r rg s} # % 9 <::*w *$!' !6&(= 60" "'& '" "! ! _g K' K5" 5 ' :$j :D$j D0!: 09$j 9-j -J+ J-+] ->*I >&! &F , F%g %Uo'9 UK Kr PK ! : __pycache__/help.cpython-312.pycnu [
9r*jr d Z ddlZddlZddlZddlZddlmZ ddlZddlZddl m
Z ddl Z ddlZ ddlmZ ddlZddlZd Zdeeef fd Zd
Zed k( r e yy# e
$ r dZ Y )>)K)KL& "
8 #!)!8!8!: < '!)!8!8!: !* "/E FF returnc
X t j t j d} t }dt
j i}ddi}ddi}t rdt j i}t rdt j i}ddd}t r-t j t j j dd}dt t dd i}dt t dd i}t j }d||dndi} | || t dut du ||||||dt" id S # t $ r ddd} Y w xY w)
z&Generate information for a bug report.)systemreleaser r Nr )r openssl_versionxr ) r r
system_sslusing_pyopensslusing_charset_normalizer pyOpenSSLurllib3chardetcharset_normalizer cryptographyidnarequests)r r$ r% OSErrorr r, r r. r- OpenSSLSSLOPENSSL_VERSION_NUMBERgetattrr/ r0 sslr requests_version)
platform_infoimplementation_info urllib3_infocharset_normalizer_info chardet_infopyopenssl_infocryptography_info idna_infor( system_ssl_infos
r inforB E sd
oo' '')
*+ w 2 23L ($ /+4d*;L#,.@.L.L"M !7#6#67 -N **")++"D"DQ!G
7< ; 74 3I ++J z7MZNSUVO "-%$D0$+tO# 5) '
E
s )D D)(D)c V t t j t dd y)z)Pretty-print the bug information as JSON.T ) sort_keysindentN)printjsondumpsrB r! r mainrK s $**TVtA
67r! __main__)__doc__rH r r7 r typingr r0 r, r r r8 r. ImportErrorr- urllib3.contribr r/ r3 r dictstrrB rK __name__rJ r! r rT s -
- ) G@8d38n 8v8
zF g
G
IGLs3 A A, A9 A)(A),A65A69 BBPK ! 1Zw w $ __pycache__/__init__.cpython-312.pycnu [
9r*j"
^ d Z ddlmZ ddlZddlZddlmZ ddlmZ ddl mZ d dZ
d dZ e
ej e e ddlZ eed
d s%ddlmZ ej, ddlmZ ee ddlmZ ej6 de ddl Z ddl m Z ddl m Z m Z ddlm!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)mZ ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 ddlm3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@ ddlAmBZBmCZC ddlDmEZE dZF e j eH j e ej6 de5d y# e
$ r dZ Y 0w xY w# e
$ r dZ Y 7w xY w# eef$ r+ ej" d ej d
e d e d e Y Gw xY w# e
$ r dZY Ow xY w# e
$ r Y ,w xY w) a
Requests HTTP Library
~~~~~~~~~~~~~~~~~~~~~
Requests is an HTTP library, written in Python, for human beings.
Basic GET usage:
>>> import requests
>>> r = requests.get('https://www.python.org')
>>> r.status_code
200
>>> b'Python is a programming language' in r.content
True
... or POST:
>>> payload = dict(key1='value1', key2='value2')
>>> r = requests.post('https://httpbin.org/post', data=payload)
>>> print(r.text)
{
...
"form": {
"key1": "value1",
"key2": "value2"
},
...
}
The other HTTP methods are supported - see `requests.api`. Full documentation
is at .
:copyright: (c) 2017 by Kenneth Reitz.
:license: Apache 2.0, see LICENSE for more details.
) annotationsN )RequestsDependencyWarning) __version__c b | j d d d }|dgk7 sJ t | dk( r|j d |\ }}}t | t | t | }}}|dk\ sJ |dk( r|dk\ sJ |rN |j d d d \ }}}t | t | t | }}}d|||fcxk rd k sJ J y |rN |j d d d \ }}}t | t | t | }}}d
|||fcxk rd k sJ J y t j
d t y )
N. dev 0r )r r r ) r r )r r r ) r r zYUnable to find acceptable character detection dependency (chardet or charset_normalizer).)splitlenappendintwarningswarnr )urllib3_versionchardet_versioncharset_normalizer_versionurllib3_version_listmajorminorpatchs @/opt/hc_python/lib/python3.12/site-packages/requests/__init__.pycheck_compatibilityr < s_
+005bq9 E7 ** * A% ##C( /E5% e*c%j#e*%5E A:: z{{ 3o 3 3C 8! <ue !%j#e*c%jeuUE5 1=I===== # > 8 > >s CBQ Gue !%j#e*c%jeuUE5 1=I=====
/ %
c t t t | j d }|g dk r!d| d}t j |t y y # t $ r Y y w xY w)Nr )r r r z Old version of cryptography (z) may cause slowdown.)listmapr r
ValueErrorr r r )cryptography_versioncryptography_version_listwarnings r _check_cryptographyr' c sk $(S2L2F2L2LS2Q)R$S! !9,12K1LLab
g 89 - s )A A A z urllib3 (z) or chardet (z)/charset_normalizer (z$) doesn't match a supported version!HAS_SNIF) pyopenssl)DependencyWarningignore) NullHandler)packagesutils)
__author____author_email__ __build____cake__
__copyright____description__ __license__ __title____url__r )deletegetheadoptionsr postputrequest)
ConnectionErrorConnectTimeoutFileModeWarning HTTPErrorJSONDecodeError ReadTimeoutRequestExceptionTimeoutTooManyRedirects URLRequired)PreparedRequestRequestResponse)Sessionsession)codes)r? r@ rB rC rI rD rJ rE rK rL rF rG rH rN r8 r9 r: r; r- r r< r= r> rM r. defaultT)r )r strr
str | Noner rQ returnNone)r$ rP rR rS )J__doc__
__future__r r urllib3
exceptionsr charset_normalizerr r ImportErrorchardetr r r' AssertionErrorr# r sslgetattrurllib3.contribr) inject_into_urllib3 cryptographyr$ urllib3.exceptionsr* simplefilterloggingr, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 apir8 r9 r: r; r r< r= r> r? r@ rA rB rC rD rE rF rG rH modelsrI rJ rK sessionsrL rM status_codesrN __all__ getLogger__name__
addHandler r r rn s !F # 1&L6
$
$
$
!+$
$
N : " 3 5 )-% %%'
01
1 h 1 2 G F F 7 6 & 8 ( & &{} 5 i >Q &!% &
O|
# HMM
G''( ) 23M2N O- - " sc E E E F /F# EEE E .FFF F# F F# #F,+F,PK ! D* * ' __pycache__/__version__.cpython-312.pycnu [
9r*j , d Z dZdZdZdZdZdZdZdZd Z y
) requestszPython HTTP for Humans.z https://requests.readthedocs.ioz2.34.2i4 z
Kenneth Reitzzme@kennethreitz.orgz
Apache-2.0zCopyright Kenneth Reitzu ✨ 🍰 ✨N)
__title____description____url__ __version__ __build__
__author____author_email__ __license__
__copyright____cake__ C/opt/hc_python/lib/python3.12/site-packages/requests/__version__.pyr s:
+
+
( )
%r PK ! 4| | ! __pycache__/certs.cpython-312.pycnu [
9r*j : d Z ddlmZ edk( r e e yy)uF
requests.certs
~~~~~~~~~~~~~~
This module returns the preferred default CA certificate bundle. There is
only one — the one from the certifi package.
If you are packaging Requests, e.g., for a Linux distribution or a managed
environment, you can change the definition of where() to return a separately
packaged CA bundle.
)where__main__N)__doc__certifir __name__print =/opt/hc_python/lib/python3.12/site-packages/requests/certs.pyr s%
z %'N r
PK ! "Ο compat.pynu [ """
requests.compat
~~~~~~~~~~~~~~~
This module previously handled import compatibility issues
between Python 2 and Python 3. It remains for backwards
compatibility until the next major version.
"""
import sys
# -------
# urllib3
# -------
from pip._vendor.urllib3 import __version__ as urllib3_version
# Detect which major version of urllib3 is being used.
try:
is_urllib3_1 = int(urllib3_version.split(".")[0]) == 1
except (TypeError, AttributeError):
# If we can't discern a version, prefer old functionality.
is_urllib3_1 = True
# -------------------
# Character Detection
# -------------------
def _resolve_char_detection():
"""Find supported character detection libraries."""
chardet = None
return chardet
chardet = _resolve_char_detection()
# -------
# Pythons
# -------
# Syntax sugar.
_ver = sys.version_info
#: Python 2.x?
is_py2 = _ver[0] == 2
#: Python 3.x?
is_py3 = _ver[0] == 3
# Note: We've patched out simplejson support in pip because it prevents
# upgrading simplejson on Windows.
import json
from json import JSONDecodeError
# Keep OrderedDict for backwards compatibility.
from collections import OrderedDict
from collections.abc import Callable, Mapping, MutableMapping
from http import cookiejar as cookielib
from http.cookies import Morsel
from io import StringIO
# --------------
# Legacy Imports
# --------------
from urllib.parse import (
quote,
quote_plus,
unquote,
unquote_plus,
urldefrag,
urlencode,
urljoin,
urlparse,
urlsplit,
urlunparse,
)
from urllib.request import (
getproxies,
getproxies_environment,
parse_http_list,
proxy_bypass,
proxy_bypass_environment,
)
builtin_str = str
str = str
bytes = bytes
basestring = (str, bytes)
numeric_types = (int, float)
integer_types = (int,)
PK ! py.typednu [ PK ! ( _internal_utils.pynu [ """
requests._internal_utils
~~~~~~~~~~~~~~
Provides utility functions that are consumed internally by Requests
which depend on extremely few external helpers (such as compat)
"""
import re
from .compat import builtin_str
_VALID_HEADER_NAME_RE_BYTE = re.compile(rb"^[^:\s][^:\r\n]*$")
_VALID_HEADER_NAME_RE_STR = re.compile(r"^[^:\s][^:\r\n]*$")
_VALID_HEADER_VALUE_RE_BYTE = re.compile(rb"^\S[^\r\n]*$|^$")
_VALID_HEADER_VALUE_RE_STR = re.compile(r"^\S[^\r\n]*$|^$")
_HEADER_VALIDATORS_STR = (_VALID_HEADER_NAME_RE_STR, _VALID_HEADER_VALUE_RE_STR)
_HEADER_VALIDATORS_BYTE = (_VALID_HEADER_NAME_RE_BYTE, _VALID_HEADER_VALUE_RE_BYTE)
HEADER_VALIDATORS = {
bytes: _HEADER_VALIDATORS_BYTE,
str: _HEADER_VALIDATORS_STR,
}
def to_native_string(string, encoding="ascii"):
"""Given a string object, regardless of type, returns a representation of
that string in the native string type, encoding and decoding where
necessary. This assumes ASCII unless told otherwise.
"""
if isinstance(string, builtin_str):
out = string
else:
out = string.decode(encoding)
return out
def unicode_is_ascii(u_string):
"""Determine if unicode string only contains ASCII characters.
:param str u_string: unicode string to check. Must be unicode
and not Python 2 `str`.
:rtype: bool
"""
assert isinstance(u_string, str)
try:
u_string.encode("ascii")
return True
except UnicodeEncodeError:
return False
PK ! =`:
exceptions.pynu [ """
requests.exceptions
~~~~~~~~~~~~~~~~~~~
This module contains the set of Requests' exceptions.
"""
from pip._vendor.urllib3.exceptions import HTTPError as BaseHTTPError
from .compat import JSONDecodeError as CompatJSONDecodeError
class RequestException(IOError):
"""There was an ambiguous exception that occurred while handling your
request.
"""
def __init__(self, *args, **kwargs):
"""Initialize RequestException with `request` and `response` objects."""
response = kwargs.pop("response", None)
self.response = response
self.request = kwargs.pop("request", None)
if response is not None and not self.request and hasattr(response, "request"):
self.request = self.response.request
super().__init__(*args, **kwargs)
class InvalidJSONError(RequestException):
"""A JSON error occurred."""
class JSONDecodeError(InvalidJSONError, CompatJSONDecodeError):
"""Couldn't decode the text into json"""
def __init__(self, *args, **kwargs):
"""
Construct the JSONDecodeError instance first with all
args. Then use it's args to construct the IOError so that
the json specific args aren't used as IOError specific args
and the error message from JSONDecodeError is preserved.
"""
CompatJSONDecodeError.__init__(self, *args)
InvalidJSONError.__init__(self, *self.args, **kwargs)
def __reduce__(self):
"""
The __reduce__ method called when pickling the object must
be the one from the JSONDecodeError (be it json/simplejson)
as it expects all the arguments for instantiation, not just
one like the IOError, and the MRO would by default call the
__reduce__ method from the IOError due to the inheritance order.
"""
return CompatJSONDecodeError.__reduce__(self)
class HTTPError(RequestException):
"""An HTTP error occurred."""
class ConnectionError(RequestException):
"""A Connection error occurred."""
class ProxyError(ConnectionError):
"""A proxy error occurred."""
class SSLError(ConnectionError):
"""An SSL error occurred."""
class Timeout(RequestException):
"""The request timed out.
Catching this error will catch both
:exc:`~requests.exceptions.ConnectTimeout` and
:exc:`~requests.exceptions.ReadTimeout` errors.
"""
class ConnectTimeout(ConnectionError, Timeout):
"""The request timed out while trying to connect to the remote server.
Requests that produced this error are safe to retry.
"""
class ReadTimeout(Timeout):
"""The server did not send any data in the allotted amount of time."""
class URLRequired(RequestException):
"""A valid URL is required to make a request."""
class TooManyRedirects(RequestException):
"""Too many redirects."""
class MissingSchema(RequestException, ValueError):
"""The URL scheme (e.g. http or https) is missing."""
class InvalidSchema(RequestException, ValueError):
"""The URL scheme provided is either invalid or unsupported."""
class InvalidURL(RequestException, ValueError):
"""The URL provided was somehow invalid."""
class InvalidHeader(RequestException, ValueError):
"""The header value provided was somehow invalid."""
class InvalidProxyURL(InvalidURL):
"""The proxy URL provided is invalid."""
class ChunkedEncodingError(RequestException):
"""The server declared chunked encoding but sent an invalid chunk."""
class ContentDecodingError(RequestException, BaseHTTPError):
"""Failed to decode response content."""
class StreamConsumedError(RequestException, TypeError):
"""The content for this response was already consumed."""
class RetryError(RequestException):
"""Custom retries logic failed"""
class UnrewindableBodyError(RequestException):
"""Requests encountered an error when trying to rewind a body."""
# Warnings
class RequestsWarning(Warning):
"""Base warning for Requests."""
class FileModeWarning(RequestsWarning, DeprecationWarning):
"""A file was opened in text mode, but Requests determined its binary length."""
class RequestsDependencyWarning(RequestsWarning):
"""An imported dependency doesn't match the expected version range."""
PK ! s61 1 api.pynu [ """
requests.api
~~~~~~~~~~~~
This module implements the Requests API.
:copyright: (c) 2012 by Kenneth Reitz.
:license: Apache2, see LICENSE for more details.
"""
from . import sessions
def request(method, url, **kwargs):
"""Constructs and sends a :class:`Request `.
:param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the query string for the :class:`Request`.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
:param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
:param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content_type'`` is a string
defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
to add for the file.
:param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds to wait for the server to send data
before giving up, as a float, or a :ref:`(connect timeout, read
timeout) ` tuple.
:type timeout: float or tuple
:param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use. Defaults to ``True``.
:param stream: (optional) if ``False``, the response content will be immediately downloaded.
:param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
:return: :class:`Response ` object
:rtype: requests.Response
Usage::
>>> import requests
>>> req = requests.request('GET', 'https://httpbin.org/get')
>>> req
"""
# By using the 'with' statement we are sure the session is closed, thus we
# avoid leaving sockets open which can trigger a ResourceWarning in some
# cases, and look like a memory leak in others.
with sessions.Session() as session:
return session.request(method=method, url=url, **kwargs)
def get(url, params=None, **kwargs):
r"""Sends a GET request.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the query string for the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
"""
return request("get", url, params=params, **kwargs)
def options(url, **kwargs):
r"""Sends an OPTIONS request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
"""
return request("options", url, **kwargs)
def head(url, **kwargs):
r"""Sends a HEAD request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes. If
`allow_redirects` is not provided, it will be set to `False` (as
opposed to the default :meth:`request` behavior).
:return: :class:`Response ` object
:rtype: requests.Response
"""
kwargs.setdefault("allow_redirects", False)
return request("head", url, **kwargs)
def post(url, data=None, json=None, **kwargs):
r"""Sends a POST request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
"""
return request("post", url, data=data, json=json, **kwargs)
def put(url, data=None, **kwargs):
r"""Sends a PUT request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
"""
return request("put", url, data=data, **kwargs)
def patch(url, data=None, **kwargs):
r"""Sends a PATCH request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
"""
return request("patch", url, data=data, **kwargs)
def delete(url, **kwargs):
r"""Sends a DELETE request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
"""
return request("delete", url, **kwargs)
PK ! QL` `
structures.pynu [ """
requests.structures
~~~~~~~~~~~~~~~~~~~
Data structures that power Requests.
"""
from collections import OrderedDict
from .compat import Mapping, MutableMapping
class CaseInsensitiveDict(MutableMapping):
"""A case-insensitive ``dict``-like object.
Implements all methods and operations of
``MutableMapping`` as well as dict's ``copy``. Also
provides ``lower_items``.
All keys are expected to be strings. The structure remembers the
case of the last key to be set, and ``iter(instance)``,
``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
will contain case-sensitive keys. However, querying and contains
testing is case insensitive::
cid = CaseInsensitiveDict()
cid['Accept'] = 'application/json'
cid['aCCEPT'] == 'application/json' # True
list(cid) == ['Accept'] # True
For example, ``headers['content-encoding']`` will return the
value of a ``'Content-Encoding'`` response header, regardless
of how the header name was originally stored.
If the constructor, ``.update``, or equality comparison
operations are given keys that have equal ``.lower()``s, the
behavior is undefined.
"""
def __init__(self, data=None, **kwargs):
self._store = OrderedDict()
if data is None:
data = {}
self.update(data, **kwargs)
def __setitem__(self, key, value):
# Use the lowercased key for lookups, but store the actual
# key alongside the value.
self._store[key.lower()] = (key, value)
def __getitem__(self, key):
return self._store[key.lower()][1]
def __delitem__(self, key):
del self._store[key.lower()]
def __iter__(self):
return (casedkey for casedkey, mappedvalue in self._store.values())
def __len__(self):
return len(self._store)
def lower_items(self):
"""Like iteritems(), but with all lowercase keys."""
return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())
def __eq__(self, other):
if isinstance(other, Mapping):
other = CaseInsensitiveDict(other)
else:
return NotImplemented
# Compare insensitively
return dict(self.lower_items()) == dict(other.lower_items())
# Copy is required
def copy(self):
return CaseInsensitiveDict(self._store.values())
def __repr__(self):
return str(dict(self.items()))
class LookupDict(dict):
"""Dictionary lookup object."""
def __init__(self, name=None):
self.name = name
super().__init__()
def __repr__(self):
return f""
def __getitem__(self, key):
# We allow fall-through here, so values default to None
return self.__dict__.get(key, None)
def get(self, key, default=None):
return self.__dict__.get(key, default)
PK ! certs.pynu [ #!/usr/bin/env python
"""
requests.certs
~~~~~~~~~~~~~~
This module returns the preferred default CA certificate bundle. There is
only one — the one from the certifi package.
If you are packaging Requests, e.g., for a Linux distribution or a managed
environment, you can change the definition of where() to return a separately
packaged CA bundle.
"""
from pip._vendor.certifi import where
if __name__ == "__main__":
print(where())
PK ! \gQɁ Ɂ utils.pynu [ """
requests.utils
~~~~~~~~~~~~~~
This module provides utility functions that are used within Requests
that are also useful for external consumption.
"""
import codecs
import contextlib
import io
import os
import re
import socket
import struct
import sys
import tempfile
import warnings
import zipfile
from collections import OrderedDict
from pip._vendor.urllib3.util import make_headers, parse_url
from . import certs
from .__version__ import __version__
# to_native_string is unused here, but imported here for backwards compatibility
from ._internal_utils import ( # noqa: F401
_HEADER_VALIDATORS_BYTE,
_HEADER_VALIDATORS_STR,
HEADER_VALIDATORS,
to_native_string,
)
from .compat import (
Mapping,
basestring,
bytes,
getproxies,
getproxies_environment,
integer_types,
is_urllib3_1,
)
from .compat import parse_http_list as _parse_list_header
from .compat import (
proxy_bypass,
proxy_bypass_environment,
quote,
str,
unquote,
urlparse,
urlunparse,
)
from .cookies import cookiejar_from_dict
from .exceptions import (
FileModeWarning,
InvalidHeader,
InvalidURL,
UnrewindableBodyError,
)
from .structures import CaseInsensitiveDict
NETRC_FILES = (".netrc", "_netrc")
DEFAULT_CA_BUNDLE_PATH = certs.where()
DEFAULT_PORTS = {"http": 80, "https": 443}
# Ensure that ', ' is used to preserve previous delimiter behavior.
DEFAULT_ACCEPT_ENCODING = ", ".join(
re.split(r",\s*", make_headers(accept_encoding=True)["accept-encoding"])
)
if sys.platform == "win32":
# provide a proxy_bypass version on Windows without DNS lookups
def proxy_bypass_registry(host):
try:
import winreg
except ImportError:
return False
try:
internetSettings = winreg.OpenKey(
winreg.HKEY_CURRENT_USER,
r"Software\Microsoft\Windows\CurrentVersion\Internet Settings",
)
# ProxyEnable could be REG_SZ or REG_DWORD, normalizing it
proxyEnable = int(winreg.QueryValueEx(internetSettings, "ProxyEnable")[0])
# ProxyOverride is almost always a string
proxyOverride = winreg.QueryValueEx(internetSettings, "ProxyOverride")[0]
except (OSError, ValueError):
return False
if not proxyEnable or not proxyOverride:
return False
# make a check value list from the registry entry: replace the
# '' string by the localhost entry and the corresponding
# canonical entry.
proxyOverride = proxyOverride.split(";")
# filter out empty strings to avoid re.match return true in the following code.
proxyOverride = filter(None, proxyOverride)
# now check if we match one of the registry values.
for test in proxyOverride:
if test == "":
if "." not in host:
return True
test = test.replace(".", r"\.") # mask dots
test = test.replace("*", r".*") # change glob sequence
test = test.replace("?", r".") # change glob char
if re.match(test, host, re.I):
return True
return False
def proxy_bypass(host): # noqa
"""Return True, if the host should be bypassed.
Checks proxy settings gathered from the environment, if specified,
or the registry.
"""
if getproxies_environment():
return proxy_bypass_environment(host)
else:
return proxy_bypass_registry(host)
def dict_to_sequence(d):
"""Returns an internal sequence dictionary update."""
if hasattr(d, "items"):
d = d.items()
return d
def super_len(o):
total_length = None
current_position = 0
if not is_urllib3_1 and isinstance(o, str):
# urllib3 2.x+ treats all strings as utf-8 instead
# of latin-1 (iso-8859-1) like http.client.
o = o.encode("utf-8")
if hasattr(o, "__len__"):
total_length = len(o)
elif hasattr(o, "len"):
total_length = o.len
elif hasattr(o, "fileno"):
try:
fileno = o.fileno()
except (io.UnsupportedOperation, AttributeError):
# AttributeError is a surprising exception, seeing as how we've just checked
# that `hasattr(o, 'fileno')`. It happens for objects obtained via
# `Tarfile.extractfile()`, per issue 5229.
pass
else:
total_length = os.fstat(fileno).st_size
# Having used fstat to determine the file length, we need to
# confirm that this file was opened up in binary mode.
if "b" not in o.mode:
warnings.warn(
(
"Requests has determined the content-length for this "
"request using the binary size of the file: however, the "
"file has been opened in text mode (i.e. without the 'b' "
"flag in the mode). This may lead to an incorrect "
"content-length. In Requests 3.0, support will be removed "
"for files in text mode."
),
FileModeWarning,
)
if hasattr(o, "tell"):
try:
current_position = o.tell()
except OSError:
# This can happen in some weird situations, such as when the file
# is actually a special file descriptor like stdin. In this
# instance, we don't know what the length is, so set it to zero and
# let requests chunk it instead.
if total_length is not None:
current_position = total_length
else:
if hasattr(o, "seek") and total_length is None:
# StringIO and BytesIO have seek but no usable fileno
try:
# seek to end of file
o.seek(0, 2)
total_length = o.tell()
# seek back to current position to support
# partially read file-like objects
o.seek(current_position or 0)
except OSError:
total_length = 0
if total_length is None:
total_length = 0
return max(0, total_length - current_position)
def get_netrc_auth(url, raise_errors=False):
"""Returns the Requests tuple auth for a given url from netrc."""
netrc_file = os.environ.get("NETRC")
if netrc_file is not None:
netrc_locations = (netrc_file,)
else:
netrc_locations = (f"~/{f}" for f in NETRC_FILES)
try:
from netrc import NetrcParseError, netrc
netrc_path = None
for f in netrc_locations:
loc = os.path.expanduser(f)
if os.path.exists(loc):
netrc_path = loc
break
# Abort early if there isn't one.
if netrc_path is None:
return
ri = urlparse(url)
host = ri.hostname
try:
_netrc = netrc(netrc_path).authenticators(host)
if _netrc:
# Return with login / password
login_i = 0 if _netrc[0] else 1
return (_netrc[login_i], _netrc[2])
except (NetrcParseError, OSError):
# If there was a parsing error or a permissions issue reading the file,
# we'll just skip netrc auth unless explicitly asked to raise errors.
if raise_errors:
raise
# App Engine hackiness.
except (ImportError, AttributeError):
pass
def guess_filename(obj):
"""Tries to guess the filename of the given object."""
name = getattr(obj, "name", None)
if name and isinstance(name, basestring) and name[0] != "<" and name[-1] != ">":
return os.path.basename(name)
def extract_zipped_paths(path):
"""Replace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
"""
if os.path.exists(path):
# this is already a valid path, no need to do anything further
return path
# find the first valid part of the provided path and treat that as a zip archive
# assume the rest of the path is the name of a member in the archive
archive, member = os.path.split(path)
while archive and not os.path.exists(archive):
archive, prefix = os.path.split(archive)
if not prefix:
# If we don't check for an empty prefix after the split (in other words, archive remains unchanged after the split),
# we _can_ end up in an infinite loop on a rare corner case affecting a small number of users
break
member = "/".join([prefix, member])
if not zipfile.is_zipfile(archive):
return path
zip_file = zipfile.ZipFile(archive)
if member not in zip_file.namelist():
return path
# we have a valid zip archive and a valid member of that archive
tmp = tempfile.gettempdir()
extracted_path = os.path.join(tmp, member.split("/")[-1])
if not os.path.exists(extracted_path):
# use read + write to avoid the creating nested folders, we only want the file, avoids mkdir racing condition
with atomic_open(extracted_path) as file_handler:
file_handler.write(zip_file.read(member))
return extracted_path
@contextlib.contextmanager
def atomic_open(filename):
"""Write a file to the disk in an atomic fashion"""
tmp_descriptor, tmp_name = tempfile.mkstemp(dir=os.path.dirname(filename))
try:
with os.fdopen(tmp_descriptor, "wb") as tmp_handler:
yield tmp_handler
os.replace(tmp_name, filename)
except BaseException:
os.remove(tmp_name)
raise
def from_key_val_list(value):
"""Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
Traceback (most recent call last):
...
ValueError: cannot encode objects that are not 2-tuples
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
"""
if value is None:
return None
if isinstance(value, (str, bytes, bool, int)):
raise ValueError("cannot encode objects that are not 2-tuples")
return OrderedDict(value)
def to_key_val_list(value):
"""Take an object and test to see if it can be represented as a
dictionary. If it can be, return a list of tuples, e.g.,
::
>>> to_key_val_list([('key', 'val')])
[('key', 'val')]
>>> to_key_val_list({'key': 'val'})
[('key', 'val')]
>>> to_key_val_list('string')
Traceback (most recent call last):
...
ValueError: cannot encode objects that are not 2-tuples
:rtype: list
"""
if value is None:
return None
if isinstance(value, (str, bytes, bool, int)):
raise ValueError("cannot encode objects that are not 2-tuples")
if isinstance(value, Mapping):
value = value.items()
return list(value)
# From mitsuhiko/werkzeug (used with permission).
def parse_list_header(value):
"""Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
"""
result = []
for item in _parse_list_header(value):
if item[:1] == item[-1:] == '"':
item = unquote_header_value(item[1:-1])
result.append(item)
return result
# From mitsuhiko/werkzeug (used with permission).
def parse_dict_header(value):
"""Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
"""
result = {}
for item in _parse_list_header(value):
if "=" not in item:
result[item] = None
continue
name, value = item.split("=", 1)
if value[:1] == value[-1:] == '"':
value = unquote_header_value(value[1:-1])
result[name] = value
return result
# From mitsuhiko/werkzeug (used with permission).
def unquote_header_value(value, is_filename=False):
r"""Unquotes a header value. (Reversal of :func:`quote_header_value`).
This does not use the real unquoting but what browsers are actually
using for quoting.
:param value: the header value to unquote.
:rtype: str
"""
if value and value[0] == value[-1] == '"':
# this is not the real unquoting, but fixing this so that the
# RFC is met will result in bugs with internet explorer and
# probably some other browsers as well. IE for example is
# uploading files with "C:\foo\bar.txt" as filename
value = value[1:-1]
# if this is a filename and the starting characters look like
# a UNC path, then just return the value without quotes. Using the
# replace sequence below on a UNC path has the effect of turning
# the leading double slash into a single slash and then
# _fix_ie_filename() doesn't work correctly. See #458.
if not is_filename or value[:2] != "\\\\":
return value.replace("\\\\", "\\").replace('\\"', '"')
return value
def dict_from_cookiejar(cj):
"""Returns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
"""
cookie_dict = {cookie.name: cookie.value for cookie in cj}
return cookie_dict
def add_dict_to_cookiejar(cj, cookie_dict):
"""Returns a CookieJar from a key/value dictionary.
:param cj: CookieJar to insert cookies into.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:rtype: CookieJar
"""
return cookiejar_from_dict(cookie_dict, cj)
def get_encodings_from_content(content):
"""Returns encodings from given content string.
:param content: bytestring to extract encodings from.
"""
warnings.warn(
(
"In requests 3.0, get_encodings_from_content will be removed. For "
"more information, please see the discussion on issue #2266. (This"
" warning should only appear once.)"
),
DeprecationWarning,
)
charset_re = re.compile(r']', flags=re.I)
pragma_re = re.compile(r']', flags=re.I)
xml_re = re.compile(r'^<\?xml.*?encoding=["\']*(.+?)["\'>]')
return (
charset_re.findall(content)
+ pragma_re.findall(content)
+ xml_re.findall(content)
)
def _parse_content_type_header(header):
"""Returns content type and parameters from given header
:param header: string
:return: tuple containing content type and dictionary of
parameters
"""
tokens = header.split(";")
content_type, params = tokens[0].strip(), tokens[1:]
params_dict = {}
items_to_strip = "\"' "
for param in params:
param = param.strip()
if param:
key, value = param, True
index_of_equals = param.find("=")
if index_of_equals != -1:
key = param[:index_of_equals].strip(items_to_strip)
value = param[index_of_equals + 1 :].strip(items_to_strip)
params_dict[key.lower()] = value
return content_type, params_dict
def get_encoding_from_headers(headers):
"""Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
"""
content_type = headers.get("content-type")
if not content_type:
return None
content_type, params = _parse_content_type_header(content_type)
if "charset" in params:
return params["charset"].strip("'\"")
if "text" in content_type:
return "ISO-8859-1"
if "application/json" in content_type:
# Assume UTF-8 based on RFC 4627: https://www.ietf.org/rfc/rfc4627.txt since the charset was unset
return "utf-8"
def stream_decode_response_unicode(iterator, r):
"""Stream decodes an iterator."""
if r.encoding is None:
yield from iterator
return
decoder = codecs.getincrementaldecoder(r.encoding)(errors="replace")
for chunk in iterator:
rv = decoder.decode(chunk)
if rv:
yield rv
rv = decoder.decode(b"", final=True)
if rv:
yield rv
def iter_slices(string, slice_length):
"""Iterate over slices of a string."""
pos = 0
if slice_length is None or slice_length <= 0:
slice_length = len(string)
while pos < len(string):
yield string[pos : pos + slice_length]
pos += slice_length
def get_unicode_from_response(r):
"""Returns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
"""
warnings.warn(
(
"In requests 3.0, get_unicode_from_response will be removed. For "
"more information, please see the discussion on issue #2266. (This"
" warning should only appear once.)"
),
DeprecationWarning,
)
tried_encodings = []
# Try charset from content-type
encoding = get_encoding_from_headers(r.headers)
if encoding:
try:
return str(r.content, encoding)
except UnicodeError:
tried_encodings.append(encoding)
# Fall back:
try:
return str(r.content, encoding, errors="replace")
except TypeError:
return r.content
# The unreserved URI characters (RFC 3986)
UNRESERVED_SET = frozenset(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789-._~"
)
def unquote_unreserved(uri):
"""Un-escape any percent-escape sequences in a URI that are unreserved
characters. This leaves all reserved, illegal and non-ASCII bytes encoded.
:rtype: str
"""
parts = uri.split("%")
for i in range(1, len(parts)):
h = parts[i][0:2]
if len(h) == 2 and h.isalnum():
try:
c = chr(int(h, 16))
except ValueError:
raise InvalidURL(f"Invalid percent-escape sequence: '{h}'")
if c in UNRESERVED_SET:
parts[i] = c + parts[i][2:]
else:
parts[i] = f"%{parts[i]}"
else:
parts[i] = f"%{parts[i]}"
return "".join(parts)
def requote_uri(uri):
"""Re-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
"""
safe_with_percent = "!#$%&'()*+,/:;=?@[]~"
safe_without_percent = "!#$&'()*+,/:;=?@[]~"
try:
# Unquote only the unreserved characters
# Then quote only illegal characters (do not quote reserved,
# unreserved, or '%')
return quote(unquote_unreserved(uri), safe=safe_with_percent)
except InvalidURL:
# We couldn't unquote the given URI, so let's try quoting it, but
# there may be unquoted '%'s in the URI. We need to make sure they're
# properly quoted so they do not cause issues elsewhere.
return quote(uri, safe=safe_without_percent)
def address_in_network(ip, net):
"""This function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
"""
ipaddr = struct.unpack("=L", socket.inet_aton(ip))[0]
netaddr, bits = net.split("/")
netmask = struct.unpack("=L", socket.inet_aton(dotted_netmask(int(bits))))[0]
network = struct.unpack("=L", socket.inet_aton(netaddr))[0] & netmask
return (ipaddr & netmask) == (network & netmask)
def dotted_netmask(mask):
"""Converts mask from /xx format to xxx.xxx.xxx.xxx
Example: if mask is 24 function returns 255.255.255.0
:rtype: str
"""
bits = 0xFFFFFFFF ^ (1 << 32 - mask) - 1
return socket.inet_ntoa(struct.pack(">I", bits))
def is_ipv4_address(string_ip):
"""
:rtype: bool
"""
try:
socket.inet_aton(string_ip)
except OSError:
return False
return True
def is_valid_cidr(string_network):
"""
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
"""
if string_network.count("/") == 1:
try:
mask = int(string_network.split("/")[1])
except ValueError:
return False
if mask < 1 or mask > 32:
return False
try:
socket.inet_aton(string_network.split("/")[0])
except OSError:
return False
else:
return False
return True
@contextlib.contextmanager
def set_environ(env_name, value):
"""Set the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothing"""
value_changed = value is not None
if value_changed:
old_value = os.environ.get(env_name)
os.environ[env_name] = value
try:
yield
finally:
if value_changed:
if old_value is None:
del os.environ[env_name]
else:
os.environ[env_name] = old_value
def should_bypass_proxies(url, no_proxy):
"""
Returns whether we should bypass proxies or not.
:rtype: bool
"""
# Prioritize lowercase environment variables over uppercase
# to keep a consistent behaviour with other http projects (curl, wget).
def get_proxy(key):
return os.environ.get(key) or os.environ.get(key.upper())
# First check whether no_proxy is defined. If it is, check that the URL
# we're getting isn't in the no_proxy list.
no_proxy_arg = no_proxy
if no_proxy is None:
no_proxy = get_proxy("no_proxy")
parsed = urlparse(url)
if parsed.hostname is None:
# URLs don't always have hostnames, e.g. file:/// urls.
return True
if no_proxy:
# We need to check whether we match here. We need to see if we match
# the end of the hostname, both with and without the port.
no_proxy = (host for host in no_proxy.replace(" ", "").split(",") if host)
if is_ipv4_address(parsed.hostname):
for proxy_ip in no_proxy:
if is_valid_cidr(proxy_ip):
if address_in_network(parsed.hostname, proxy_ip):
return True
elif parsed.hostname == proxy_ip:
# If no_proxy ip was defined in plain IP notation instead of cidr notation &
# matches the IP of the index
return True
else:
host_with_port = parsed.hostname
if parsed.port:
host_with_port += f":{parsed.port}"
for host in no_proxy:
if parsed.hostname.endswith(host) or host_with_port.endswith(host):
# The URL does match something in no_proxy, so we don't want
# to apply the proxies on this URL.
return True
with set_environ("no_proxy", no_proxy_arg):
# parsed.hostname can be `None` in cases such as a file URI.
try:
bypass = proxy_bypass(parsed.hostname)
except (TypeError, socket.gaierror):
bypass = False
if bypass:
return True
return False
def get_environ_proxies(url, no_proxy=None):
"""
Return a dict of environment proxies.
:rtype: dict
"""
if should_bypass_proxies(url, no_proxy=no_proxy):
return {}
else:
return getproxies()
def select_proxy(url, proxies):
"""Select a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
"""
proxies = proxies or {}
urlparts = urlparse(url)
if urlparts.hostname is None:
return proxies.get(urlparts.scheme, proxies.get("all"))
proxy_keys = [
urlparts.scheme + "://" + urlparts.hostname,
urlparts.scheme,
"all://" + urlparts.hostname,
"all",
]
proxy = None
for proxy_key in proxy_keys:
if proxy_key in proxies:
proxy = proxies[proxy_key]
break
return proxy
def resolve_proxies(request, proxies, trust_env=True):
"""This method takes proxy information from a request and configuration
input to resolve a mapping of target proxies. This will consider settings
such as NO_PROXY to strip proxy configurations.
:param request: Request or PreparedRequest
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
:param trust_env: Boolean declaring whether to trust environment configs
:rtype: dict
"""
proxies = proxies if proxies is not None else {}
url = request.url
scheme = urlparse(url).scheme
no_proxy = proxies.get("no_proxy")
new_proxies = proxies.copy()
if trust_env and not should_bypass_proxies(url, no_proxy=no_proxy):
environ_proxies = get_environ_proxies(url, no_proxy=no_proxy)
proxy = environ_proxies.get(scheme, environ_proxies.get("all"))
if proxy:
new_proxies.setdefault(scheme, proxy)
return new_proxies
def default_user_agent(name="python-requests"):
"""
Return a string representing the default user agent.
:rtype: str
"""
return f"{name}/{__version__}"
def default_headers():
"""
:rtype: requests.structures.CaseInsensitiveDict
"""
return CaseInsensitiveDict(
{
"User-Agent": default_user_agent(),
"Accept-Encoding": DEFAULT_ACCEPT_ENCODING,
"Accept": "*/*",
"Connection": "keep-alive",
}
)
def parse_header_links(value):
"""Return a list of parsed link headers proxies.
i.e. Link: ; rel=front; type="image/jpeg",; rel=back;type="image/jpeg"
:rtype: list
"""
links = []
replace_chars = " '\""
value = value.strip(replace_chars)
if not value:
return links
for val in re.split(", *<", value):
try:
url, params = val.split(";", 1)
except ValueError:
url, params = val, ""
link = {"url": url.strip("<> '\"")}
for param in params.split(";"):
try:
key, value = param.split("=")
except ValueError:
break
link[key.strip(replace_chars)] = value.strip(replace_chars)
links.append(link)
return links
# Null bytes; no need to recreate these on each call to guess_json_utf
_null = "\x00".encode("ascii") # encoding to ASCII for Python 3
_null2 = _null * 2
_null3 = _null * 3
def guess_json_utf(data):
"""
:rtype: str
"""
# JSON always starts with two ASCII characters, so detection is as
# easy as counting the nulls and from their location and count
# determine the encoding. Also detect a BOM, if present.
sample = data[:4]
if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE):
return "utf-32" # BOM included
if sample[:3] == codecs.BOM_UTF8:
return "utf-8-sig" # BOM included, MS style (discouraged)
if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE):
return "utf-16" # BOM included
nullcount = sample.count(_null)
if nullcount == 0:
return "utf-8"
if nullcount == 2:
if sample[::2] == _null2: # 1st and 3rd are null
return "utf-16-be"
if sample[1::2] == _null2: # 2nd and 4th are null
return "utf-16-le"
# Did not detect 2 valid UTF-16 ascii-range characters
if nullcount == 3:
if sample[:3] == _null3:
return "utf-32-be"
if sample[1:] == _null3:
return "utf-32-le"
# Did not detect a valid UTF-32 ascii-range character
return None
def prepend_scheme_if_needed(url, new_scheme):
"""Given a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
"""
parsed = parse_url(url)
scheme, auth, host, port, path, query, fragment = parsed
# A defect in urlparse determines that there isn't a netloc present in some
# urls. We previously assumed parsing was overly cautious, and swapped the
# netloc and path. Due to a lack of tests on the original defect, this is
# maintained with parse_url for backwards compatibility.
netloc = parsed.netloc
if not netloc:
netloc, path = path, netloc
if auth:
# parse_url doesn't provide the netloc with auth
# so we'll add it ourselves.
netloc = "@".join([auth, netloc])
if scheme is None:
scheme = new_scheme
if path is None:
path = ""
return urlunparse((scheme, netloc, path, "", query, fragment))
def get_auth_from_url(url):
"""Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
"""
parsed = urlparse(url)
try:
auth = (unquote(parsed.username), unquote(parsed.password))
except (AttributeError, TypeError):
auth = ("", "")
return auth
def check_header_validity(header):
"""Verifies that header parts don't contain leading whitespace
reserved characters, or return characters.
:param header: tuple, in the format (name, value).
"""
name, value = header
_validate_header_part(header, name, 0)
_validate_header_part(header, value, 1)
def _validate_header_part(header, header_part, header_validator_index):
if isinstance(header_part, str):
validator = _HEADER_VALIDATORS_STR[header_validator_index]
elif isinstance(header_part, bytes):
validator = _HEADER_VALIDATORS_BYTE[header_validator_index]
else:
raise InvalidHeader(
f"Header part ({header_part!r}) from {header} "
f"must be of type str or bytes, not {type(header_part)}"
)
if not validator.match(header_part):
header_kind = "name" if header_validator_index == 0 else "value"
raise InvalidHeader(
f"Invalid leading whitespace, reserved character(s), or return "
f"character(s) in header {header_kind}: {header_part!r}"
)
def urldefragauth(url):
"""
Given a url remove the fragment and the authentication part.
:rtype: str
"""
scheme, netloc, path, params, query, fragment = urlparse(url)
# see func:`prepend_scheme_if_needed`
if not netloc:
netloc, path = path, netloc
netloc = netloc.rsplit("@", 1)[-1]
return urlunparse((scheme, netloc, path, params, query, ""))
def rewind_body(prepared_request):
"""Move file pointer back to its recorded starting position
so it can be read again on redirect.
"""
body_seek = getattr(prepared_request.body, "seek", None)
if body_seek is not None and isinstance(
prepared_request._body_position, integer_types
):
try:
body_seek(prepared_request._body_position)
except OSError:
raise UnrewindableBodyError(
"An error occurred when rewinding request body for redirect."
)
else:
raise UnrewindableBodyError("Unable to rewind request body for redirect.")
PK !
# __init__.pynu [ # __
# /__) _ _ _ _ _/ _
# / ( (- (/ (/ (- _) / _)
# /
"""
Requests HTTP Library
~~~~~~~~~~~~~~~~~~~~~
Requests is an HTTP library, written in Python, for human beings.
Basic GET usage:
>>> import requests
>>> r = requests.get('https://www.python.org')
>>> r.status_code
200
>>> b'Python is a programming language' in r.content
True
... or POST:
>>> payload = dict(key1='value1', key2='value2')
>>> r = requests.post('https://httpbin.org/post', data=payload)
>>> print(r.text)
{
...
"form": {
"key1": "value1",
"key2": "value2"
},
...
}
The other HTTP methods are supported - see `requests.api`. Full documentation
is at .
:copyright: (c) 2017 by Kenneth Reitz.
:license: Apache 2.0, see LICENSE for more details.
"""
import warnings
from pip._vendor import urllib3
from .exceptions import RequestsDependencyWarning
charset_normalizer_version = None
chardet_version = None
def check_compatibility(urllib3_version, chardet_version, charset_normalizer_version):
urllib3_version = urllib3_version.split(".")
assert urllib3_version != ["dev"] # Verify urllib3 isn't installed from git.
# Sometimes, urllib3 only reports its version as 16.1.
if len(urllib3_version) == 2:
urllib3_version.append("0")
# Check urllib3 for compatibility.
major, minor, patch = urllib3_version # noqa: F811
major, minor, patch = int(major), int(minor), int(patch)
# urllib3 >= 1.21.1
assert major >= 1
if major == 1:
assert minor >= 21
# Check charset_normalizer for compatibility.
if chardet_version:
major, minor, patch = chardet_version.split(".")[:3]
major, minor, patch = int(major), int(minor), int(patch)
# chardet_version >= 3.0.2, < 6.0.0
assert (3, 0, 2) <= (major, minor, patch) < (6, 0, 0)
elif charset_normalizer_version:
major, minor, patch = charset_normalizer_version.split(".")[:3]
major, minor, patch = int(major), int(minor), int(patch)
# charset_normalizer >= 2.0.0 < 4.0.0
assert (2, 0, 0) <= (major, minor, patch) < (4, 0, 0)
else:
# pip does not need or use character detection
pass
def _check_cryptography(cryptography_version):
# cryptography < 1.3.4
try:
cryptography_version = list(map(int, cryptography_version.split(".")))
except ValueError:
return
if cryptography_version < [1, 3, 4]:
warning = "Old version of cryptography ({}) may cause slowdown.".format(
cryptography_version
)
warnings.warn(warning, RequestsDependencyWarning)
# Check imported dependencies for compatibility.
try:
check_compatibility(
urllib3.__version__, chardet_version, charset_normalizer_version
)
except (AssertionError, ValueError):
warnings.warn(
"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported "
"version!".format(
urllib3.__version__, chardet_version, charset_normalizer_version
),
RequestsDependencyWarning,
)
# Attempt to enable urllib3's fallback for SNI support
# if the standard library doesn't support SNI or the
# 'ssl' library isn't available.
try:
# Note: This logic prevents upgrading cryptography on Windows, if imported
# as part of pip.
from pip._internal.utils.compat import WINDOWS
if not WINDOWS:
raise ImportError("pip internals: don't import cryptography on Windows")
try:
import ssl
except ImportError:
ssl = None
if not getattr(ssl, "HAS_SNI", False):
from pip._vendor.urllib3.contrib import pyopenssl
pyopenssl.inject_into_urllib3()
# Check cryptography version
from cryptography import __version__ as cryptography_version
_check_cryptography(cryptography_version)
except ImportError:
pass
# urllib3's DependencyWarnings should be silenced.
from pip._vendor.urllib3.exceptions import DependencyWarning
warnings.simplefilter("ignore", DependencyWarning)
# Set default logging handler to avoid "No handler found" warnings.
import logging
from logging import NullHandler
from . import packages, utils
from .__version__ import (
__author__,
__author_email__,
__build__,
__cake__,
__copyright__,
__description__,
__license__,
__title__,
__url__,
__version__,
)
from .api import delete, get, head, options, patch, post, put, request
from .exceptions import (
ConnectionError,
ConnectTimeout,
FileModeWarning,
HTTPError,
JSONDecodeError,
ReadTimeout,
RequestException,
Timeout,
TooManyRedirects,
URLRequired,
)
from .models import PreparedRequest, Request, Response
from .sessions import Session, session
from .status_codes import codes
logging.getLogger(__name__).addHandler(NullHandler())
# FileModeWarnings go off per the default.
warnings.simplefilter("default", FileModeWarning, append=True)
PK ! [ۀ _types.pynu [ """
requests._types
~~~~~~~~~~~~~~~
This module contains type aliases used internally by the Requests library.
These types are not part of the public API and must not be relied upon
by external code.
"""
from __future__ import annotations
from collections.abc import Callable, Iterable, Mapping, MutableMapping, Sequence
from typing import (
TYPE_CHECKING,
Any,
Protocol,
TypeAlias,
TypeVar,
runtime_checkable,
)
_T_co = TypeVar("_T_co", covariant=True)
_KT_co = TypeVar("_KT_co", covariant=True)
_VT_co = TypeVar("_VT_co", covariant=True)
@runtime_checkable
class SupportsRead(Protocol[_T_co]):
def read(self, length: int = ..., /) -> _T_co: ...
@runtime_checkable
class SupportsItems(Protocol[_KT_co, _VT_co]):
def items(self) -> Iterable[tuple[_KT_co, _VT_co]]: ...
# These are needed at runtime for default_hooks() return type
HookType: TypeAlias = Callable[["Response"], Any]
HooksInputType: TypeAlias = Mapping[str, Iterable[HookType] | HookType]
def is_prepared(request: PreparedRequest) -> TypeIs[_ValidatedRequest]:
"""Verify a PreparedRequest has been fully prepared."""
if TYPE_CHECKING:
return request.url is not None and request.method is not None
# noop at runtime to avoid AssertionError
return True
if TYPE_CHECKING:
from http.cookiejar import CookieJar
from typing import TypeAlias, TypedDict
from typing_extensions import (
Buffer, # TODO: move to collections.abc when Python >= 3.12
TypeIs, # TODO: move to typing when Python >= 3.13
)
from .auth import AuthBase
from .cookies import RequestsCookieJar
from .models import PreparedRequest, Response
from .structures import CaseInsensitiveDict
class _ValidatedRequest(PreparedRequest):
"""Subtype asserting a PreparedRequest has been fully prepared before calling.
The override suppression is required because mutable attribute types are
invariant (Liskov), but we only narrow after preparation is complete. This
is the explicit contract for Requests but Python's typing doesn't have a
better way to represent the requirement.
"""
url: str # type: ignore[reportIncompatibleVariableOverride]
method: str # type: ignore[reportIncompatibleVariableOverride]
# Type aliases for core API concepts (ordered by request() signature)
UriType: TypeAlias = str | bytes
_ParamsMappingKeyType: TypeAlias = str | bytes | int | float
_ParamsMappingValueType: TypeAlias = (
str | bytes | int | float | Iterable[str | bytes | int | float] | None
)
ParamsType: TypeAlias = (
SupportsItems[_ParamsMappingKeyType, _ParamsMappingValueType]
| tuple[tuple[_ParamsMappingKeyType, _ParamsMappingValueType], ...]
| Iterable[tuple[_ParamsMappingKeyType, _ParamsMappingValueType]]
| str
| bytes
| None
)
KVDataType: TypeAlias = Iterable[tuple[Any, Any]] | SupportsItems[Any, Any]
RawDataType: TypeAlias = KVDataType | str | bytes
StreamDataType: TypeAlias = SupportsRead[str | bytes]
EncodableDataType: TypeAlias = RawDataType | StreamDataType
DataType: TypeAlias = (
KVDataType
| Iterable[bytes | str]
| str
| bytes
| Buffer
| SupportsRead[str | bytes]
| None
)
BodyType: TypeAlias = (
bytes | str | Iterable[bytes | str] | SupportsRead[bytes | str] | None
)
HeadersType: TypeAlias = Mapping[str, str | bytes] | None
CookiesType: TypeAlias = RequestsCookieJar | Mapping[str, str]
# Building blocks for FilesType
_FileName: TypeAlias = str | None
_FileContent: TypeAlias = SupportsRead[str | bytes] | str | bytes
_FileSpecBasic: TypeAlias = tuple[_FileName, _FileContent]
_FileSpecWithContentType: TypeAlias = tuple[_FileName, _FileContent, str]
_FileSpecWithHeaders: TypeAlias = tuple[
_FileName, _FileContent, str, CaseInsensitiveDict[str] | Mapping[str, str]
]
_FileSpec: TypeAlias = (
_FileContent | _FileSpecBasic | _FileSpecWithContentType | _FileSpecWithHeaders
)
FilesType: TypeAlias = (
Mapping[str, _FileSpec] | Iterable[tuple[str, _FileSpec]] | None
)
AuthType: TypeAlias = (
tuple[str, str] | AuthBase | Callable[[PreparedRequest], PreparedRequest] | None
)
TimeoutType: TypeAlias = float | tuple[float | None, float | None] | None
ProxiesType: TypeAlias = MutableMapping[str, str]
HooksType: TypeAlias = dict[str, list[HookType]] | None
VerifyType: TypeAlias = bool | str
CertType: TypeAlias = str | tuple[str, str] | None
JsonType: TypeAlias = (
None
| bool
| int
| float
| str
| Sequence["JsonType"]
| Mapping[str, "JsonType"]
)
# TypedDicts for Unpack kwargs (PEP 692)
class BaseRequestKwargs(TypedDict, total=False):
headers: HeadersType
cookies: RequestsCookieJar | CookieJar | dict[str, str] | None
files: FilesType
auth: AuthType
timeout: TimeoutType
allow_redirects: bool
proxies: dict[str, str] | None
hooks: HooksInputType | None
stream: bool | None
verify: VerifyType | None
cert: CertType
class RequestKwargs(BaseRequestKwargs, total=False):
"""kwargs for request(), options(), head(), delete()."""
params: ParamsType
data: DataType
json: JsonType
class GetKwargs(BaseRequestKwargs, total=False):
data: DataType
json: JsonType
class PostKwargs(BaseRequestKwargs, total=False):
params: ParamsType
class DataKwargs(BaseRequestKwargs, total=False):
"""kwargs for put(), patch()."""
params: ParamsType
json: JsonType
PK ! Ie status_codes.pynu [ r"""
The ``codes`` object defines a mapping from common names for HTTP statuses
to their numerical codes, accessible either as attributes or as dictionary
items.
Example::
>>> import requests
>>> requests.codes['temporary_redirect']
307
>>> requests.codes.teapot
418
>>> requests.codes['\o/']
200
Some codes have multiple names, and both upper- and lower-case versions of
the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
``codes.okay`` all correspond to the HTTP status code 200.
"""
from .structures import LookupDict
_codes = {
# Informational.
100: ("continue",),
101: ("switching_protocols",),
102: ("processing", "early-hints"),
103: ("checkpoint",),
122: ("uri_too_long", "request_uri_too_long"),
200: ("ok", "okay", "all_ok", "all_okay", "all_good", "\\o/", "✓"),
201: ("created",),
202: ("accepted",),
203: ("non_authoritative_info", "non_authoritative_information"),
204: ("no_content",),
205: ("reset_content", "reset"),
206: ("partial_content", "partial"),
207: ("multi_status", "multiple_status", "multi_stati", "multiple_stati"),
208: ("already_reported",),
226: ("im_used",),
# Redirection.
300: ("multiple_choices",),
301: ("moved_permanently", "moved", "\\o-"),
302: ("found",),
303: ("see_other", "other"),
304: ("not_modified",),
305: ("use_proxy",),
306: ("switch_proxy",),
307: ("temporary_redirect", "temporary_moved", "temporary"),
308: (
"permanent_redirect",
"resume_incomplete",
"resume",
), # "resume" and "resume_incomplete" to be removed in 3.0
# Client Error.
400: ("bad_request", "bad"),
401: ("unauthorized",),
402: ("payment_required", "payment"),
403: ("forbidden",),
404: ("not_found", "-o-"),
405: ("method_not_allowed", "not_allowed"),
406: ("not_acceptable",),
407: ("proxy_authentication_required", "proxy_auth", "proxy_authentication"),
408: ("request_timeout", "timeout"),
409: ("conflict",),
410: ("gone",),
411: ("length_required",),
412: ("precondition_failed", "precondition"),
413: ("request_entity_too_large", "content_too_large"),
414: ("request_uri_too_large", "uri_too_long"),
415: ("unsupported_media_type", "unsupported_media", "media_type"),
416: (
"requested_range_not_satisfiable",
"requested_range",
"range_not_satisfiable",
),
417: ("expectation_failed",),
418: ("im_a_teapot", "teapot", "i_am_a_teapot"),
421: ("misdirected_request",),
422: ("unprocessable_entity", "unprocessable", "unprocessable_content"),
423: ("locked",),
424: ("failed_dependency", "dependency"),
425: ("unordered_collection", "unordered", "too_early"),
426: ("upgrade_required", "upgrade"),
428: ("precondition_required", "precondition"),
429: ("too_many_requests", "too_many"),
431: ("header_fields_too_large", "fields_too_large"),
444: ("no_response", "none"),
449: ("retry_with", "retry"),
450: ("blocked_by_windows_parental_controls", "parental_controls"),
451: ("unavailable_for_legal_reasons", "legal_reasons"),
499: ("client_closed_request",),
# Server Error.
500: ("internal_server_error", "server_error", "/o\\", "✗"),
501: ("not_implemented",),
502: ("bad_gateway",),
503: ("service_unavailable", "unavailable"),
504: ("gateway_timeout",),
505: ("http_version_not_supported", "http_version"),
506: ("variant_also_negotiates",),
507: ("insufficient_storage",),
509: ("bandwidth_limit_exceeded", "bandwidth"),
510: ("not_extended",),
511: ("network_authentication_required", "network_auth", "network_authentication"),
}
codes = LookupDict(name="status_codes")
def _init():
for code, titles in _codes.items():
for title in titles:
setattr(codes, title, code)
if not title.startswith(("\\", "/")):
setattr(codes, title.upper(), code)
def doc(code):
names = ", ".join(f"``{n}``" for n in _codes[code])
return "* %d: %s" % (code, names)
global __doc__
__doc__ = (
__doc__ + "\n" + "\n".join(doc(code) for code in sorted(_codes))
if __doc__ is not None
else None
)
_init()
PK ! V! ! packages.pynu [ import sys
from .compat import chardet
# This code exists for backwards compatibility reasons.
# I don't like it either. Just look the other way. :)
for package in ("urllib3", "idna"):
vendored_package = "pip._vendor." + package
locals()[package] = __import__(vendored_package)
# This traversal is apparently necessary such that the identities are
# preserved (requests.packages.urllib3.* is urllib3.*)
for mod in list(sys.modules):
if mod == vendored_package or mod.startswith(vendored_package + '.'):
unprefixed_mod = mod[len("pip._vendor."):]
sys.modules['pip._vendor.requests.packages.' + unprefixed_mod] = sys.modules[mod]
if chardet is not None:
target = chardet.__name__
for mod in list(sys.modules):
if mod == target or mod.startswith(f"{target}."):
imported_mod = sys.modules[mod]
sys.modules[f"requests.packages.{mod}"] = imported_mod
mod = mod.replace(target, "chardet")
sys.modules[f"requests.packages.{mod}"] = imported_mod
PK ! ؞H H
cookies.pynu [ """
requests.cookies
~~~~~~~~~~~~~~~~
Compatibility code to be able to use `http.cookiejar.CookieJar` with requests.
requests.utils imports from here, so be careful with imports.
"""
import calendar
import copy
import time
from ._internal_utils import to_native_string
from .compat import Morsel, MutableMapping, cookielib, urlparse, urlunparse
try:
import threading
except ImportError:
import dummy_threading as threading
class MockRequest:
"""Wraps a `requests.Request` to mimic a `urllib2.Request`.
The code in `http.cookiejar.CookieJar` expects this interface in order to correctly
manage cookie policies, i.e., determine whether a cookie can be set, given the
domains of the request and the cookie.
The original request object is read-only. The client is responsible for collecting
the new headers via `get_new_headers()` and interpreting them appropriately. You
probably want `get_cookie_header`, defined below.
"""
def __init__(self, request):
self._r = request
self._new_headers = {}
self.type = urlparse(self._r.url).scheme
def get_type(self):
return self.type
def get_host(self):
return urlparse(self._r.url).netloc
def get_origin_req_host(self):
return self.get_host()
def get_full_url(self):
# Only return the response's URL if the user hadn't set the Host
# header
if not self._r.headers.get("Host"):
return self._r.url
# If they did set it, retrieve it and reconstruct the expected domain
host = to_native_string(self._r.headers["Host"], encoding="utf-8")
parsed = urlparse(self._r.url)
# Reconstruct the URL as we expect it
return urlunparse(
[
parsed.scheme,
host,
parsed.path,
parsed.params,
parsed.query,
parsed.fragment,
]
)
def is_unverifiable(self):
return True
def has_header(self, name):
return name in self._r.headers or name in self._new_headers
def get_header(self, name, default=None):
return self._r.headers.get(name, self._new_headers.get(name, default))
def add_header(self, key, val):
"""cookiejar has no legitimate use for this method; add it back if you find one."""
raise NotImplementedError(
"Cookie headers should be added with add_unredirected_header()"
)
def add_unredirected_header(self, name, value):
self._new_headers[name] = value
def get_new_headers(self):
return self._new_headers
@property
def unverifiable(self):
return self.is_unverifiable()
@property
def origin_req_host(self):
return self.get_origin_req_host()
@property
def host(self):
return self.get_host()
class MockResponse:
"""Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`.
...what? Basically, expose the parsed HTTP headers from the server response
the way `http.cookiejar` expects to see them.
"""
def __init__(self, headers):
"""Make a MockResponse for `cookiejar` to read.
:param headers: a httplib.HTTPMessage or analogous carrying the headers
"""
self._headers = headers
def info(self):
return self._headers
def getheaders(self, name):
self._headers.getheaders(name)
def extract_cookies_to_jar(jar, request, response):
"""Extract the cookies from the response into a CookieJar.
:param jar: http.cookiejar.CookieJar (not necessarily a RequestsCookieJar)
:param request: our own requests.Request object
:param response: urllib3.HTTPResponse object
"""
if not (hasattr(response, "_original_response") and response._original_response):
return
# the _original_response field is the wrapped httplib.HTTPResponse object,
req = MockRequest(request)
# pull out the HTTPMessage with the headers and put it in the mock:
res = MockResponse(response._original_response.msg)
jar.extract_cookies(res, req)
def get_cookie_header(jar, request):
"""
Produce an appropriate Cookie header string to be sent with `request`, or None.
:rtype: str
"""
r = MockRequest(request)
jar.add_cookie_header(r)
return r.get_new_headers().get("Cookie")
def remove_cookie_by_name(cookiejar, name, domain=None, path=None):
"""Unsets a cookie by name, by default over all domains and paths.
Wraps CookieJar.clear(), is O(n).
"""
clearables = []
for cookie in cookiejar:
if cookie.name != name:
continue
if domain is not None and domain != cookie.domain:
continue
if path is not None and path != cookie.path:
continue
clearables.append((cookie.domain, cookie.path, cookie.name))
for domain, path, name in clearables:
cookiejar.clear(domain, path, name)
class CookieConflictError(RuntimeError):
"""There are two cookies that meet the criteria specified in the cookie jar.
Use .get and .set and include domain and path args in order to be more specific.
"""
class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
"""Compatibility class; is a http.cookiejar.CookieJar, but exposes a dict
interface.
This is the CookieJar we create by default for requests and sessions that
don't specify one, since some clients may expect response.cookies and
session.cookies to support dict operations.
Requests does not use the dict interface internally; it's just for
compatibility with external client code. All requests code should work
out of the box with externally provided instances of ``CookieJar``, e.g.
``LWPCookieJar`` and ``FileCookieJar``.
Unlike a regular CookieJar, this class is pickleable.
.. warning:: dictionary operations that are normally O(1) may be O(n).
"""
def get(self, name, default=None, domain=None, path=None):
"""Dict-like get() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
.. warning:: operation is O(n), not O(1).
"""
try:
return self._find_no_duplicates(name, domain, path)
except KeyError:
return default
def set(self, name, value, **kwargs):
"""Dict-like set() that also supports optional domain and path args in
order to resolve naming collisions from using one cookie jar over
multiple domains.
"""
# support client code that unsets cookies by assignment of a None value:
if value is None:
remove_cookie_by_name(
self, name, domain=kwargs.get("domain"), path=kwargs.get("path")
)
return
if isinstance(value, Morsel):
c = morsel_to_cookie(value)
else:
c = create_cookie(name, value, **kwargs)
self.set_cookie(c)
return c
def iterkeys(self):
"""Dict-like iterkeys() that returns an iterator of names of cookies
from the jar.
.. seealso:: itervalues() and iteritems().
"""
for cookie in iter(self):
yield cookie.name
def keys(self):
"""Dict-like keys() that returns a list of names of cookies from the
jar.
.. seealso:: values() and items().
"""
return list(self.iterkeys())
def itervalues(self):
"""Dict-like itervalues() that returns an iterator of values of cookies
from the jar.
.. seealso:: iterkeys() and iteritems().
"""
for cookie in iter(self):
yield cookie.value
def values(self):
"""Dict-like values() that returns a list of values of cookies from the
jar.
.. seealso:: keys() and items().
"""
return list(self.itervalues())
def iteritems(self):
"""Dict-like iteritems() that returns an iterator of name-value tuples
from the jar.
.. seealso:: iterkeys() and itervalues().
"""
for cookie in iter(self):
yield cookie.name, cookie.value
def items(self):
"""Dict-like items() that returns a list of name-value tuples from the
jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a
vanilla python dict of key value pairs.
.. seealso:: keys() and values().
"""
return list(self.iteritems())
def list_domains(self):
"""Utility method to list all the domains in the jar."""
domains = []
for cookie in iter(self):
if cookie.domain not in domains:
domains.append(cookie.domain)
return domains
def list_paths(self):
"""Utility method to list all the paths in the jar."""
paths = []
for cookie in iter(self):
if cookie.path not in paths:
paths.append(cookie.path)
return paths
def multiple_domains(self):
"""Returns True if there are multiple domains in the jar.
Returns False otherwise.
:rtype: bool
"""
domains = []
for cookie in iter(self):
if cookie.domain is not None and cookie.domain in domains:
return True
domains.append(cookie.domain)
return False # there is only one domain in jar
def get_dict(self, domain=None, path=None):
"""Takes as an argument an optional domain and path and returns a plain
old Python dict of name-value pairs of cookies that meet the
requirements.
:rtype: dict
"""
dictionary = {}
for cookie in iter(self):
if (domain is None or cookie.domain == domain) and (
path is None or cookie.path == path
):
dictionary[cookie.name] = cookie.value
return dictionary
def __contains__(self, name):
try:
return super().__contains__(name)
except CookieConflictError:
return True
def __getitem__(self, name):
"""Dict-like __getitem__() for compatibility with client code. Throws
exception if there are more than one cookie with name. In that case,
use the more explicit get() method instead.
.. warning:: operation is O(n), not O(1).
"""
return self._find_no_duplicates(name)
def __setitem__(self, name, value):
"""Dict-like __setitem__ for compatibility with client code. Throws
exception if there is already a cookie of that name in the jar. In that
case, use the more explicit set() method instead.
"""
self.set(name, value)
def __delitem__(self, name):
"""Deletes a cookie given a name. Wraps ``http.cookiejar.CookieJar``'s
``remove_cookie_by_name()``.
"""
remove_cookie_by_name(self, name)
def set_cookie(self, cookie, *args, **kwargs):
if (
hasattr(cookie.value, "startswith")
and cookie.value.startswith('"')
and cookie.value.endswith('"')
):
cookie.value = cookie.value.replace('\\"', "")
return super().set_cookie(cookie, *args, **kwargs)
def update(self, other):
"""Updates this jar with cookies from another CookieJar or dict-like"""
if isinstance(other, cookielib.CookieJar):
for cookie in other:
self.set_cookie(copy.copy(cookie))
else:
super().update(other)
def _find(self, name, domain=None, path=None):
"""Requests uses this method internally to get cookie values.
If there are conflicting cookies, _find arbitrarily chooses one.
See _find_no_duplicates if you want an exception thrown if there are
conflicting cookies.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:return: cookie.value
"""
for cookie in iter(self):
if cookie.name == name:
if domain is None or cookie.domain == domain:
if path is None or cookie.path == path:
return cookie.value
raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}")
def _find_no_duplicates(self, name, domain=None, path=None):
"""Both ``__get_item__`` and ``get`` call this function: it's never
used elsewhere in Requests.
:param name: a string containing name of cookie
:param domain: (optional) string containing domain of cookie
:param path: (optional) string containing path of cookie
:raises KeyError: if cookie is not found
:raises CookieConflictError: if there are multiple cookies
that match name and optionally domain and path
:return: cookie.value
"""
toReturn = None
for cookie in iter(self):
if cookie.name == name:
if domain is None or cookie.domain == domain:
if path is None or cookie.path == path:
if toReturn is not None:
# if there are multiple cookies that meet passed in criteria
raise CookieConflictError(
f"There are multiple cookies with name, {name!r}"
)
# we will eventually return this as long as no cookie conflict
toReturn = cookie.value
if toReturn:
return toReturn
raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}")
def __getstate__(self):
"""Unlike a normal CookieJar, this class is pickleable."""
state = self.__dict__.copy()
# remove the unpickleable RLock object
state.pop("_cookies_lock")
return state
def __setstate__(self, state):
"""Unlike a normal CookieJar, this class is pickleable."""
self.__dict__.update(state)
if "_cookies_lock" not in self.__dict__:
self._cookies_lock = threading.RLock()
def copy(self):
"""Return a copy of this RequestsCookieJar."""
new_cj = RequestsCookieJar()
new_cj.set_policy(self.get_policy())
new_cj.update(self)
return new_cj
def get_policy(self):
"""Return the CookiePolicy instance used."""
return self._policy
def _copy_cookie_jar(jar):
if jar is None:
return None
if hasattr(jar, "copy"):
# We're dealing with an instance of RequestsCookieJar
return jar.copy()
# We're dealing with a generic CookieJar instance
new_jar = copy.copy(jar)
new_jar.clear()
for cookie in jar:
new_jar.set_cookie(copy.copy(cookie))
return new_jar
def create_cookie(name, value, **kwargs):
"""Make a cookie from underspecified parameters.
By default, the pair of `name` and `value` will be set for the domain ''
and sent on every request (this is sometimes called a "supercookie").
"""
result = {
"version": 0,
"name": name,
"value": value,
"port": None,
"domain": "",
"path": "/",
"secure": False,
"expires": None,
"discard": True,
"comment": None,
"comment_url": None,
"rest": {"HttpOnly": None},
"rfc2109": False,
}
badargs = set(kwargs) - set(result)
if badargs:
raise TypeError(
f"create_cookie() got unexpected keyword arguments: {list(badargs)}"
)
result.update(kwargs)
result["port_specified"] = bool(result["port"])
result["domain_specified"] = bool(result["domain"])
result["domain_initial_dot"] = result["domain"].startswith(".")
result["path_specified"] = bool(result["path"])
return cookielib.Cookie(**result)
def morsel_to_cookie(morsel):
"""Convert a Morsel object into a Cookie containing the one k/v pair."""
expires = None
if morsel["max-age"]:
try:
expires = int(time.time() + int(morsel["max-age"]))
except ValueError:
raise TypeError(f"max-age: {morsel['max-age']} must be integer")
elif morsel["expires"]:
time_template = "%a, %d-%b-%Y %H:%M:%S GMT"
expires = calendar.timegm(time.strptime(morsel["expires"], time_template))
return create_cookie(
comment=morsel["comment"],
comment_url=bool(morsel["comment"]),
discard=False,
domain=morsel["domain"],
expires=expires,
name=morsel.key,
path=morsel["path"],
port=None,
rest={"HttpOnly": morsel["httponly"]},
rfc2109=False,
secure=bool(morsel["secure"]),
value=morsel.value,
version=morsel["version"] or 0,
)
def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True):
"""Returns a CookieJar from a key/value dictionary.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:param cookiejar: (optional) A cookiejar to add the cookies to.
:param overwrite: (optional) If False, will not replace cookies
already in the jar with new ones.
:rtype: CookieJar
"""
if cookiejar is None:
cookiejar = RequestsCookieJar()
if cookie_dict is not None:
names_from_jar = [cookie.name for cookie in cookiejar]
for name in cookie_dict:
if overwrite or (name not in names_from_jar):
cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))
return cookiejar
def merge_cookies(cookiejar, cookies):
"""Add cookies to cookiejar and returns a merged CookieJar.
:param cookiejar: CookieJar object to add the cookies to.
:param cookies: Dictionary or CookieJar object to be added.
:rtype: CookieJar
"""
if not isinstance(cookiejar, cookielib.CookieJar):
raise ValueError("You can only merge into CookieJar")
if isinstance(cookies, dict):
cookiejar = cookiejar_from_dict(cookies, cookiejar=cookiejar, overwrite=False)
elif isinstance(cookies, cookielib.CookieJar):
try:
cookiejar.update(cookies)
except AttributeError:
for cookie_in_jar in cookies:
cookiejar.set_cookie(cookie_in_jar)
return cookiejar
PK ! 5 help.pynu [ """Module containing bug report helper(s)."""
import json
import platform
import ssl
import sys
from pip._vendor import idna
from pip._vendor import urllib3
from . import __version__ as requests_version
charset_normalizer = None
chardet = None
try:
from pip._vendor.urllib3.contrib import pyopenssl
except ImportError:
pyopenssl = None
OpenSSL = None
cryptography = None
else:
import cryptography
import OpenSSL
def _implementation():
"""Return a dict with the Python implementation and version.
Provide both the name and the version of the Python implementation
currently running. For example, on CPython 3.10.3 it will return
{'name': 'CPython', 'version': '3.10.3'}.
This function works best on CPython and PyPy: in particular, it probably
doesn't work for Jython or IronPython. Future investigation should be done
to work out the correct shape of the code for those platforms.
"""
implementation = platform.python_implementation()
if implementation == "CPython":
implementation_version = platform.python_version()
elif implementation == "PyPy":
implementation_version = "{}.{}.{}".format(
sys.pypy_version_info.major,
sys.pypy_version_info.minor,
sys.pypy_version_info.micro,
)
if sys.pypy_version_info.releaselevel != "final":
implementation_version = "".join(
[implementation_version, sys.pypy_version_info.releaselevel]
)
elif implementation == "Jython":
implementation_version = platform.python_version() # Complete Guess
elif implementation == "IronPython":
implementation_version = platform.python_version() # Complete Guess
else:
implementation_version = "Unknown"
return {"name": implementation, "version": implementation_version}
def info():
"""Generate information for a bug report."""
try:
platform_info = {
"system": platform.system(),
"release": platform.release(),
}
except OSError:
platform_info = {
"system": "Unknown",
"release": "Unknown",
}
implementation_info = _implementation()
urllib3_info = {"version": urllib3.__version__}
charset_normalizer_info = {"version": None}
chardet_info = {"version": None}
if charset_normalizer:
charset_normalizer_info = {"version": charset_normalizer.__version__}
if chardet:
chardet_info = {"version": chardet.__version__}
pyopenssl_info = {
"version": None,
"openssl_version": "",
}
if OpenSSL:
pyopenssl_info = {
"version": OpenSSL.__version__,
"openssl_version": f"{OpenSSL.SSL.OPENSSL_VERSION_NUMBER:x}",
}
cryptography_info = {
"version": getattr(cryptography, "__version__", ""),
}
idna_info = {
"version": getattr(idna, "__version__", ""),
}
system_ssl = ssl.OPENSSL_VERSION_NUMBER
system_ssl_info = {"version": f"{system_ssl:x}" if system_ssl is not None else ""}
return {
"platform": platform_info,
"implementation": implementation_info,
"system_ssl": system_ssl_info,
"using_pyopenssl": pyopenssl is not None,
"using_charset_normalizer": chardet is None,
"pyOpenSSL": pyopenssl_info,
"urllib3": urllib3_info,
"chardet": chardet_info,
"charset_normalizer": charset_normalizer_info,
"cryptography": cryptography_info,
"idna": idna_info,
"requests": {
"version": requests_version,
},
}
def main():
"""Pretty-print the bug information as JSON."""
print(json.dumps(info(), sort_keys=True, indent=2))
if __name__ == "__main__":
main()
PK ! ލ' ' auth.pynu [ """
requests.auth
~~~~~~~~~~~~~
This module contains the authentication handlers for Requests.
"""
import hashlib
import os
import re
import threading
import time
import warnings
from base64 import b64encode
from ._internal_utils import to_native_string
from .compat import basestring, str, urlparse
from .cookies import extract_cookies_to_jar
from .utils import parse_dict_header
CONTENT_TYPE_FORM_URLENCODED = "application/x-www-form-urlencoded"
CONTENT_TYPE_MULTI_PART = "multipart/form-data"
def _basic_auth_str(username, password):
"""Returns a Basic Auth string."""
# "I want us to put a big-ol' comment on top of it that
# says that this behaviour is dumb but we need to preserve
# it because people are relying on it."
# - Lukasa
#
# These are here solely to maintain backwards compatibility
# for things like ints. This will be removed in 3.0.0.
if not isinstance(username, basestring):
warnings.warn(
"Non-string usernames will no longer be supported in Requests "
"3.0.0. Please convert the object you've passed in ({!r}) to "
"a string or bytes object in the near future to avoid "
"problems.".format(username),
category=DeprecationWarning,
)
username = str(username)
if not isinstance(password, basestring):
warnings.warn(
"Non-string passwords will no longer be supported in Requests "
"3.0.0. Please convert the object you've passed in ({!r}) to "
"a string or bytes object in the near future to avoid "
"problems.".format(type(password)),
category=DeprecationWarning,
)
password = str(password)
# -- End Removal --
if isinstance(username, str):
username = username.encode("latin1")
if isinstance(password, str):
password = password.encode("latin1")
authstr = "Basic " + to_native_string(
b64encode(b":".join((username, password))).strip()
)
return authstr
class AuthBase:
"""Base class that all auth implementations derive from"""
def __call__(self, r):
raise NotImplementedError("Auth hooks must be callable.")
class HTTPBasicAuth(AuthBase):
"""Attaches HTTP Basic Authentication to the given Request object."""
def __init__(self, username, password):
self.username = username
self.password = password
def __eq__(self, other):
return all(
[
self.username == getattr(other, "username", None),
self.password == getattr(other, "password", None),
]
)
def __ne__(self, other):
return not self == other
def __call__(self, r):
r.headers["Authorization"] = _basic_auth_str(self.username, self.password)
return r
class HTTPProxyAuth(HTTPBasicAuth):
"""Attaches HTTP Proxy Authentication to a given Request object."""
def __call__(self, r):
r.headers["Proxy-Authorization"] = _basic_auth_str(self.username, self.password)
return r
class HTTPDigestAuth(AuthBase):
"""Attaches HTTP Digest Authentication to the given Request object."""
def __init__(self, username, password):
self.username = username
self.password = password
# Keep state in per-thread local storage
self._thread_local = threading.local()
def init_per_thread_state(self):
# Ensure state is initialized just once per-thread
if not hasattr(self._thread_local, "init"):
self._thread_local.init = True
self._thread_local.last_nonce = ""
self._thread_local.nonce_count = 0
self._thread_local.chal = {}
self._thread_local.pos = None
self._thread_local.num_401_calls = None
def build_digest_header(self, method, url):
"""
:rtype: str
"""
realm = self._thread_local.chal["realm"]
nonce = self._thread_local.chal["nonce"]
qop = self._thread_local.chal.get("qop")
algorithm = self._thread_local.chal.get("algorithm")
opaque = self._thread_local.chal.get("opaque")
hash_utf8 = None
if algorithm is None:
_algorithm = "MD5"
else:
_algorithm = algorithm.upper()
# lambdas assume digest modules are imported at the top level
if _algorithm == "MD5" or _algorithm == "MD5-SESS":
def md5_utf8(x):
if isinstance(x, str):
x = x.encode("utf-8")
return hashlib.md5(x).hexdigest()
hash_utf8 = md5_utf8
elif _algorithm == "SHA":
def sha_utf8(x):
if isinstance(x, str):
x = x.encode("utf-8")
return hashlib.sha1(x).hexdigest()
hash_utf8 = sha_utf8
elif _algorithm == "SHA-256":
def sha256_utf8(x):
if isinstance(x, str):
x = x.encode("utf-8")
return hashlib.sha256(x).hexdigest()
hash_utf8 = sha256_utf8
elif _algorithm == "SHA-512":
def sha512_utf8(x):
if isinstance(x, str):
x = x.encode("utf-8")
return hashlib.sha512(x).hexdigest()
hash_utf8 = sha512_utf8
KD = lambda s, d: hash_utf8(f"{s}:{d}") # noqa:E731
if hash_utf8 is None:
return None
# XXX not implemented yet
entdig = None
p_parsed = urlparse(url)
#: path is request-uri defined in RFC 2616 which should not be empty
path = p_parsed.path or "/"
if p_parsed.query:
path += f"?{p_parsed.query}"
A1 = f"{self.username}:{realm}:{self.password}"
A2 = f"{method}:{path}"
HA1 = hash_utf8(A1)
HA2 = hash_utf8(A2)
if nonce == self._thread_local.last_nonce:
self._thread_local.nonce_count += 1
else:
self._thread_local.nonce_count = 1
ncvalue = f"{self._thread_local.nonce_count:08x}"
s = str(self._thread_local.nonce_count).encode("utf-8")
s += nonce.encode("utf-8")
s += time.ctime().encode("utf-8")
s += os.urandom(8)
cnonce = hashlib.sha1(s).hexdigest()[:16]
if _algorithm == "MD5-SESS":
HA1 = hash_utf8(f"{HA1}:{nonce}:{cnonce}")
if not qop:
respdig = KD(HA1, f"{nonce}:{HA2}")
elif qop == "auth" or "auth" in qop.split(","):
noncebit = f"{nonce}:{ncvalue}:{cnonce}:auth:{HA2}"
respdig = KD(HA1, noncebit)
else:
# XXX handle auth-int.
return None
self._thread_local.last_nonce = nonce
# XXX should the partial digests be encoded too?
base = (
f'username="{self.username}", realm="{realm}", nonce="{nonce}", '
f'uri="{path}", response="{respdig}"'
)
if opaque:
base += f', opaque="{opaque}"'
if algorithm:
base += f', algorithm="{algorithm}"'
if entdig:
base += f', digest="{entdig}"'
if qop:
base += f', qop="auth", nc={ncvalue}, cnonce="{cnonce}"'
return f"Digest {base}"
def handle_redirect(self, r, **kwargs):
"""Reset num_401_calls counter on redirects."""
if r.is_redirect:
self._thread_local.num_401_calls = 1
def handle_401(self, r, **kwargs):
"""
Takes the given response and tries digest-auth, if needed.
:rtype: requests.Response
"""
# If response is not 4xx, do not auth
# See https://github.com/psf/requests/issues/3772
if not 400 <= r.status_code < 500:
self._thread_local.num_401_calls = 1
return r
if self._thread_local.pos is not None:
# Rewind the file position indicator of the body to where
# it was to resend the request.
r.request.body.seek(self._thread_local.pos)
s_auth = r.headers.get("www-authenticate", "")
if "digest" in s_auth.lower() and self._thread_local.num_401_calls < 2:
self._thread_local.num_401_calls += 1
pat = re.compile(r"digest ", flags=re.IGNORECASE)
self._thread_local.chal = parse_dict_header(pat.sub("", s_auth, count=1))
# Consume content and release the original connection
# to allow our new request to reuse the same one.
r.content
r.close()
prep = r.request.copy()
extract_cookies_to_jar(prep._cookies, r.request, r.raw)
prep.prepare_cookies(prep._cookies)
prep.headers["Authorization"] = self.build_digest_header(
prep.method, prep.url
)
_r = r.connection.send(prep, **kwargs)
_r.history.append(r)
_r.request = prep
return _r
self._thread_local.num_401_calls = 1
return r
def __call__(self, r):
# Initialize per-thread state, if needed
self.init_per_thread_state()
# If we have a saved nonce, skip the 401
if self._thread_local.last_nonce:
r.headers["Authorization"] = self.build_digest_header(r.method, r.url)
try:
self._thread_local.pos = r.body.tell()
except AttributeError:
# In the case of HTTPDigestAuth being reused and the body of
# the previous request was a file-like object, pos has the
# file position of the previous body. Ensure it's set to
# None.
self._thread_local.pos = None
r.register_hook("response", self.handle_401)
r.register_hook("response", self.handle_redirect)
self._thread_local.num_401_calls = 1
return r
def __eq__(self, other):
return all(
[
self.username == getattr(other, "username", None),
self.password == getattr(other, "password", None),
]
)
def __ne__(self, other):
return not self == other
PK ! G hooks.pynu [ """
requests.hooks
~~~~~~~~~~~~~~
This module provides the capabilities for the Requests hooks system.
Available hooks:
``response``:
The response generated from a Request.
"""
HOOKS = ["response"]
def default_hooks():
return {event: [] for event in HOOKS}
# TODO: response is the only one
def dispatch_hook(key, hooks, hook_data, **kwargs):
"""Dispatches a hook dictionary on a given piece of data."""
hooks = hooks or {}
hooks = hooks.get(key)
if hooks:
if hasattr(hooks, "__call__"):
hooks = [hooks]
for hook in hooks:
_hook_data = hook(hook_data, **kwargs)
if _hook_data is not None:
hook_data = _hook_data
return hook_data
PK ! ]< C
C
help.pyonu [
abc @ s
d Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l m Z d d l m
Z
d d l m Z
y d d l m Z Wn# e k
r d Z d Z d Z n Xd d l Z d d l Z d
Z d Z d Z e d
k r e n d S( s' Module containing bug report helper(s).i( t print_functionN( t idna( t urllib3( t chardeti ( t __version__( t pyopensslc C s t j } | d k r' t j } n | d k r d t j j t j j t j j f } t j j d k r d j | t j j g } q n< | d k r t j } n! | d k r t j } n d } i | d 6| d
6S( s Return a dict with the Python implementation and version.
Provide both the name and the version of the Python implementation
currently running. For example, on CPython 2.7.5 it will return
{'name': 'CPython', 'version': '2.7.5'}.
This function works best on CPython and PyPy: in particular, it probably
doesn't work for Jython or IronPython. Future investigation should be done
to work out the correct shape of the code for those platforms.
t CPythont PyPys %s.%s.%st finalt t Jythont
IronPythont Unknownt namet version(
t platformt python_implementationt python_versiont syst pypy_version_infot majort minort microt releaselevelt join( t implementationt implementation_version( ( s= /usr/lib/python2.7/site-packages/pip/_vendor/requests/help.pyt _implementation s c C sq y$ i t j d 6t j d 6} Wn% t k
rK i d d 6d d 6} n Xt } i t j d 6} i t j d 6} i d d 6d d 6} t r i t j d 6d t j
j d 6} n i t t
d d d 6} i t t d d d 6} t t d d } i | d k rd | n d d 6} i
| d
6| d 6| d 6t d k d
6| d 6| d 6| d 6| d 6| d 6i t d 6d 6S( s& Generate information for a bug report.t systemt releaseR R R t openssl_versions %xR t OPENSSL_VERSION_NUMBERR R t
system_sslt using_pyopensslt pyOpenSSLR R t cryptographyR t requestsN( R R R t IOErrorR R R R t Nonet OpenSSLt SSLR t getattrR# R t sslR t requests_version( t
platform_infot implementation_infot urllib3_infot chardet_infot pyopenssl_infot cryptography_infot idna_infoR t system_ssl_info( ( s= /usr/lib/python2.7/site-packages/pip/_vendor/requests/help.pyt info; sJ
c C s& t t j t d t d d d S( s) Pretty-print the bug information as JSON.t sort_keyst indenti N( t printt jsont dumpsR4 t True( ( ( s= /usr/lib/python2.7/site-packages/pip/_vendor/requests/help.pyt mainr s t __main__( t __doc__t
__future__R R8 R R R* t pip._vendorR R R R R R+ t packages.urllib3.contribR t ImportErrorR& R' R# R R4 R; t __name__( ( ( s= /usr/lib/python2.7/site-packages/pip/_vendor/requests/help.pyt s,
! 7 PK ! ϢIt% %
models.pycnu [
Rec @ s d Z d d l Z d d l Z d d l 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 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 d d
l 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( m) Z) m* Z* m+ Z+ m, Z, m- Z- m. Z. m/ Z/ m0 Z0 m1 Z1 d d l2 m3 Z3 m4 Z4 m5 Z5 m6 Z6 m7 Z7 m8 Z8 m9 Z9 m: Z: m; Z; m< Z< m= Z= m> Z> d d l2 m? Z@ d d lA mB ZB eB jC eB jD eB jE eB jF eB jG f ZH d ZI d d ZJ d ZK d eL f d YZM d eL f d YZN d eN f d YZO d eM eN f d YZP d eL f d YZQ d S(! s`
requests.models
~~~~~~~~~~~~~~~
This module contains the primary objects that power Requests.
iN( t RequestField( t encode_multipart_formdata( t parse_url( t DecodeErrort ReadTimeoutErrort
ProtocolErrort LocationParseError( t UnsupportedOperationi ( t
default_hooks( t CaseInsensitiveDict( t
HTTPBasicAuth( t cookiejar_from_dictt get_cookie_headert _copy_cookie_jar( t HTTPErrort
MissingSchemat
InvalidURLt ChunkedEncodingErrort ContentDecodingErrort ConnectionErrort StreamConsumedError( t to_native_stringt unicode_is_ascii(
t guess_filenamet get_auth_from_urlt requote_urit stream_decode_response_unicodet to_key_val_listt parse_header_linkst iter_slicest guess_json_utft super_lent check_header_validity( t Callablet Mappingt cookielibt
urlunparset urlsplitt urlencodet strt bytest is_py2t chardett builtin_strt
basestring( t json( t codesi i
i i t RequestEncodingMixinc B s5 e Z e d Z e d Z e d Z RS( c C ss g } t | j } | j } | s- d } n | j | | j } | rf | j d | j | n d j | S( s Build the path URL to use.t /t ?t ( R% t urlt patht appendt queryt join( t selfR3 t pR4 R6 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt path_url= s
c C s t | t t f r | St | d r, | St | d rg } x t | D] \ } } t | t sy t | d r | g } n xl | D]d } | d k r | j t | t r | j d n | t | t r | j d n | f q q WqN Wt | d t
S| Sd S( s Encode parameters in a piece of data.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
t readt __iter__s utf-8t doseqN( t
isinstanceR' R( t hasattrR R, t NoneR5 t encodeR& t True( t datat resultt kt vst v( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt _encode_paramsR s
!3c
C s | s t d n t | t r3 t d n g } t | pE i } t | pW i } x | D] \ } } t | t s t | d r | g } n x | D] } | d
k r t | t s t | } n | j t | t r | j d n | t | t r| j
d n | f q q Wqd Wx<| D]4\ } } d
} d
} t | t t f rt
| d k r| \ }
} qt
| d k r| \ }
} } q| \ }
} } } n t | p| }
| } t | t t t f r| } n6 t | d r| j } n | d
k r#q3n | } t d | d | d
|
d | }
|
j d | | j |
q3Wt | \ } } | | f S( s Build the body for a multipart/form-data request.
Will successfully encode files when passed as a dict or a list of
tuples. Order is retained if data is a list of tuples but arbitrary
if parameters are supplied as a dict.
The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
or 4-tuples (filename, fileobj, contentype, custom_headers).
s Files must be provided.s Data must not be a string.R< s utf-8i i R; t nameRC t filenamet headerst content_typeN( t
ValueErrorR> R, R R? R@ R( R' R5 t decodeRA t tuplet listt lenR t bytearrayR; R t make_multipartR ( t filesRC t
new_fieldst fieldst fieldt valRG RE t ftt fht fnt fpt fdatat rft bodyRL ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt
_encode_filesm sP
!3 !( t __name__t
__module__t propertyR: t staticmethodRH R` ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR/ < s t RequestHooksMixinc B s e Z d Z d Z RS( c C s| | | j k r" t d | n t | t rH | j | j | n0 t | d rx | j | j d | D n d S( s Properly register a hook.s1 Unsupported event specified, with event name "%s"R< c s s$ | ] } t | t r | Vq d S( N( R> R! ( t .0t h( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pys s N( t hooksRM R> R! R5 R? t extend( R8 t eventt hook( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt
register_hook s c C s5 y | j | j | t SWn t k
r0 t SXd S( si Deregister a previously registered hook.
Returns True if the hook existed, False if not.
N( Rh t removeRB RM t False( R8 Rj Rk ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt deregister_hook s
( Ra Rb Rl Ro ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRe s t Requestc B sG e Z d Z d d d d d d d d d d d
Z d Z d Z RS( s{ A user-created :class:`Request ` object.
Used to prepare a :class:`PreparedRequest `, which is sent to the server.
:param method: HTTP method to use.
:param url: URL to send.
:param headers: dictionary of headers to send.
:param files: dictionary of {filename: fileobject} files to multipart upload.
:param data: the body to attach to the request. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param json: json for the body to attach to the request (if files or data is not specified).
:param params: URL parameters to append to the URL. If a dictionary or
list of tuples ``[(key, value)]`` is provided, form-encoding will
take place.
:param auth: Auth handler or (user, pass) tuple.
:param cookies: dictionary or CookieJar of cookies to attach to this request.
:param hooks: dictionary of callback hooks, for internal usage.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> req.prepare()
c
C s | d k r g n | } | d k r* g n | } | d k rB i n | } | d k rZ i n | } | d k rr i n | } t | _ x6 t | j D]" \ } } | j d | d | q W| | _ | | _ | | _ | | _ | | _
|
| _ | | _ | | _
| | _ d S( NRj Rk ( R@ R Rh RP t itemsRl t methodR3 RK RT RC R- t paramst autht cookies(
R8 Rr R3 RK RT RC Rs Rt Ru Rh R- RE RG ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __init__ s" c C s d | j S( Ns ( Rr ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __repr__ s c C sq t } | j d | j d | j d | j d | j d | j d | j d | j d | j d | j
d
| j
| S( sX Constructs a :class:`PreparedRequest ` for transmission and returns it.Rr R3 RK RT RC R- Rs Rt Ru Rh ( t PreparedRequestt prepareRr R3 RK RT RC R- Rs Rt Ru Rh ( R8 R9 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRy s
N( Ra Rb t __doc__R@ Rv Rw Ry ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRp s
Rx c B s e Z d Z d Z d d d d d d d d d d d
Z d Z d Z d Z e d Z
d Z d Z d d Z
d
Z d d Z d
Z d Z RS( s The fully mutable :class:`PreparedRequest ` object,
containing the exact bytes that will be sent to the server.
Generated from either a :class:`Request ` object or manually.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'https://httpbin.org/get')
>>> r = req.prepare()
>>> r
>>> s = requests.Session()
>>> s.send(r)
c C sF d | _ d | _ d | _ d | _ d | _ t | _ d | _ d S( N( R@ Rr R3 RK t _cookiesR_ R Rh t _body_position( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRv # s c C sk | j | | j | | | j | | j | | j | | |
| j | | | j | d S( s6 Prepares the entire request with the given parameters.N( t prepare_methodt prepare_urlt prepare_headerst prepare_cookiest prepare_bodyt prepare_autht
prepare_hooks( R8 Rr R3 RK RT RC Rs Rt Ru Rh R- ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRy 4 s
c C s d | j S( Ns ( Rr ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRw F s c C s t } | j | _ | j | _ | j d k r? | j j n d | _ t | j | _ | j | _ | j | _ | j
| _
| S( N( Rx Rr R3 RK R@ t copyR
R{ R_ Rh R| ( R8 R9 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR I s ' c C s7 | | _ | j d k r3 t | j j | _ n d S( s Prepares the given HTTP method.N( Rr R@ R t upper( R8 Rr ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR} T s c C sS d d l m } y" | j | d t j d } Wn | j k
rN t n X| S( Ni( t idnat uts46s utf-8( t pip._vendorR RA RB RN t IDNAErrort UnicodeError( t hostR ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt _get_idna_encoded_hostZ s "
c C s t | t r! | j d } n t r3 t | n t | } | j } d | k rz | j j d rz | | _ d Sy% t
| \ } } } } } } } Wn" t k
r }
t |
j
n X| s d } | j t | d } t | n | st d | n t | sRy | j | } Wqpt k
rNt d qpXn | j d rpt d n | pyd } | r| d
7} n | | 7} | r| d t | 7} n | sd } n t rst | t r| j d } n t | t r
| j d } n t | t r.| j d } n t | t rO| j d } n t | t rs| j d } qsn t | t t f rt | } n | j | }
|
r| rd
| |
f } q|
} n t t | | | d | | g } | | _ d S( s Prepares the given HTTP URL.t utf8t :t httpNsD Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?s Invalid URL %r: No host supplieds URL has an invalid label.u *R2 t @R0 s utf-8s %s&%s( R> R( RN R) t unicodeR' t lstript lowert
startswithR3 R R R t argst formatR R R R R RA RH R R$ R@ ( R8 R3 Rs t schemeRt R t portR4 R6 t fragmentt et errort netloct
enc_params( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR~ d sh " %
$c C sY t | _ | rU x@ | j D]/ } t | | \ } } | | j t | R( RA t allR? R, RP RO R" R t TypeErrort AttributeErrorR t getattrR R| t IOErrort OSErrort objectt NotImplementedErrorR+ RK R` RH t prepare_content_lengthR_ ( R8 RC RT R- R_ RL t is_streamt length( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR sJ "
c C sr | d k r7 t | } | rn t | | j d Prepare Content-Length header based on request method and bodys Content-Lengtht GETt HEADt 0N( R R ( R@ R R+ RK Rr t get( R8 R_ R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR
s 'R2 c C s | d k r6 t | j } t | r- | n d } n | r t | t rl t | d k rl t | } n | | } | j j | j | j
| j n d S( s" Prepares the given HTTP auth data.i N( R@ R R3 t anyR> RO RQ R
t __dict__t updateR R_ ( R8 Rt R3 t url_autht r( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s ! c C s_ t | t j r | | _ n t | | _ t | j | } | d k r[ | | j d ` object. Any subsequent calls
to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
header is removed beforehand.
t CookieN( R> R# t CookieJarR{ R R R@ RK ( R8 Ru t
cookie_header( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR - s c C s5 | p g } x" | D] } | j | | | q Wd S( s Prepares the given hooks.N( Rl ( R8 Rh Rj ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR A s
N( Ra Rb Rz Rv R@ Ry Rw R R} Rd R R~ R R R R R R ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRx s
V E
t Responsec
B s7 e Z d Z d d d d d d d d d d
g
Z d Z d Z d
Z d Z d Z d Z d Z
d Z d Z e
d Z e
d Z e
d Z e
d Z e
d Z d e d Z e e d" d Z e
d Z e
d Z d Z e
d Z d Z d! Z RS(# sh The :class:`Response ` object, which contains a
server's response to an HTTP request.
t _contentt status_codeRK R3 t historyt encodingt reasonRu t elapsedt requestc C s t | _ t | _ d | _ d | _ t | _ d | _ d | _ d | _
g | _ d | _ t
i | _ t j d | _ d | _ d S( Ni ( Rn R t _content_consumedR@ t _nextR R RK t rawR3 R R R R Ru t datetimet timedeltaR R ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRv U s c C s | S( N( ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __enter__ s c G s | j d S( N( t close( R8 R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __exit__ s c s* j s j n f d j D S( Nc s% i | ] } t | d | q S( N( R R@ ( Rf t attr( R8 ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pys
s ( R t contentt __attrs__( R8 ( ( R8 s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __getstate__ s
c C sQ x* | j D] \ } } t | | | q
Wt | d t t | d d d S( NR R ( Rq t setattrRB R@ ( R8 t stateRI R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __setstate__ s c C s d | j S( Ns ( R ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRw s c C s | j S( sk Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
( t ok( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __bool__ s c C s | j S( sk Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
( R ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __nonzero__ s c C s
| j d S( s, Allows you to use a response as an iterator.i ( t iter_content( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR< s c C s' y | j Wn t k
r" t SXt S( sx Returns True if :attr:`status_code` is less than 400, False if not.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
( t raise_for_statusR Rn RB ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s
c C s d | j k o | j t k S( s True if this Response is a well-formed HTTP redirect that could have
been processed automatically (by :meth:`Session.resolve_redirects`).
t location( RK R t REDIRECT_STATI( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt is_redirect s c C s( d | j k o' | j t j t j f k S( s@ True if this Response one of the permanent versions of redirect.R ( RK R R. t moved_permanentlyt permanent_redirect( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt is_permanent_redirect s c C s | j S( sT Returns a PreparedRequest for the next request in a redirect chain, if there is one.( R ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt next s c C s t j | j d S( s7 The apparent encoding, provided by the chardet library.R ( R* t detectR ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt apparent_encoding s i c s f d } j r9 t j t r9 t n5 d k rn t t rn t d t n t j } | } j r | n | } | r t
| } n | S( s Iterates over the response data. When stream=True is set on the
request, this avoids reading the content at once into memory for
large responses. The chunk size is the number of bytes it should
read into memory. This is not necessarily the length of each item
returned as decoding can take place.
chunk_size must be of type int or None. A value of None will
function differently depending on the value of `stream`.
stream=True will read data as it arrives in whatever size the
chunks are received. If stream=False, data is returned as
a single chunk.
If decode_unicode is True, content will be decoded using the best
available encoding based on the response.
c 3 s t j d r y, x% j j d t D] } | Vq. WWq t k
r_ } t | q t k
r} } t | q t k
r } t | q Xn. x+ t r j j
} | s Pn | Vq Wt _ d S( Nt streamt decode_content( R? R R RB R R R R R R R; R ( t chunkR ( t
chunk_sizeR8 ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt generate s
s. chunk_size must be an int, it is instead a %s.N( R R> R t boolR R@ t intR t typeR R ( R8 R t decode_unicodeR t
reused_chunkst
stream_chunkst chunks( ( R R8 s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s c c s d } x | j d | d | D] } | d k r> | | } n | rV | j | } n | j } | r | d r | r | d d | d k r | j } n d } x | D] } | Vq Wq W| d k r | Vn d S( s Iterates over the response data, one line at a time. When
stream=True is set on the request, this avoids reading the
content at once into memory for large responses.
.. note:: This method is not reentrant safe.
R R iN( R@ R t splitt
splitlinest pop( R8 R R t delimitert pendingR t linest line( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt
iter_lines s
.
c C s | j t k ru | j r' t d n | j d k sE | j d k rQ d | _ qu d j | j t pl d | _ n t
| _ | j S( s" Content of the response, in bytes.s2 The content for this response was already consumedi R2 N( R Rn R t RuntimeErrorR R R@ R7 R t CONTENT_CHUNK_SIZERB ( R8 ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR 0 s $ c C s d } | j } | j s" t d S| j d k r= | j } n y t | j | d d } Wn, t t f k
r t | j d d } n X| S( s Content of the response, in unicode.
If Response.encoding is None, encoding will be guessed using
``chardet``.
The encoding of the response content is determined based solely on HTTP
headers, following RFC 2616 to the letter. If you can take advantage of
non-HTTP knowledge to make a better guess at the encoding, you should
set ``r.encoding`` appropriately before accessing this property.
R2 t errorst replaceN( R@ R R R' R t LookupErrorR ( R8 R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt textD s
c K s | j r} | j r} t | j d k r} t | j } | d k r} y t j | j j | | SWqz t k
rv qz Xq} n t j | j | S( s Returns the json-encoded content of a response, if any.
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
:raises ValueError: If the response body does not contain valid json.
i N(
R R RQ R R@ R t loadsRN t UnicodeDecodeErrorR ( R8 t kwargsR ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR- j s (
c C sj | j j d } i } | rf t | } x9 | D]. } | j d pR | j d } | | | R R( RN R R R3 R ( R8 t http_error_msgR ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s
c C sH | j s | j j n t | j d d } | d k rD | n d S( s Releases the connection back to the pool. Once this method has been
called the underlying ``raw`` object must not be accessed again.
*Note: Should not normally need to be called explicitly.*
t release_connN( R R R R R@ ( R8 R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s
N( Ra Rb Rz R Rv R R R R Rw R R R< Rc R R R R R Rn R t ITER_CHUNK_SIZER@ R R R R- R R R ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR K s2 /
7 & (R Rz R t syst encodings.idnat encodingst pip._vendor.urllib3.fieldsR t pip._vendor.urllib3.filepostR t pip._vendor.urllib3.utilR t pip._vendor.urllib3.exceptionsR R R R t ioR Rh R t
structuresR Rt R
Ru R R R
t
exceptionsR R R R R R R t _internal_utilsR R t utilsR R R R R R R R R R t compatR! R" R# R$ R% R& R' R( R) R* R+ R, R- R t status_codesR. t movedt foundt othert temporary_redirectR R t DEFAULT_REDIRECT_LIMITR R R R/ Re Rp Rx R ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt s@ " 4FR
rJ s ( t HOOKS( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/hooks.pyt
default_hooks s c K sx | p i } | j | } | rt t | d r< | g } n x5 | D]* } | | | } | d k rC | } qC qC Wn | S( s6 Dispatches a hook dictionary on a given piece of data.t __call__N( t gett hasattrt None( t keyt hookst hook_datat kwargst hookt
_hook_data( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/hooks.pyt
dispatch_hook s
N( t __doc__R R R ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/hooks.pyt
s PK ! ': : api.pycnu [
Rec @ sq d Z d d l m Z d Z d d Z d Z d Z d d d Z d d Z d d Z
d
Z d S( s
requests.api
~~~~~~~~~~~~
This module implements the Requests API.
:copyright: (c) 2012 by Kenneth Reitz.
:license: Apache2, see LICENSE for more details.
i ( t sessionsc
K s2 t j } | j d | d | | SWd QXd S( s Constructs and sends a :class:`Request `.
:param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the query string for the :class:`Request`.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
:param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
:param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
:param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')``
or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string
defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers
to add for the file.
:param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth.
:param timeout: (optional) How many seconds to wait for the server to send data
before giving up, as a float, or a :ref:`(connect timeout, read
timeout) ` tuple.
:type timeout: float or tuple
:param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``.
:type allow_redirects: bool
:param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
:param verify: (optional) Either a boolean, in which case it controls whether we verify
the server's TLS certificate, or a string, in which case it must be a path
to a CA bundle to use. Defaults to ``True``.
:param stream: (optional) if ``False``, the response content will be immediately downloaded.
:param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
:return: :class:`Response ` object
:rtype: requests.Response
Usage::
>>> import requests
>>> req = requests.request('GET', 'https://httpbin.org/get')
>>> req
t methodt urlN( R t Sessiont request( R R t kwargst session( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR s ,c K s& | j d t t d | d | | S( sd Sends a GET request.
:param url: URL for the new :class:`Request` object.
:param params: (optional) Dictionary, list of tuples or bytes to send
in the query string for the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
t allow_redirectst gett params( t
setdefaultt TrueR ( R R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR @ s c K s | j d t t d | | S( s Sends an OPTIONS request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
R t options( R
R R ( R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR O s c K s | j d t t d | | S( sk Sends a HEAD request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes. If
`allow_redirects` is not provided, it will be set to `False` (as
opposed to the default :meth:`request` behavior).
:return: :class:`Response ` object
:rtype: requests.Response
R t head( R
t FalseR ( R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR
\ s c K s t d | d | d | | S( s Sends a POST request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) json data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
t postt datat json( R ( R R R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR k s c K s t d | d | | S( s Sends a PUT request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) json data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
t putR ( R ( R R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR z s c K s t d | d | | S( s Sends a PATCH request.
:param url: URL for the new :class:`Request` object.
:param data: (optional) Dictionary, list of tuples, bytes, or file-like
object to send in the body of the :class:`Request`.
:param json: (optional) json data to send in the body of the :class:`Request`.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
t patchR ( R ( R R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR s c K s t d | | S( s Sends a DELETE request.
:param url: URL for the new :class:`Request` object.
:param \*\*kwargs: Optional arguments that ``request`` takes.
:return: :class:`Response ` object
:rtype: requests.Response
t delete( R ( R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyR s N( t __doc__t R R t NoneR R R
R R R R ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/api.pyt s 0
PK ! ;̵B B packages.pyonu [
abc @ s d d l Z x d D] Z d e Z e e e e s
PK ! wr r
models.pyonu [
abc @ s d Z d d l Z d d l Z d d l Z d d l 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 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 d d
l 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) m* Z* m+ Z+ m, Z, m- Z- m. Z. m/ Z/ m0 Z0 m1 Z1 m2 Z2 d d l3 m4 Z4 m5 Z5 m6 Z6 m7 Z7 m8 Z8 m9 Z9 m: Z: m; Z; m< Z< m= Z= d d l3 m> Z? d d l@ mA ZA eA jB eA jC eA jD eA jE eA jF f ZG d ZH d d ZI d ZJ d eK f d YZL d eK f d YZM d eM f d YZN d eL eM f d YZO d eK f d YZP d S(! s`
requests.models
~~~~~~~~~~~~~~~
This module contains the primary objects that power Requests.
iN( t RequestField( t encode_multipart_formdata( t parse_url( t DecodeErrort ReadTimeoutErrort
ProtocolErrort LocationParseError( t UnsupportedOperationi ( t
default_hooks( t CaseInsensitiveDict( t
HTTPBasicAuth( t cookiejar_from_dictt get_cookie_headert _copy_cookie_jar( t HTTPErrort
MissingSchemat
InvalidURLt ChunkedEncodingErrort ContentDecodingErrort ConnectionErrort StreamConsumedError( t to_native_stringt unicode_is_ascii(
t guess_filenamet get_auth_from_urlt requote_urit stream_decode_response_unicodet to_key_val_listt parse_header_linkst iter_slicest guess_json_utft super_lent check_header_validity(
t cookielibt
urlunparset urlsplitt urlencodet strt bytest is_py2t chardett builtin_strt
basestring( t json( t codesi i
i i t RequestEncodingMixinc B s5 e Z e d Z e d Z e d Z RS( c C ss g } t | j } | j } | s- d } n | j | | j } | rf | j d | j | n d j | S( s Build the path URL to use.t /t ?t ( R# t urlt patht appendt queryt join( t selfR1 t pR2 R4 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt path_url= s
c C s t | t t f r | St | d r, | St | d rg } x t | D] \ } } t | t sy t | d r | g } n xl | D]d } | d k r | j t | t r | j d n | t | t r | j d n | f q q WqN Wt | d t
S| Sd S( s Encode parameters in a piece of data.
Will successfully encode parameters when passed as a dict or a list of
2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
if parameters are supplied as a dict.
t readt __iter__s utf-8t doseqN( t
isinstanceR% R& t hasattrR R* t NoneR3 t encodeR$ t True( t datat resultt kt vst v( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt _encode_paramsR s
!3c
C s] | s t d n t | t r3 t d n g } t | pE i } t | pW i } x | D] \ } } t | t s t | d r | g } n x | D] } | d k r t | t s t | } n | j t | t r | j d n | t | t r| j
d n | f q q Wqd Wx| D]
\ } } d } d } t | t t f rt
| d k r| \ }
} qt
| d k r| \ }
} } q| \ }
} } } n t | p| }
| } t | t t t f r| } n | j } t d | d | d |
d
| }
|
j d | | j |
q3Wt | \ } } | | f S(
s Build the body for a multipart/form-data request.
Will successfully encode files when passed as a dict or a list of
tuples. Order is retained if data is a list of tuples but arbitrary
if parameters are supplied as a dict.
The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
or 4-tuples (filename, fileobj, contentype, custom_headers).
s Files must be provided.s Data must not be a string.R: s utf-8i i t nameRA t filenamet headerst content_typeN( t
ValueErrorR< R* R R= R> R& R% R3 t decodeR? t tuplet listt lenR t bytearrayR9 R t make_multipartR ( t filesRA t
new_fieldst fieldst fieldt valRE RC t ftt fht fnt fpt fdatat rft bodyRJ ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt
_encode_filesm sH
!3 !( t __name__t
__module__t propertyR8 t staticmethodRF R^ ( ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR- < s t RequestHooksMixinc B s e Z d Z d Z RS( c C s | | j k r" t d | n t | t j rK | j | j | n0 t | d r{ | j | j d | D n d S( s Properly register a hook.s1 Unsupported event specified, with event name "%s"R: c s s' | ] } t | t j r | Vq d S( N( R< t collectionst Callable( t .0t h( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pys s N( t hooksRK R< Rd Re R3 R= t extend( R6 t eventt hook( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt
register_hook s c C s5 y | j | j | t SWn t k
r0 t SXd S( si Deregister a previously registered hook.
Returns True if the hook existed, False if not.
N( Rh t removeR@ RK t False( R6 Rj Rk ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt deregister_hook s
( R_ R` Rl Ro ( ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRc s t Requestc B sG e Z d Z d d d d d d d d d d d
Z d Z d Z RS( s A user-created :class:`Request ` object.
Used to prepare a :class:`PreparedRequest `, which is sent to the server.
:param method: HTTP method to use.
:param url: URL to send.
:param headers: dictionary of headers to send.
:param files: dictionary of {filename: fileobject} files to multipart upload.
:param data: the body to attach to the request. If a dictionary is provided, form-encoding will take place.
:param json: json for the body to attach to the request (if files or data is not specified).
:param params: dictionary of URL parameters to append to the URL.
:param auth: Auth handler or (user, pass) tuple.
:param cookies: dictionary or CookieJar of cookies to attach to this request.
:param hooks: dictionary of callback hooks, for internal usage.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'http://httpbin.org/get')
>>> req.prepare()
c
C s | d k r g n | } | d k r* g n | } | d k rB i n | } | d k rZ i n | } | d k rr i n | } t | _ x6 t | j D]" \ } } | j d | d | q W| | _ | | _ | | _ | | _ | | _
|
| _ | | _ | | _
| | _ d S( NRj Rk ( R> R Rh RN t itemsRl t methodR1 RI RR RA R+ t paramst autht cookies(
R6 Rr R1 RI RR RA Rs Rt Ru Rh R+ RC RE ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __init__ s" c C s d | j S( Ns ( Rr ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __repr__ s c C sq t } | j d | j d | j d | j d | j d | j d | j d | j d | j d | j
d
| j
| S( sX Constructs a :class:`PreparedRequest ` for transmission and returns it.Rr R1 RI RR RA R+ Rs Rt Ru Rh ( t PreparedRequestt prepareRr R1 RI RR RA R+ Rs Rt Ru Rh ( R6 R7 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRy s
N( R_ R` t __doc__R> Rv Rw Ry ( ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRp s
Rx c B s e Z d Z d Z d d d d d d d d d d d
Z d Z d Z d Z e d Z
d Z d Z d d Z
d
Z d d Z d
Z d Z RS( s The fully mutable :class:`PreparedRequest ` object,
containing the exact bytes that will be sent to the server.
Generated from either a :class:`Request ` object or manually.
Usage::
>>> import requests
>>> req = requests.Request('GET', 'http://httpbin.org/get')
>>> r = req.prepare()
>>> s = requests.Session()
>>> s.send(r)
c C sF d | _ d | _ d | _ d | _ d | _ t | _ d | _ d S( N( R> Rr R1 RI t _cookiesR] R Rh t _body_position( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRv s c C sk | j | | j | | | j | | j | | j | | |
| j | | | j | d S( s6 Prepares the entire request with the given parameters.N( t prepare_methodt prepare_urlt prepare_headerst prepare_cookiest prepare_bodyt prepare_autht
prepare_hooks( R6 Rr R1 RI RR RA Rs Rt Ru Rh R+ ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRy + s
c C s d | j S( Ns ( Rr ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRw = s c C s t } | j | _ | j | _ | j d k r? | j j n d | _ t | j | _ | j | _ | j | _ | j
| _
| S( N( Rx Rr R1 RI R> t copyR
R{ R] Rh R| ( R6 R7 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR @ s ' c C s7 | | _ | j d k r3 t | j j | _ n d S( s Prepares the given HTTP method.N( Rr R> R t upper( R6 Rr ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR} K s c C sO d d l } y" | j | d t j d } Wn | j k
rJ t n X| S( Nit uts46s utf-8( t idnaR? R@ RL t IDNAErrort UnicodeError( t hostR ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt _get_idna_encoded_hostQ s "
c C s t | t r! | j d } n t r3 t | n t | } | j } d | k rz | j j d rz | | _ d Sy% t
| \ } } } } } } } Wn" t k
r }
t |
j
n X| s d } | j t | d } t | n | st d | n t | sRy | j | } Wqpt k
rNt d qpXn | j d rpt d n | pyd } | r| d
7} n | | 7} | r| d t | 7} n | sd } n t rst | t r| j d } n t | t r
| j d } n t | t r.| j d } n t | t rO| j d } n t | t rs| j d } qsn t | t t f rt | } n | j | }
|
r| rd
| |
f } q|
} n t t | | | d | | g } | | _ d S( s Prepares the given HTTP URL.t utf8t :t httpNsD Invalid URL {0!r}: No schema supplied. Perhaps you meant http://{0}?s Invalid URL %r: No host supplieds URL has an invalid label.u *R0 t @R. s utf-8s %s&%s( R< R& RL R' t unicodeR% t lstript lowert
startswithR1 R R R t argst formatR R R R R R? RF R R" R> ( R6 R1 Rs t schemeRt R t portR2 R4 t fragmentt et errort netloct
enc_params( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR~ [ sh " %
$c C sY t | _ | rU x@ | j D]/ } t | | \ } } | | j t | t complexjsont dumpsR< R& R? t allR= R* RN RM Rd t MappingR t TypeErrort AttributeErrorR t getattrR R| t IOErrort OSErrort objectt NotImplementedErrorR) RI R^ RF t prepare_content_lengthR] ( R6 RA RR R+ R] RJ t is_streamt length( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR sJ %
c C sr | d k r7 t | } | rn t | | j d Prepare Content-Length header based on request method and bodys Content-Lengtht GETt HEADt 0N( R R ( R> R R) RI Rr t get( R6 R] R ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s 'R0 c C s | d k r6 t | j } t | r- | n d } n | r t | t rl t | d k rl t | } n | | } | j j | j | j
| j n d S( s" Prepares the given HTTP auth data.i N( R> R R1 t anyR< RM RO R
t __dict__t updateR R] ( R6 Rt R1 t url_autht r( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s ! c C s_ t | t j r | | _ n t | | _ t | j | } | d k r[ | | j d ` object. Any subsequent calls
to ``prepare_cookies`` will have no actual effect, unless the "Cookie"
header is removed beforehand.
t CookieN( R< R! t CookieJarR{ R R R> RI ( R6 Ru t
cookie_header( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR $ s c C s5 | p g } x" | D] } | j | | | q Wd S( s Prepares the given hooks.N( Rl ( R6 Rh Rj ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR 8 s
N( R_ R` Rz Rv R> Ry Rw R R} Rb R R~ R R R R R R ( ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRx s
V E
t Responsec
B s7 e Z d Z d d d d d d d d d d
g
Z d Z d Z d
Z d Z d Z d Z d Z
d Z d Z e
d Z e
d Z e
d Z e
d Z e
d Z d e d Z e d" d" d Z e
d Z e
d Z d Z e
d Z d Z d! Z RS(# sh The :class:`Response ` object, which contains a
server's response to an HTTP request.
t _contentt status_codeRI R1 t historyt encodingt reasonRu t elapsedt requestc C s t | _ t | _ d | _ d | _ t | _ d | _ d | _ d | _
g | _ d | _ t
i | _ t j d | _ d | _ d S( Ni ( Rn R t _content_consumedR> t _nextR R RI t rawR1 R R R R Ru t datetimet timedeltaR R ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRv L s c C s | S( N( ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __enter__{ s c G s | j d S( N( t close( R6 R ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __exit__~ s c s0 j s j n t f d j D S( Nc 3 s' | ] } | t | d f Vq d S( N( R R> ( Rf t attr( R6 ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pys s ( R t contentt dictt __attrs__( R6 ( ( R6 s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __getstate__ s
c C sQ x* | j D] \ } } t | | | q
Wt | d t t | d d d S( NR R ( Rq t setattrR@ R> ( R6 t stateRG R ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __setstate__ s c C s d | j S( Ns ( R ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyRw s c C s | j S( sk Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
( t ok( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __bool__ s c C s | j S( sk Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
( R ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt __nonzero__ s c C s
| j d S( s, Allows you to use a response as an iterator.i ( t iter_content( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR: s c C s' y | j Wn t k
r" t SXt S( sk Returns True if :attr:`status_code` is less than 400.
This attribute checks if the status code of the response is between
400 and 600 to see if there was a client error or a server error. If
the status code, is between 200 and 400, this will return True. This
is **not** a check to see if the response code is ``200 OK``.
( t raise_for_statusR Rn R@ ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s
c C s d | j k o | j t k S( s True if this Response is a well-formed HTTP redirect that could have
been processed automatically (by :meth:`Session.resolve_redirects`).
t location( RI R t REDIRECT_STATI( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt is_redirect s c C s( d | j k o' | j t j t j f k S( s@ True if this Response one of the permanent versions of redirect.R ( RI R R, t moved_permanentlyt permanent_redirect( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt is_permanent_redirect s c C s | j S( sT Returns a PreparedRequest for the next request in a redirect chain, if there is one.( R ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt next s c C s t j | j d S( s7 The apparent encoding, provided by the chardet library.R ( R( t detectR ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt apparent_encoding s i c s f d } j r9 t j t r9 t n5 d k rn t t rn t d t n t j } | } j r | n | } | r t
| } n | S( s Iterates over the response data. When stream=True is set on the
request, this avoids reading the content at once into memory for
large responses. The chunk size is the number of bytes it should
read into memory. This is not necessarily the length of each item
returned as decoding can take place.
chunk_size must be of type int or None. A value of None will
function differently depending on the value of `stream`.
stream=True will read data as it arrives in whatever size the
chunks are received. If stream=False, data is returned as
a single chunk.
If decode_unicode is True, content will be decoded using the best
available encoding based on the response.
c 3 s t j d r y, x% j j d t D] } | Vq. WWq t k
r_ } t | q t k
r} } t | q t k
r } t | q Xn. x+ t r j j
} | s Pn | Vq Wt _ d S( Nt streamt decode_content( R= R R R@ R R R R R R R9 R ( t chunkR ( t
chunk_sizeR6 ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt generate s
s. chunk_size must be an int, it is instead a %s.N( R R< R t boolR R> t intR t typeR R ( R6 R t decode_unicodeR t
reused_chunkst
stream_chunkst chunks( ( R R6 s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s c c s d } x | j d | d | D] } | d k r> | | } n | rV | j | } n | j } | r | d r | r | d d | d k r | j } n d } x | D] } | Vq Wq W| d k r | Vn d S( s Iterates over the response data, one line at a time. When
stream=True is set on the request, this avoids reading the
content at once into memory for large responses.
.. note:: This method is not reentrant safe.
R R iN( R> R t splitt
splitlinest pop( R6 R R t delimitert pendingR t linest line( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt
iter_lines s
.
c C s | j t k r{ | j r' t d n | j d k sE | j d k rQ d | _ q{ t j | j t
pr t | _ n t | _ | j S( s" Content of the response, in bytes.s2 The content for this response was already consumedi N( R Rn R t RuntimeErrorR R R> R& R5 R t CONTENT_CHUNK_SIZER@ ( R6 ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR * s * c C s d } | j } | j s" t d S| j d k r= | j } n y t | j | d d } Wn, t t f k
r t | j d d } n X| S( s Content of the response, in unicode.
If Response.encoding is None, encoding will be guessed using
``chardet``.
The encoding of the response content is determined based solely on HTTP
headers, following RFC 2616 to the letter. If you can take advantage of
non-HTTP knowledge to make a better guess at the encoding, you should
set ``r.encoding`` appropriately before accessing this property.
R0 t errorst replaceN( R> R R R% R t LookupErrorR ( R6 R R ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt text> s
c K s | j r} | j r} t | j d k r} t | j } | d k r} y t j | j j | | SWqz t k
rv qz Xq} n t j | j | S( s Returns the json-encoded content of a response, if any.
:param \*\*kwargs: Optional arguments that ``json.loads`` takes.
:raises ValueError: If the response body does not contain valid json.
i N(
R R RO R R> R t loadsRL t UnicodeDecodeErrorR ( R6 t kwargsR ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR+ d s (
c C sj | j j d } i } | rf t | } x9 | D]. } | j d pR | j d } | | | ( R6 R ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR s
N( R_ R` Rz R Rv R R R R Rw R R R: Ra R R R R R Rn R t ITER_CHUNK_SIZER> R R R R+ R R R ( ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyR B s2 /
7 & (Q Rz Rd R t syst encodings.idnat encodingst pip._vendor.urllib3.fieldsR t pip._vendor.urllib3.filepostR t pip._vendor.urllib3.utilR t pip._vendor.urllib3.exceptionsR R R R t ioR Rh R t
structuresR Rt R
Ru R R R
t
exceptionsR R R R R R R t _internal_utilsR R t utilsR R R R R R R R R R t compatR! R" R# R$ R% R& R' R( R) R* R+ R t status_codesR, t movedt foundt othert temporary_redirectR R t DEFAULT_REDIRECT_LIMITR R R R- Rc Rp Rx R ( ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/models.pyt sB " 4FF
nF ;PK ! |L L status_codes.pycnu [
Rec @ s d a d d l m Z iD d d 6d d 6d d 6d d
6d d
6d d 6d d 6d d 6d d 6d d 6d d! 6d d$ 6d d) 6d d+ 6d d- 6d d/ 6d d3 6d d5 6d d8 6d d: 6d d< 6d d> 6d dB 6d dF 6d dI 6d dK 6d dN 6d dP 6d dS 6d dV 6d dX 6d d\ 6d d_ 6d da 6d dc 6d de 6d dh 6d dj 6d dl 6d dp 6d dt 6d dv 6d dz 6d d| 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6dd 6dd 6dd 6dd 6dd 6dd 6Z e d d Z d Z e d S( s
The ``codes`` object defines a mapping from common names for HTTP statuses
to their numerical codes, accessible either as attributes or as dictionary
items.
Example::
>>> import requests
>>> requests.codes['temporary_redirect']
307
>>> requests.codes.teapot
418
>>> requests.codes['\o/']
200
Some codes have multiple names, and both upper- and lower-case versions of
the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
``codes.okay`` all correspond to the HTTP status code 200.
i ( t
LookupDictt continueid t switching_protocolsie t
processingif t
checkpointig t uri_too_longt request_uri_too_longiz t okt okayt all_okt all_okayt all_goods \o/s ✓i t createdi t acceptedi t non_authoritative_infot non_authoritative_informationi t
no_contenti t
reset_contentt reseti t partial_contentt partiali t multi_statust multiple_statust multi_statit multiple_statii t already_reportedi t im_usedi t multiple_choicesi, t moved_permanentlyt moveds \o-i- t foundi. t see_othert otheri/ t not_modifiedi0 t use_proxyi1 t switch_proxyi2 t temporary_redirectt temporary_movedt temporaryi3 t permanent_redirectt resume_incompletet resumei4 t bad_requestt badi t unauthorizedi t payment_requiredt paymenti t forbiddeni t not_founds -o-i t method_not_allowedt not_allowedi t not_acceptablei t proxy_authentication_requiredt
proxy_autht proxy_authenticationi t request_timeoutt timeouti t conflicti t gonei t length_requiredi t precondition_failedt preconditioni t request_entity_too_largei t request_uri_too_largei t unsupported_media_typet unsupported_mediat
media_typei t requested_range_not_satisfiablet requested_ranget range_not_satisfiablei t expectation_failedi t im_a_teapott teapott
i_am_a_teapoti t misdirected_requesti t unprocessable_entityt
unprocessablei t lockedi t failed_dependencyt
dependencyi t unordered_collectiont unorderedi t upgrade_requiredt upgradei t precondition_requiredi t too_many_requestst too_manyi t header_fields_too_larget fields_too_largei t no_responset nonei t
retry_witht retryi t$ blocked_by_windows_parental_controlst parental_controlsi t unavailable_for_legal_reasonst
legal_reasonsi t client_closed_requesti t internal_server_errort server_errors /o\s ✗i t not_implementedi t bad_gatewayi t service_unavailablet unavailablei t gateway_timeouti t http_version_not_supportedt http_versioni t variant_also_negotiatesi t insufficient_storagei t bandwidth_limit_exceededt bandwidthi t not_extendedi t network_authentication_requiredt network_autht network_authenticationi t namet status_codesc s xc t j D]U \ } } xF | D]> } t t | | | j d s t t | j | q q Wq
Wd t d k r t d d j f d t t D n d a d S( Ns \t /c S s+ d j d t | D } d | | f S( Ns , c s s | ] } d | Vq d S( s ``%s``N( ( t .0t n( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/status_codes.pys s s s * %d: %s( t joint _codes( t codet names( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/status_codes.pyt docr s s
c 3 s | ] } | Vq d S( N( ( Rv Rz ( R| ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/status_codes.pys x s ( s \Ru (
Ry t itemst setattrt codest
startswitht uppert __doc__t NoneRx t sorted( Rz t titlest title( ( R| s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/status_codes.pyt _initk s
! N( R ( R ( R ( R ( R R ( R R R R
R s \o/s ✓( R ( R
( R R ( R ( R R ( R R ( R R R R ( R ( R ( R ( R R s \o-( R ( R R ( R! ( R" ( R# ( R$ R% R& ( R' R( R) ( R* R+ ( R, ( R- R. ( R/ ( R0 s -o-( R1 R2 ( R3 ( R4 R5 R6 ( R7 R8 ( R9 ( R: ( R; ( R< R= ( R> ( R? ( R@ RA RB ( RC RD RE ( RF ( RG RH RI ( RJ ( RK RL ( RM ( RN RO ( RP RQ ( RR RS ( RT R= ( RU RV ( RW RX ( RY RZ ( R[ R\ ( R] R^ ( R_ R` ( Ra ( Rb Rc s /o\s ✗( Rd ( Re ( Rf Rg ( Rh ( Ri Rj ( Rk ( Rl ( Rm Rn ( Ro ( Rp Rq Rr ( R t
structuresR Ry R R ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/status_codes.pyt s
PK ! u_@g g __init__.pyonu [
abc @ st d Z d d l m Z d d l m Z d d l Z d d l m Z d Z y e e j e j Wn9 e e
f k
r e j d j e j e j e n Xd d l
m Z e j d
e d d l m Z m Z m Z m Z d d l 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 d d l m Z m Z 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/ m0 Z0 m1 Z1 m2 Z2 m3 Z3 m4 Z4 m5 Z5 m6 Z6 d d l7 Z7 y d d l7 m8 Z8 Wn* e9 k
r@d e7 j: f d YZ8 n Xe7 j; e< j= e8 e j d e4 d e> d S( s
Requests HTTP Library
~~~~~~~~~~~~~~~~~~~~~
Requests is an HTTP library, written in Python, for human beings. Basic GET
usage:
>>> import requests
>>> r = requests.get('https://www.python.org')
>>> r.status_code
200
>>> 'Python is a programming language' in r.content
True
... or POST:
>>> payload = dict(key1='value1', key2='value2')
>>> r = requests.post('http://httpbin.org/post', data=payload)
>>> print(r.text)
{
...
"form": {
"key2": "value2",
"key1": "value1"
},
...
}
The other HTTP methods are supported - see `requests.api`. Full documentation
is at .
:copyright: (c) 2017 by Kenneth Reitz.
:license: Apache 2.0, see LICENSE for more details.
i( t urllib3( t chardetNi ( t RequestsDependencyWarningc C s | j d } t | d k r1 | j d n | \ } } } t | t | t | } } } | j d d \ } } } t | t | t | } } } d S( Nt .i t 0i ( t splitt lent appendt int( t urllib3_versiont chardet_versiont majort minort patch( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/requests/__init__.pyt check_compatibility1 s & &sA urllib3 ({0}) or chardet ({1}) doesn't match a supported version!( t DependencyWarningt ignore( t __title__t __description__t __url__t __version__( t __build__t
__author__t __author_email__t __license__( t
__copyright__t __cake__( t utils( t packages( t Requestt Responset PreparedRequest( t requestt gett headt postR
t putt deletet options( t sessiont Session( t codes( t RequestExceptiont Timeoutt URLRequiredt TooManyRedirectst HTTPErrort ConnectionErrort FileModeWarningt ConnectTimeoutt ReadTimeout( t NullHandlerR3 c B s e Z d Z RS( c C s d S( N( ( t selft record( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/requests/__init__.pyt emits s ( t __name__t
__module__R6 ( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/requests/__init__.pyR3 r s t defaultR (? t __doc__t pip._vendorR R t warningst
exceptionsR R R t AssertionErrort
ValueErrort warnt formatt pip._vendor.urllib3.exceptionsR t simplefilterR R R R R R R R R t R R t modelsR R R t apiR R! R" R# R
R$ R% R& t sessionsR' R( t status_codesR) R* R+ R, R- R. R/ R0 R1 R2 t loggingR3 t ImportErrort Handlert getLoggerR7 t
addHandlert True( ( ( sA /usr/lib/python2.7/site-packages/pip/_vendor/requests/__init__.pyt ) s<
"" :@
PK ! >l5 5
compat.pyonu [
abc @ s5 d Z d d l m Z d d l Z e j Z e d d k Z e d d k Z d d l Z e rGd d l m
Z
m Z m Z m
Z
m Z m Z m Z m Z m Z d d l m Z m Z m Z m Z m Z d d l m Z d d l Z d d
l m Z d d l m Z d d l m Z e Z! e Z" e# Z e$ Z$ e% e& e' f Z( e% e& f Z) n e r1d d
l* m Z m Z m Z m Z m Z m
Z
m Z m Z m
Z
m Z d d l+ m Z m Z m Z m Z m Z d d l, m- Z d d
l. m Z d d l/ m Z d d l0 m Z e Z! e Z e" Z" e e" f Z$ e% e' f Z( e% f Z) n d S( sq
requests.compat
~~~~~~~~~~~~~~~
This module handles import compatibility issues between Python 2 and
Python 3.
i( t chardetNi i i ( t quotet unquotet
quote_plust unquote_plust urlencodet
getproxiest proxy_bypasst proxy_bypass_environmentt getproxies_environment( t urlparset
urlunparset urljoint urlsplitt urldefrag( t parse_http_list( t Morsel( t StringIO( t OrderedDict(
R
R R R
R R R R R R ( R R R R R ( t cookiejar(1 t __doc__t pip._vendorR t syst version_infot _vert is_py2t is_py3t jsont urllibR R R R R R R R R R
R R R
R t urllib2R t cookielibt CookieR R t) pip._vendor.urllib3.packages.ordered_dictR t strt builtin_strt bytest unicodet
basestringt intt longt floatt
numeric_typest
integer_typest urllib.parset urllib.requestt httpR t http.cookiest iot collections( ( ( s? /usr/lib/python2.7/site-packages/pip/_vendor/requests/compat.pyt sB @( F( PK ! 6 structures.pycnu [
Rec @ s\ d Z d d l m Z d d l m Z m Z d e f d YZ d e f d YZ d S(
sO
requests.structures
~~~~~~~~~~~~~~~~~~~
Data structures that power Requests.
i( t OrderedDicti ( t Mappingt MutableMappingt CaseInsensitiveDictc B sk e Z d Z d d Z d Z d Z d Z d Z d Z d Z
d Z d Z d
Z
RS( s A case-insensitive ``dict``-like object.
Implements all methods and operations of
``MutableMapping`` as well as dict's ``copy``. Also
provides ``lower_items``.
All keys are expected to be strings. The structure remembers the
case of the last key to be set, and ``iter(instance)``,
``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()``
will contain case-sensitive keys. However, querying and contains
testing is case insensitive::
cid = CaseInsensitiveDict()
cid['Accept'] = 'application/json'
cid['aCCEPT'] == 'application/json' # True
list(cid) == ['Accept'] # True
For example, ``headers['content-encoding']`` will return the
value of a ``'Content-Encoding'`` response header, regardless
of how the header name was originally stored.
If the constructor, ``.update``, or equality comparison
operations are given keys that have equal ``.lower()``s, the
behavior is undefined.
c K s5 t | _ | d k r! i } n | j | | d S( N( R t _storet Nonet update( t selft datat kwargs( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt __init__* s c C s | | f | j | j < s ( R t values( R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt __iter__; s c C s
t | j S( N( t lenR ( R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt __len__> s c C s d | j j D S( s. Like iteritems(), but with all lowercase keys.c s s% | ] \ } } | | d f Vq d S( i N( ( R t lowerkeyt keyval( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pys D s ( R t items( R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt lower_itemsA s c C sD t | t r t | } n t St | j t | j k S( N( t
isinstanceR R t NotImplementedt dictR ( R t other( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt __eq__I s c C s t | j j S( N( R R R ( R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt copyR s c C s t t | j S( N( t strR R ( R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt __repr__U s N( t __name__t
__module__t __doc__R R
R R R R R R R R! R# ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyR s t
LookupDictc B s8 e Z d Z d d Z d Z d Z d d Z RS( s Dictionary lookup object.c C s | | _ t t | j d S( N( t namet superR' R
( R R( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyR
\ s c C s d | j S( Ns
( R( ( R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyR# ` s c C s | j j | d S( N( t __dict__t getR ( R R ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyR c s c C s | j j | | S( N( R* R+ ( R R t default( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyR+ h s N( R$ R% R& R R
R# R R+ ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyR' Y s
N( R& t collectionsR t compatR R R R R' ( ( ( s /builddir/build/BUILDROOT/alt-python27-pip-20.2.4-5.el8.x86_64/opt/alt/python27/lib/python2.7/site-packages/pip/_vendor/requests/structures.pyt s JPK ! 2ۄW W cookies.pyonu [
abc @ sQ d Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l m Z m Z m
Z
m Z y d d l Z Wn e
k
r d d l Z n Xd e f d YZ d e f d YZ d
Z d Z d d d Z d
e f d YZ d e j e j f d YZ d Z d Z d Z d e d Z d Z d S( s
requests.cookies
~~~~~~~~~~~~~~~~
Compatibility code to be able to use `cookielib.CookieJar` with requests.
requests.utils imports from here, so be careful with imports.
iNi ( t to_native_string( t cookielibt urlparset
urlunparset Morselt MockRequestc B s e Z d Z d Z d Z d Z d Z d Z d Z d Z d d Z d Z d
Z
d Z e d Z e d
Z e d Z RS( s Wraps a `requests.Request` to mimic a `urllib2.Request`.
The code in `cookielib.CookieJar` expects this interface in order to correctly
manage cookie policies, i.e., determine whether a cookie can be set, given the
domains of the request and the cookie.
The original request object is read-only. The client is responsible for collecting
the new headers via `get_new_headers()` and interpreting them appropriately. You
probably want `get_cookie_header`, defined below.
c C s. | | _ i | _ t | j j j | _ d S( N( t _rt _new_headersR t urlt schemet type( t selft request( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt __init__& s c C s | j S( N( R
( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt get_type+ s c C s t | j j j S( N( R R R t netloc( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt get_host. s c C s
| j S( N( R ( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt get_origin_req_host1 s c C sx | j j j d s | j j St | j j d d d } t | j j } t | j | | j | j | j
| j g S( Nt Hostt encodings utf-8( R t headerst getR R R R R t patht paramst queryt fragment( R t hostt parsed( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt get_full_url4 s
c C s t S( N( t True( R ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt is_unverifiableB s c C s | | j j k p | | j k S( N( R R R ( R t name( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt
has_headerE s c C s% | j j j | | j j | | S( N( R R R R ( R R t default( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt
get_headerH s c C s t d d S( sM cookielib has no legitimate use for this method; add it back if you find one.s= Cookie headers should be added with add_unredirected_header()N( t NotImplementedError( R t keyt val( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt
add_headerK s c C s | | j | ( R R' RQ t resultt badargst err( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyRO s0
c C s! d } | d r_ y$ t t j t | d } Wq t k
r[ t d | d q Xn2 | d r d } t j t j | d | } n t d | d d t | d d t
d | d d | d | j d
| d
d d d i | d
d 6d t
d t | d d | j d | d p d
S( sB Convert a Morsel object into a Cookie containing the one k/v pair.s max-ages max-age: %s must be integerR s %a, %d-%b-%Y %H:%M:%S GMTR R R RB R R R R t httponlyR R R R' R i N(
R/ t intt timet
ValueErrorR t calendart timegmt strptimeRO R R` R$ R' ( t morselR t
time_template( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyRN s0
$
c C s | d k r t } n | d k r g | D] } | j ^ q+ } x@ | D]5 } | s_ | | k rG | j t | | | qG qG Wn | S( s- Returns a CookieJar from a key/value dictionary.
:param cookie_dict: Dict of key/values to insert into CookieJar.
:param cookiejar: (optional) A cookiejar to add the cookies to.
:param overwrite: (optional) If False, will not replace cookies
already in the jar with new ones.
N( R/ RJ R RP RO ( t cookie_dictRE t overwriteRG t names_from_jarR ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt cookiejar_from_dict s
$c C s t | t j s! t d n t | t rK t | d | d t } nX t | t j r y | j | Wq t k
r x | D] } | j | q Wq Xn | S( s Add cookies to cookiejar and returns a merged CookieJar.
:param cookiejar: CookieJar object to add the cookies to.
:param cookies: Dictionary or CookieJar object to be added.
s! You can only merge into CookieJarRE R (
RM R Ro R R R R` Rq t AttributeErrorRP ( RE t cookiest
cookie_in_jar( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt
merge_cookies s
(! R. Rp R R t collectionst _internal_utilsR t compatR R R R Rz t ImportErrort dummy_threadingt objectR R1 R= RA R/ RH t RuntimeErrorRI Ro t MutableMappingRJ R RO RN R R R ( ( ( s@ /usr/lib/python2.7/site-packages/pip/_vendor/requests/cookies.pyt