else:
self.base_url = URL(base_url)
- if proxies is None and trust_env:
- proxies = typing.cast(ProxiesTypes, get_environment_proxies())
-
- self.proxies: typing.Dict[str, AsyncDispatcher] = _proxies_to_dispatchers(
- proxies
- )
-
if params is None:
params = {}
self.dispatch = async_dispatch
self.concurrency_backend = backend
+ if proxies is None and trust_env:
+ proxies = typing.cast(ProxiesTypes, get_environment_proxies())
+
+ self.proxies: typing.Dict[str, AsyncDispatcher] = _proxies_to_dispatchers(
+ proxies,
+ verify=verify,
+ cert=cert,
+ timeout=timeout,
+ http_versions=http_versions,
+ pool_limits=pool_limits,
+ backend=backend,
+ trust_env=trust_env,
+ )
+
@property
def headers(self) -> Headers:
return self._headers
cert: CertTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
if request.url.scheme not in ("http", "https"):
raise InvalidURL('URL scheme must be "http" or "https".')
- if proxies is not None:
- dispatch_proxies = _proxies_to_dispatchers(proxies)
- else:
- dispatch_proxies = self.proxies
- dispatch = self._dispatcher_for_request(request, dispatch_proxies)
+ dispatch = self._dispatcher_for_request(request, self.proxies)
async def get_response(request: AsyncRequest) -> AsyncResponse:
try:
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self.request(
"GET",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def options(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self.request(
"OPTIONS",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def head(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self.request(
"HEAD",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def post(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self.request(
"POST",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def put(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self.request(
"PUT",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def patch(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self.request(
"PATCH",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def delete(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self.request(
"DELETE",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def request(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
request = self.build_request(
method=method,
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
return response
cert: CertTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> AsyncResponse:
return await self._get_response(
request=request,
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
async def close(self) -> None:
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
request = self.build_request(
method=method,
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
return response
cert: CertTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
concurrency_backend = self.concurrency_backend
"cert": cert,
"timeout": timeout,
"trust_env": trust_env,
- "proxies": proxies,
}
async_response = concurrency_backend.run(coroutine, *args, **kwargs)
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
return self.request(
"GET",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
def options(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
return self.request(
"OPTIONS",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
def head(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
return self.request(
"HEAD",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
def post(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
return self.request(
"POST",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
def put(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
return self.request(
"PUT",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
def patch(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
return self.request(
"PATCH",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
def delete(
verify: VerifyTypes = None,
timeout: TimeoutTypes = None,
trust_env: bool = None,
- proxies: ProxiesTypes = None,
) -> Response:
return self.request(
"DELETE",
cert=cert,
timeout=timeout,
trust_env=trust_env,
- proxies=proxies,
)
def close(self) -> None:
self.close()
-def _proxy_from_url(url: URLTypes) -> AsyncDispatcher:
- url = URL(url)
- if url.scheme in ("http", "https"):
- return HTTPProxy(url)
- raise ValueError(f"Unknown proxy for {url!r}")
-
-
def _proxies_to_dispatchers(
- proxies: typing.Optional[ProxiesTypes]
+ proxies: typing.Optional[ProxiesTypes],
+ verify: VerifyTypes,
+ cert: typing.Optional[CertTypes],
+ timeout: TimeoutTypes,
+ http_versions: typing.Optional[HTTPVersionTypes],
+ pool_limits: PoolLimits,
+ backend: ConcurrencyBackend,
+ trust_env: bool,
) -> typing.Dict[str, AsyncDispatcher]:
+ def _proxy_from_url(url: URLTypes) -> AsyncDispatcher:
+ nonlocal verify, cert, timeout, http_versions, pool_limits, backend, trust_env
+ url = URL(url)
+ if url.scheme in ("http", "https"):
+ return HTTPProxy(
+ url,
+ verify=verify,
+ cert=cert,
+ timeout=timeout,
+ pool_limits=pool_limits,
+ backend=backend,
+ trust_env=trust_env,
+ http_versions=http_versions,
+ )
+ raise ValueError(f"Unknown proxy for {url!r}")
+
if proxies is None:
return {}
elif isinstance(proxies, (str, URL)):