async def send(self,
request,
stream=False,
timeout=None,
verify=True,
cert=None,
proxies=None) -> Response:
method = request.method
url = request.url
headers = [(_encode(k), _encode(v))
for k, v in request.headers.items()]
if not request.body:
body = b""
elif isinstance(request.body, str):
body = _encode(request.body)
else:
body = request.body
if isinstance(timeout, tuple):
timeout_kwargs = {
"connect_timeout": timeout[0],
"read_timeout": timeout[1]
}
else:
timeout_kwargs = {
"connect_timeout": timeout,
"read_timeout": timeout
}
timeout = http3.TimeoutConfig(**timeout_kwargs)
try:
response = await self.pool.request(
method,
url,
headers=headers,
data=body,
cert=cert,
verify=verify,
timeout=timeout,
)
except socket.error as err:
raise ConnectionError(err, request=request)
except http3.ConnectTimeout as err:
raise ConnectTimeout(err, request=request)
except http3.ReadTimeout as err:
raise ReadTimeout(err, request=request)
if not stream:
await response.read()
return self.build_response(request, response)
async def send(
self,
request,
stream=False,
timeout=None,
verify=True,
cert=None,
proxies=None,
):
method = request.method
url = request.url
headers = [(_encode(k), _encode(v))
for k, v in request.headers.items()]
if not request.body:
body = b""
elif isinstance(request.body, str):
body = _encode(request.body)
else:
body = request.body
if isinstance(timeout, tuple):
timeout_kwargs = {
"connect_timeout": timeout[0],
"read_timeout": timeout[1],
}
else:
timeout_kwargs = {
"connect_timeout": timeout,
"read_timeout": timeout,
}
ssl = httpcore.SSLConfig(cert=cert, verify=verify)
timeout = httpcore.TimeoutConfig(**timeout_kwargs)
try:
response = await self.pool.request(
method,
url,
headers=headers,
body=body,
stream=stream,
ssl=ssl,
timeout=timeout,
)
except (httpcore.BadResponse, socket.error) as err:
raise ConnectionError(err, request=request)
except httpcore.ConnectTimeout as err:
raise requests.exceptions.ConnectTimeout(err, request=request)
except httpcore.ReadTimeout as err:
raise requests.exceptions.ReadTimeout(err, request=request)
return self.build_response(request, response)
async def send(self,
request,
stream=False,
timeout=None,
verify=True,
cert=None,
proxies=None) -> requests.Response:
urlparts = urlparse(request.url)
hostname = urlparts.hostname
port = urlparts.port
if port is None:
port = {"http": 80, "https": 443}[urlparts.scheme]
target = urlparts.path
if urlparts.query:
target += "?" + urlparts.query
headers = [("host", urlparts.netloc)] + list(request.headers.items())
ssl = get_ssl(urlparts, verify, cert)
if isinstance(timeout, tuple):
connect_timeout, read_timeout = timeout
else:
connect_timeout = timeout
read_timeout = timeout
try:
reader, writer = await asyncio.wait_for(
asyncio.open_connection(hostname, port, ssl=ssl),
connect_timeout)
except asyncio.TimeoutError:
raise requests.ConnectTimeout()
conn = h11.Connection(our_role=h11.CLIENT)
message = h11.Request(method=request.method,
target=target,
headers=headers)
data = conn.send(message)
writer.write(data)
if request.body:
body = (_encode(request.body)
if isinstance(request.body, str) else request.body)
message = h11.Data(data=body)
data = conn.send(message)
writer.write(data)
message = h11.EndOfMessage()
data = conn.send(message)
writer.write(data)
status_code = 0
headers = []
reason = b""
buffer = io.BytesIO()
while True:
event = conn.next_event()
event_type = type(event)
if event_type is h11.NEED_DATA:
try:
data = await asyncio.wait_for(reader.read(2048),
read_timeout)
except asyncio.TimeoutError:
raise requests.ReadTimeout()
conn.receive_data(data)
elif event_type is h11.Response:
status_code = event.status_code
headers = [(key.decode(), value.decode())
for key, value in event.headers]
reason = event.reason
elif event_type is h11.Data:
buffer.write(event.data)
elif event_type is h11.EndOfMessage:
buffer.seek(0)
break
writer.close()
if hasattr(writer, "wait_closed"):
await writer.wait_closed()
resp = urllib3.HTTPResponse(
body=buffer,
headers=headers,
status=status_code,
reason=reason,
preload_content=False,
)
return self.build_response(request, resp)
async def send(self,
request,
stream=False,
timeout=None,
verify=True,
cert=None,
proxies=None) -> requests.Response:
urlparts = urlparse(request.url)
if isinstance(timeout, tuple):
connect_timeout, read_timeout = timeout
else:
connect_timeout = timeout
read_timeout = timeout
connection = await self.manager.get_connection(url=urlparts,
verify=verify,
cert=cert,
timeout=connect_timeout)
target = urlparts.path
if urlparts.query:
target += "?" + urlparts.query
headers = [("host", urlparts.netloc)] + list(request.headers.items())
message = h11.Request(method=request.method,
target=target,
headers=headers)
await connection.send_event(message)
if request.body:
body = (_encode(request.body)
if isinstance(request.body, str) else request.body)
message = h11.Data(data=body)
await connection.send_event(message)
message = h11.EndOfMessage()
await connection.send_event(message)
status_code = 0
headers = []
reason = b""
buffer = io.BytesIO()
while True:
event = await connection.receive_event(read_timeout)
event_type = type(event)
if event_type is h11.Response:
status_code = event.status_code
headers = [(key.decode(), value.decode())
for key, value in event.headers]
reason = event.reason
elif event_type is h11.Data:
buffer.write(event.data)
elif event_type is h11.EndOfMessage:
buffer.seek(0)
break
await connection.close()
resp = urllib3.HTTPResponse(
body=buffer,
headers=headers,
status=status_code,
reason=reason,
preload_content=False,
)
return self.build_response(request, resp)