Upload folder using huggingface_hub

f1e6b80 verified about 1 year ago

60.2 kB

	import asyncio
	import functools
	import random
	import socket
	import sys
	import traceback
	import warnings
	from collections import OrderedDict, defaultdict, deque
	from contextlib import suppress
	from http import HTTPStatus
	from itertools import chain, cycle, islice
	from time import monotonic
	from types import TracebackType
	from typing import (
	TYPE_CHECKING,
	Any,
	Awaitable,
	Callable,
	DefaultDict,
	Deque,
	Dict,
	Iterator,
	List,
	Literal,
	Optional,
	Sequence,
	Set,
	Tuple,
	Type,
	Union,
	cast,
	)

	import aiohappyeyeballs

	from . import hdrs, helpers
	from .abc import AbstractResolver, ResolveResult
	from .client_exceptions import (
	ClientConnectionError,
	ClientConnectorCertificateError,
	ClientConnectorDNSError,
	ClientConnectorError,
	ClientConnectorSSLError,
	ClientHttpProxyError,
	ClientProxyConnectionError,
	ServerFingerprintMismatch,
	UnixClientConnectorError,
	cert_errors,
	ssl_errors,
	)
	from .client_proto import ResponseHandler
	from .client_reqrep import ClientRequest, Fingerprint, _merge_ssl_params
	from .helpers import (
	ceil_timeout,
	is_ip_address,
	noop,
	sentinel,
	set_exception,
	set_result,
	)
	from .resolver import DefaultResolver

	if TYPE_CHECKING:
	import ssl

	SSLContext = ssl.SSLContext
	else:
	try:
	import ssl

	SSLContext = ssl.SSLContext
	except ImportError: # pragma: no cover
	ssl = None # type: ignore[assignment]
	SSLContext = object # type: ignore[misc,assignment]

	EMPTY_SCHEMA_SET = frozenset({""})
	HTTP_SCHEMA_SET = frozenset({"http", "https"})
	WS_SCHEMA_SET = frozenset({"ws", "wss"})

	HTTP_AND_EMPTY_SCHEMA_SET = HTTP_SCHEMA_SET \| EMPTY_SCHEMA_SET
	HIGH_LEVEL_SCHEMA_SET = HTTP_AND_EMPTY_SCHEMA_SET \| WS_SCHEMA_SET

	NEEDS_CLEANUP_CLOSED = (3, 13, 0) <= sys.version_info < (
	3,
	13,
	1,
	) or sys.version_info < (3, 12, 7)
	# Cleanup closed is no longer needed after https://github.com/python/cpython/pull/118960
	# which first appeared in Python 3.12.7 and 3.13.1


	__all__ = ("BaseConnector", "TCPConnector", "UnixConnector", "NamedPipeConnector")


	if TYPE_CHECKING:
	from .client import ClientTimeout
	from .client_reqrep import ConnectionKey
	from .tracing import Trace


	class _DeprecationWaiter:
	__slots__ = ("_awaitable", "_awaited")

	def __init__(self, awaitable: Awaitable[Any]) -> None:
	self._awaitable = awaitable
	self._awaited = False

	def __await__(self) -> Any:
	self._awaited = True
	return self._awaitable.__await__()

	def __del__(self) -> None:
	if not self._awaited:
	warnings.warn(
	"Connector.close() is a coroutine, "
	"please use await connector.close()",
	DeprecationWarning,
	)


	class Connection:

	_source_traceback = None

	def __init__(
	self,
	connector: "BaseConnector",
	key: "ConnectionKey",
	protocol: ResponseHandler,
	loop: asyncio.AbstractEventLoop,
	) -> None:
	self._key = key
	self._connector = connector
	self._loop = loop
	self._protocol: Optional[ResponseHandler] = protocol
	self._callbacks: List[Callable[[], None]] = []

	if loop.get_debug():
	self._source_traceback = traceback.extract_stack(sys._getframe(1))

	def __repr__(self) -> str:
	return f"Connection<{self._key}>"

	def __del__(self, _warnings: Any = warnings) -> None:
	if self._protocol is not None:
	kwargs = {"source": self}
	_warnings.warn(f"Unclosed connection {self!r}", ResourceWarning, **kwargs)
	if self._loop.is_closed():
	return

	self._connector._release(self._key, self._protocol, should_close=True)

	context = {"client_connection": self, "message": "Unclosed connection"}
	if self._source_traceback is not None:
	context["source_traceback"] = self._source_traceback
	self._loop.call_exception_handler(context)

	def __bool__(self) -> Literal[True]:
	"""Force subclasses to not be falsy, to make checks simpler."""
	return True

	@property
	def loop(self) -> asyncio.AbstractEventLoop:
	warnings.warn(
	"connector.loop property is deprecated", DeprecationWarning, stacklevel=2
	)
	return self._loop

	@property
	def transport(self) -> Optional[asyncio.Transport]:
	if self._protocol is None:
	return None
	return self._protocol.transport

	@property
	def protocol(self) -> Optional[ResponseHandler]:
	return self._protocol

	def add_callback(self, callback: Callable[[], None]) -> None:
	if callback is not None:
	self._callbacks.append(callback)

	def _notify_release(self) -> None:
	callbacks, self._callbacks = self._callbacks[:], []

	for cb in callbacks:
	with suppress(Exception):
	cb()

	def close(self) -> None:
	self._notify_release()

	if self._protocol is not None:
	self._connector._release(self._key, self._protocol, should_close=True)
	self._protocol = None

	def release(self) -> None:
	self._notify_release()

	if self._protocol is not None:
	self._connector._release(self._key, self._protocol)
	self._protocol = None

	@property
	def closed(self) -> bool:
	return self._protocol is None or not self._protocol.is_connected()


	class _TransportPlaceholder:
	"""placeholder for BaseConnector.connect function"""

	__slots__ = ()

	def close(self) -> None:
	"""Close the placeholder transport."""


	class BaseConnector:
	"""Base connector class.

	keepalive_timeout - (optional) Keep-alive timeout.
	force_close - Set to True to force close and do reconnect
	after each request (and between redirects).
	limit - The total number of simultaneous connections.
	limit_per_host - Number of simultaneous connections to one host.
	enable_cleanup_closed - Enables clean-up closed ssl transports.
	Disabled by default.
	timeout_ceil_threshold - Trigger ceiling of timeout values when
	it's above timeout_ceil_threshold.
	loop - Optional event loop.
	"""

	_closed = True # prevent AttributeError in __del__ if ctor was failed
	_source_traceback = None

	# abort transport after 2 seconds (cleanup broken connections)
	_cleanup_closed_period = 2.0

	allowed_protocol_schema_set = HIGH_LEVEL_SCHEMA_SET

	def __init__(
	self,
	*,
	keepalive_timeout: Union[object, None, float] = sentinel,
	force_close: bool = False,
	limit: int = 100,
	limit_per_host: int = 0,
	enable_cleanup_closed: bool = False,
	loop: Optional[asyncio.AbstractEventLoop] = None,
	timeout_ceil_threshold: float = 5,
	) -> None:

	if force_close:
	if keepalive_timeout is not None and keepalive_timeout is not sentinel:
	raise ValueError(
	"keepalive_timeout cannot be set if force_close is True"
	)
	else:
	if keepalive_timeout is sentinel:
	keepalive_timeout = 15.0

	loop = loop or asyncio.get_running_loop()
	self._timeout_ceil_threshold = timeout_ceil_threshold

	self._closed = False
	if loop.get_debug():
	self._source_traceback = traceback.extract_stack(sys._getframe(1))

	# Connection pool of reusable connections.
	# We use a deque to store connections because it has O(1) popleft()
	# and O(1) append() operations to implement a FIFO queue.
	self._conns: DefaultDict[
	ConnectionKey, Deque[Tuple[ResponseHandler, float]]
	] = defaultdict(deque)
	self._limit = limit
	self._limit_per_host = limit_per_host
	self._acquired: Set[ResponseHandler] = set()
	self._acquired_per_host: DefaultDict[ConnectionKey, Set[ResponseHandler]] = (
	defaultdict(set)
	)
	self._keepalive_timeout = cast(float, keepalive_timeout)
	self._force_close = force_close

	# {host_key: FIFO list of waiters}
	# The FIFO is implemented with an OrderedDict with None keys because
	# python does not have an ordered set.
	self._waiters: DefaultDict[
	ConnectionKey, OrderedDict[asyncio.Future[None], None]
	] = defaultdict(OrderedDict)

	self._loop = loop
	self._factory = functools.partial(ResponseHandler, loop=loop)

	# start keep-alive connection cleanup task
	self._cleanup_handle: Optional[asyncio.TimerHandle] = None

	# start cleanup closed transports task
	self._cleanup_closed_handle: Optional[asyncio.TimerHandle] = None

	if enable_cleanup_closed and not NEEDS_CLEANUP_CLOSED:
	warnings.warn(
	"enable_cleanup_closed ignored because "
	"https://github.com/python/cpython/pull/118960 is fixed "
	f"in Python version {sys.version_info}",
	DeprecationWarning,
	stacklevel=2,
	)
	enable_cleanup_closed = False

	self._cleanup_closed_disabled = not enable_cleanup_closed
	self._cleanup_closed_transports: List[Optional[asyncio.Transport]] = []
	self._cleanup_closed()

	def __del__(self, _warnings: Any = warnings) -> None:
	if self._closed:
	return
	if not self._conns:
	return

	conns = [repr(c) for c in self._conns.values()]

	self._close()

	kwargs = {"source": self}
	_warnings.warn(f"Unclosed connector {self!r}", ResourceWarning, **kwargs)
	context = {
	"connector": self,
	"connections": conns,
	"message": "Unclosed connector",
	}
	if self._source_traceback is not None:
	context["source_traceback"] = self._source_traceback
	self._loop.call_exception_handler(context)

	def __enter__(self) -> "BaseConnector":
	warnings.warn(
	'"with Connector():" is deprecated, '
	'use "async with Connector():" instead',
	DeprecationWarning,
	)
	return self

	def __exit__(self, *exc: Any) -> None:
	self._close()

	async def __aenter__(self) -> "BaseConnector":
	return self

	async def __aexit__(
	self,
	exc_type: Optional[Type[BaseException]] = None,
	exc_value: Optional[BaseException] = None,
	exc_traceback: Optional[TracebackType] = None,
	) -> None:
	await self.close()

	@property
	def force_close(self) -> bool:
	"""Ultimately close connection on releasing if True."""
	return self._force_close

	@property
	def limit(self) -> int:
	"""The total number for simultaneous connections.

	If limit is 0 the connector has no limit.
	The default limit size is 100.
	"""
	return self._limit

	@property
	def limit_per_host(self) -> int:
	"""The limit for simultaneous connections to the same endpoint.

	Endpoints are the same if they are have equal
	(host, port, is_ssl) triple.
	"""
	return self._limit_per_host

	def _cleanup(self) -> None:
	"""Cleanup unused transports."""
	if self._cleanup_handle:
	self._cleanup_handle.cancel()
	# _cleanup_handle should be unset, otherwise _release() will not
	# recreate it ever!
	self._cleanup_handle = None

	now = monotonic()
	timeout = self._keepalive_timeout

	if self._conns:
	connections = defaultdict(deque)
	deadline = now - timeout
	for key, conns in self._conns.items():
	alive: Deque[Tuple[ResponseHandler, float]] = deque()
	for proto, use_time in conns:
	if proto.is_connected() and use_time - deadline >= 0:
	alive.append((proto, use_time))
	continue
	transport = proto.transport
	proto.close()
	if not self._cleanup_closed_disabled and key.is_ssl:
	self._cleanup_closed_transports.append(transport)

	if alive:
	connections[key] = alive

	self._conns = connections

	if self._conns:
	self._cleanup_handle = helpers.weakref_handle(
	self,
	"_cleanup",
	timeout,
	self._loop,
	timeout_ceil_threshold=self._timeout_ceil_threshold,
	)

	def _cleanup_closed(self) -> None:
	"""Double confirmation for transport close.

	Some broken ssl servers may leave socket open without proper close.
	"""
	if self._cleanup_closed_handle:
	self._cleanup_closed_handle.cancel()

	for transport in self._cleanup_closed_transports:
	if transport is not None:
	transport.abort()

	self._cleanup_closed_transports = []

	if not self._cleanup_closed_disabled:
	self._cleanup_closed_handle = helpers.weakref_handle(
	self,
	"_cleanup_closed",
	self._cleanup_closed_period,
	self._loop,
	timeout_ceil_threshold=self._timeout_ceil_threshold,
	)

	def close(self) -> Awaitable[None]:
	"""Close all opened transports."""
	self._close()
	return _DeprecationWaiter(noop())

	def _close(self) -> None:
	if self._closed:
	return

	self._closed = True

	try:
	if self._loop.is_closed():
	return

	# cancel cleanup task
	if self._cleanup_handle:
	self._cleanup_handle.cancel()

	# cancel cleanup close task
	if self._cleanup_closed_handle:
	self._cleanup_closed_handle.cancel()

	for data in self._conns.values():
	for proto, t0 in data:
	proto.close()

	for proto in self._acquired:
	proto.close()

	for transport in self._cleanup_closed_transports:
	if transport is not None:
	transport.abort()

	finally:
	self._conns.clear()
	self._acquired.clear()
	for keyed_waiters in self._waiters.values():
	for keyed_waiter in keyed_waiters:
	keyed_waiter.cancel()
	self._waiters.clear()
	self._cleanup_handle = None
	self._cleanup_closed_transports.clear()
	self._cleanup_closed_handle = None

	@property
	def closed(self) -> bool:
	"""Is connector closed.

	A readonly property.
	"""
	return self._closed

	def _available_connections(self, key: "ConnectionKey") -> int:
	"""
	Return number of available connections.

	The limit, limit_per_host and the connection key are taken into account.

	If it returns less than 1 means that there are no connections
	available.
	"""
	# check total available connections
	# If there are no limits, this will always return 1
	total_remain = 1

	if self._limit and (total_remain := self._limit - len(self._acquired)) <= 0:
	return total_remain

	# check limit per host
	if host_remain := self._limit_per_host:
	if acquired := self._acquired_per_host.get(key):
	host_remain -= len(acquired)
	if total_remain > host_remain:
	return host_remain

	return total_remain

	async def connect(
	self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
	) -> Connection:
	"""Get from pool or create new connection."""
	key = req.connection_key
	if (conn := await self._get(key, traces)) is not None:
	# If we do not have to wait and we can get a connection from the pool
	# we can avoid the timeout ceil logic and directly return the connection
	return conn

	async with ceil_timeout(timeout.connect, timeout.ceil_threshold):
	if self._available_connections(key) <= 0:
	await self._wait_for_available_connection(key, traces)
	if (conn := await self._get(key, traces)) is not None:
	return conn

	placeholder = cast(ResponseHandler, _TransportPlaceholder())
	self._acquired.add(placeholder)
	if self._limit_per_host:
	self._acquired_per_host[key].add(placeholder)

	try:
	# Traces are done inside the try block to ensure that the
	# that the placeholder is still cleaned up if an exception
	# is raised.
	if traces:
	for trace in traces:
	await trace.send_connection_create_start()
	proto = await self._create_connection(req, traces, timeout)
	if traces:
	for trace in traces:
	await trace.send_connection_create_end()
	except BaseException:
	self._release_acquired(key, placeholder)
	raise
	else:
	if self._closed:
	proto.close()
	raise ClientConnectionError("Connector is closed.")

	# The connection was successfully created, drop the placeholder
	# and add the real connection to the acquired set. There should
	# be no awaits after the proto is added to the acquired set
	# to ensure that the connection is not left in the acquired set
	# on cancellation.
	self._acquired.remove(placeholder)
	self._acquired.add(proto)
	if self._limit_per_host:
	acquired_per_host = self._acquired_per_host[key]
	acquired_per_host.remove(placeholder)
	acquired_per_host.add(proto)
	return Connection(self, key, proto, self._loop)

	async def _wait_for_available_connection(
	self, key: "ConnectionKey", traces: List["Trace"]
	) -> None:
	"""Wait for an available connection slot."""
	# We loop here because there is a race between
	# the connection limit check and the connection
	# being acquired. If the connection is acquired
	# between the check and the await statement, we
	# need to loop again to check if the connection
	# slot is still available.
	attempts = 0
	while True:
	fut: asyncio.Future[None] = self._loop.create_future()
	keyed_waiters = self._waiters[key]
	keyed_waiters[fut] = None
	if attempts:
	# If we have waited before, we need to move the waiter
	# to the front of the queue as otherwise we might get
	# starved and hit the timeout.
	keyed_waiters.move_to_end(fut, last=False)

	try:
	# Traces happen in the try block to ensure that the
	# the waiter is still cleaned up if an exception is raised.
	if traces:
	for trace in traces:
	await trace.send_connection_queued_start()
	await fut
	if traces:
	for trace in traces:
	await trace.send_connection_queued_end()
	finally:
	# pop the waiter from the queue if its still
	# there and not already removed by _release_waiter
	keyed_waiters.pop(fut, None)
	if not self._waiters.get(key, True):
	del self._waiters[key]

	if self._available_connections(key) > 0:
	break
	attempts += 1

	async def _get(
	self, key: "ConnectionKey", traces: List["Trace"]
	) -> Optional[Connection]:
	"""Get next reusable connection for the key or None.

	The connection will be marked as acquired.
	"""
	if (conns := self._conns.get(key)) is None:
	return None

	t1 = monotonic()
	while conns:
	proto, t0 = conns.popleft()
	# We will we reuse the connection if its connected and
	# the keepalive timeout has not been exceeded
	if proto.is_connected() and t1 - t0 <= self._keepalive_timeout:
	if not conns:
	# The very last connection was reclaimed: drop the key
	del self._conns[key]
	self._acquired.add(proto)
	if self._limit_per_host:
	self._acquired_per_host[key].add(proto)
	if traces:
	for trace in traces:
	try:
	await trace.send_connection_reuseconn()
	except BaseException:
	self._release_acquired(key, proto)
	raise
	return Connection(self, key, proto, self._loop)

	# Connection cannot be reused, close it
	transport = proto.transport
	proto.close()
	# only for SSL transports
	if not self._cleanup_closed_disabled and key.is_ssl:
	self._cleanup_closed_transports.append(transport)

	# No more connections: drop the key
	del self._conns[key]
	return None

	def _release_waiter(self) -> None:
	"""
	Iterates over all waiters until one to be released is found.

	The one to be released is not finished and
	belongs to a host that has available connections.
	"""
	if not self._waiters:
	return

	# Having the dict keys ordered this avoids to iterate
	# at the same order at each call.
	queues = list(self._waiters)
	random.shuffle(queues)

	for key in queues:
	if self._available_connections(key) < 1:
	continue

	waiters = self._waiters[key]
	while waiters:
	waiter, _ = waiters.popitem(last=False)
	if not waiter.done():
	waiter.set_result(None)
	return

	def _release_acquired(self, key: "ConnectionKey", proto: ResponseHandler) -> None:
	"""Release acquired connection."""
	if self._closed:
	# acquired connection is already released on connector closing
	return

	self._acquired.discard(proto)
	if self._limit_per_host and (conns := self._acquired_per_host.get(key)):
	conns.discard(proto)
	if not conns:
	del self._acquired_per_host[key]
	self._release_waiter()

	def _release(
	self,
	key: "ConnectionKey",
	protocol: ResponseHandler,
	*,
	should_close: bool = False,
	) -> None:
	if self._closed:
	# acquired connection is already released on connector closing
	return

	self._release_acquired(key, protocol)

	if self._force_close or should_close or protocol.should_close:
	transport = protocol.transport
	protocol.close()

	if key.is_ssl and not self._cleanup_closed_disabled:
	self._cleanup_closed_transports.append(transport)
	return

	self._conns[key].append((protocol, monotonic()))

	if self._cleanup_handle is None:
	self._cleanup_handle = helpers.weakref_handle(
	self,
	"_cleanup",
	self._keepalive_timeout,
	self._loop,
	timeout_ceil_threshold=self._timeout_ceil_threshold,
	)

	async def _create_connection(
	self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
	) -> ResponseHandler:
	raise NotImplementedError()


	class _DNSCacheTable:
	def __init__(self, ttl: Optional[float] = None) -> None:
	self._addrs_rr: Dict[Tuple[str, int], Tuple[Iterator[ResolveResult], int]] = {}
	self._timestamps: Dict[Tuple[str, int], float] = {}
	self._ttl = ttl

	def __contains__(self, host: object) -> bool:
	return host in self._addrs_rr

	def add(self, key: Tuple[str, int], addrs: List[ResolveResult]) -> None:
	self._addrs_rr[key] = (cycle(addrs), len(addrs))

	if self._ttl is not None:
	self._timestamps[key] = monotonic()

	def remove(self, key: Tuple[str, int]) -> None:
	self._addrs_rr.pop(key, None)

	if self._ttl is not None:
	self._timestamps.pop(key, None)

	def clear(self) -> None:
	self._addrs_rr.clear()
	self._timestamps.clear()

	def next_addrs(self, key: Tuple[str, int]) -> List[ResolveResult]:
	loop, length = self._addrs_rr[key]
	addrs = list(islice(loop, length))
	# Consume one more element to shift internal state of `cycle`
	next(loop)
	return addrs

	def expired(self, key: Tuple[str, int]) -> bool:
	if self._ttl is None:
	return False

	return self._timestamps[key] + self._ttl < monotonic()


	def _make_ssl_context(verified: bool) -> SSLContext:
	"""Create SSL context.

	This method is not async-friendly and should be called from a thread
	because it will load certificates from disk and do other blocking I/O.
	"""
	if ssl is None:
	# No ssl support
	return None
	if verified:
	sslcontext = ssl.create_default_context()
	else:
	sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
	sslcontext.options \|= ssl.OP_NO_SSLv2
	sslcontext.options \|= ssl.OP_NO_SSLv3
	sslcontext.check_hostname = False
	sslcontext.verify_mode = ssl.CERT_NONE
	sslcontext.options \|= ssl.OP_NO_COMPRESSION
	sslcontext.set_default_verify_paths()
	sslcontext.set_alpn_protocols(("http/1.1",))
	return sslcontext


	# The default SSLContext objects are created at import time
	# since they do blocking I/O to load certificates from disk,
	# and imports should always be done before the event loop starts
	# or in a thread.
	_SSL_CONTEXT_VERIFIED = _make_ssl_context(True)
	_SSL_CONTEXT_UNVERIFIED = _make_ssl_context(False)


	class TCPConnector(BaseConnector):
	"""TCP connector.

	verify_ssl - Set to True to check ssl certifications.
	fingerprint - Pass the binary sha256
	digest of the expected certificate in DER format to verify
	that the certificate the server presents matches. See also
	https://en.wikipedia.org/wiki/HTTP_Public_Key_Pinning
	resolver - Enable DNS lookups and use this
	resolver
	use_dns_cache - Use memory cache for DNS lookups.
	ttl_dns_cache - Max seconds having cached a DNS entry, None forever.
	family - socket address family
	local_addr - local tuple of (host, port) to bind socket to

	keepalive_timeout - (optional) Keep-alive timeout.
	force_close - Set to True to force close and do reconnect
	after each request (and between redirects).
	limit - The total number of simultaneous connections.
	limit_per_host - Number of simultaneous connections to one host.
	enable_cleanup_closed - Enables clean-up closed ssl transports.
	Disabled by default.
	happy_eyeballs_delay - This is the “Connection Attempt Delay”
	as defined in RFC 8305. To disable
	the happy eyeballs algorithm, set to None.
	interleave - “First Address Family Count” as defined in RFC 8305
	loop - Optional event loop.
	"""

	allowed_protocol_schema_set = HIGH_LEVEL_SCHEMA_SET \| frozenset({"tcp"})

	def __init__(
	self,
	*,
	verify_ssl: bool = True,
	fingerprint: Optional[bytes] = None,
	use_dns_cache: bool = True,
	ttl_dns_cache: Optional[int] = 10,
	family: socket.AddressFamily = socket.AddressFamily.AF_UNSPEC,
	ssl_context: Optional[SSLContext] = None,
	ssl: Union[bool, Fingerprint, SSLContext] = True,
	local_addr: Optional[Tuple[str, int]] = None,
	resolver: Optional[AbstractResolver] = None,
	keepalive_timeout: Union[None, float, object] = sentinel,
	force_close: bool = False,
	limit: int = 100,
	limit_per_host: int = 0,
	enable_cleanup_closed: bool = False,
	loop: Optional[asyncio.AbstractEventLoop] = None,
	timeout_ceil_threshold: float = 5,
	happy_eyeballs_delay: Optional[float] = 0.25,
	interleave: Optional[int] = None,
	):
	super().__init__(
	keepalive_timeout=keepalive_timeout,
	force_close=force_close,
	limit=limit,
	limit_per_host=limit_per_host,
	enable_cleanup_closed=enable_cleanup_closed,
	loop=loop,
	timeout_ceil_threshold=timeout_ceil_threshold,
	)

	self._ssl = _merge_ssl_params(ssl, verify_ssl, ssl_context, fingerprint)
	if resolver is None:
	resolver = DefaultResolver(loop=self._loop)
	self._resolver = resolver

	self._use_dns_cache = use_dns_cache
	self._cached_hosts = _DNSCacheTable(ttl=ttl_dns_cache)
	self._throttle_dns_futures: Dict[
	Tuple[str, int], Set["asyncio.Future[None]"]
	] = {}
	self._family = family
	self._local_addr_infos = aiohappyeyeballs.addr_to_addr_infos(local_addr)
	self._happy_eyeballs_delay = happy_eyeballs_delay
	self._interleave = interleave
	self._resolve_host_tasks: Set["asyncio.Task[List[ResolveResult]]"] = set()

	def close(self) -> Awaitable[None]:
	"""Close all ongoing DNS calls."""
	for fut in chain.from_iterable(self._throttle_dns_futures.values()):
	fut.cancel()

	for t in self._resolve_host_tasks:
	t.cancel()

	return super().close()

	@property
	def family(self) -> int:
	"""Socket family like AF_INET."""
	return self._family

	@property
	def use_dns_cache(self) -> bool:
	"""True if local DNS caching is enabled."""
	return self._use_dns_cache

	def clear_dns_cache(
	self, host: Optional[str] = None, port: Optional[int] = None
	) -> None:
	"""Remove specified host/port or clear all dns local cache."""
	if host is not None and port is not None:
	self._cached_hosts.remove((host, port))
	elif host is not None or port is not None:
	raise ValueError("either both host and port or none of them are allowed")
	else:
	self._cached_hosts.clear()

	async def _resolve_host(
	self, host: str, port: int, traces: Optional[Sequence["Trace"]] = None
	) -> List[ResolveResult]:
	"""Resolve host and return list of addresses."""
	if is_ip_address(host):
	return [
	{
	"hostname": host,
	"host": host,
	"port": port,
	"family": self._family,
	"proto": 0,
	"flags": 0,
	}
	]

	if not self._use_dns_cache:

	if traces:
	for trace in traces:
	await trace.send_dns_resolvehost_start(host)

	res = await self._resolver.resolve(host, port, family=self._family)

	if traces:
	for trace in traces:
	await trace.send_dns_resolvehost_end(host)

	return res

	key = (host, port)
	if key in self._cached_hosts and not self._cached_hosts.expired(key):
	# get result early, before any await (#4014)
	result = self._cached_hosts.next_addrs(key)

	if traces:
	for trace in traces:
	await trace.send_dns_cache_hit(host)
	return result

	futures: Set["asyncio.Future[None]"]
	#
	# If multiple connectors are resolving the same host, we wait
	# for the first one to resolve and then use the result for all of them.
	# We use a throttle to ensure that we only resolve the host once
	# and then use the result for all the waiters.
	#
	if key in self._throttle_dns_futures:
	# get futures early, before any await (#4014)
	futures = self._throttle_dns_futures[key]
	future: asyncio.Future[None] = self._loop.create_future()
	futures.add(future)
	if traces:
	for trace in traces:
	await trace.send_dns_cache_hit(host)
	try:
	await future
	finally:
	futures.discard(future)
	return self._cached_hosts.next_addrs(key)

	# update dict early, before any await (#4014)
	self._throttle_dns_futures[key] = futures = set()
	# In this case we need to create a task to ensure that we can shield
	# the task from cancellation as cancelling this lookup should not cancel
	# the underlying lookup or else the cancel event will get broadcast to
	# all the waiters across all connections.
	#
	coro = self._resolve_host_with_throttle(key, host, port, futures, traces)
	loop = asyncio.get_running_loop()
	if sys.version_info >= (3, 12):
	# Optimization for Python 3.12, try to send immediately
	resolved_host_task = asyncio.Task(coro, loop=loop, eager_start=True)
	else:
	resolved_host_task = loop.create_task(coro)

	if not resolved_host_task.done():
	self._resolve_host_tasks.add(resolved_host_task)
	resolved_host_task.add_done_callback(self._resolve_host_tasks.discard)

	try:
	return await asyncio.shield(resolved_host_task)
	except asyncio.CancelledError:

	def drop_exception(fut: "asyncio.Future[List[ResolveResult]]") -> None:
	with suppress(Exception, asyncio.CancelledError):
	fut.result()

	resolved_host_task.add_done_callback(drop_exception)
	raise

	async def _resolve_host_with_throttle(
	self,
	key: Tuple[str, int],
	host: str,
	port: int,
	futures: Set["asyncio.Future[None]"],
	traces: Optional[Sequence["Trace"]],
	) -> List[ResolveResult]:
	"""Resolve host and set result for all waiters.

	This method must be run in a task and shielded from cancellation
	to avoid cancelling the underlying lookup.
	"""
	if traces:
	for trace in traces:
	await trace.send_dns_cache_miss(host)
	try:
	if traces:
	for trace in traces:
	await trace.send_dns_resolvehost_start(host)

	addrs = await self._resolver.resolve(host, port, family=self._family)
	if traces:
	for trace in traces:
	await trace.send_dns_resolvehost_end(host)

	self._cached_hosts.add(key, addrs)
	for fut in futures:
	set_result(fut, None)
	except BaseException as e:
	# any DNS exception is set for the waiters to raise the same exception.
	# This coro is always run in task that is shielded from cancellation so
	# we should never be propagating cancellation here.
	for fut in futures:
	set_exception(fut, e)
	raise
	finally:
	self._throttle_dns_futures.pop(key)

	return self._cached_hosts.next_addrs(key)

	async def _create_connection(
	self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
	) -> ResponseHandler:
	"""Create connection.

	Has same keyword arguments as BaseEventLoop.create_connection.
	"""
	if req.proxy:
	_, proto = await self._create_proxy_connection(req, traces, timeout)
	else:
	_, proto = await self._create_direct_connection(req, traces, timeout)

	return proto

	def _get_ssl_context(self, req: ClientRequest) -> Optional[SSLContext]:
	"""Logic to get the correct SSL context

	0. if req.ssl is false, return None

	1. if ssl_context is specified in req, use it
	2. if _ssl_context is specified in self, use it
	3. otherwise:
	1. if verify_ssl is not specified in req, use self.ssl_context
	(will generate a default context according to self.verify_ssl)
	2. if verify_ssl is True in req, generate a default SSL context
	3. if verify_ssl is False in req, generate a SSL context that
	won't verify
	"""
	if not req.is_ssl():
	return None

	if ssl is None: # pragma: no cover
	raise RuntimeError("SSL is not supported.")
	sslcontext = req.ssl
	if isinstance(sslcontext, ssl.SSLContext):
	return sslcontext
	if sslcontext is not True:
	# not verified or fingerprinted
	return _SSL_CONTEXT_UNVERIFIED
	sslcontext = self._ssl
	if isinstance(sslcontext, ssl.SSLContext):
	return sslcontext
	if sslcontext is not True:
	# not verified or fingerprinted
	return _SSL_CONTEXT_UNVERIFIED
	return _SSL_CONTEXT_VERIFIED

	def _get_fingerprint(self, req: ClientRequest) -> Optional["Fingerprint"]:
	ret = req.ssl
	if isinstance(ret, Fingerprint):
	return ret
	ret = self._ssl
	if isinstance(ret, Fingerprint):
	return ret
	return None

	async def _wrap_create_connection(
	self,
	*args: Any,
	addr_infos: List[aiohappyeyeballs.AddrInfoType],
	req: ClientRequest,
	timeout: "ClientTimeout",
	client_error: Type[Exception] = ClientConnectorError,
	**kwargs: Any,
	) -> Tuple[asyncio.Transport, ResponseHandler]:
	try:
	async with ceil_timeout(
	timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
	):
	sock = await aiohappyeyeballs.start_connection(
	addr_infos=addr_infos,
	local_addr_infos=self._local_addr_infos,
	happy_eyeballs_delay=self._happy_eyeballs_delay,
	interleave=self._interleave,
	loop=self._loop,
	)
	return await self._loop.create_connection(args, *kwargs, sock=sock)
	except cert_errors as exc:
	raise ClientConnectorCertificateError(req.connection_key, exc) from exc
	except ssl_errors as exc:
	raise ClientConnectorSSLError(req.connection_key, exc) from exc
	except OSError as exc:
	if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
	raise
	raise client_error(req.connection_key, exc) from exc

	async def _wrap_existing_connection(
	self,
	*args: Any,
	req: ClientRequest,
	timeout: "ClientTimeout",
	client_error: Type[Exception] = ClientConnectorError,
	**kwargs: Any,
	) -> Tuple[asyncio.Transport, ResponseHandler]:
	try:
	async with ceil_timeout(
	timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
	):
	return await self._loop.create_connection(args, *kwargs)
	except cert_errors as exc:
	raise ClientConnectorCertificateError(req.connection_key, exc) from exc
	except ssl_errors as exc:
	raise ClientConnectorSSLError(req.connection_key, exc) from exc
	except OSError as exc:
	if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
	raise
	raise client_error(req.connection_key, exc) from exc

	def _fail_on_no_start_tls(self, req: "ClientRequest") -> None:
	"""Raise a :py:exc:`RuntimeError` on missing ``start_tls()``.

	It is necessary for TLS-in-TLS so that it is possible to
	send HTTPS queries through HTTPS proxies.

	This doesn't affect regular HTTP requests, though.
	"""
	if not req.is_ssl():
	return

	proxy_url = req.proxy
	assert proxy_url is not None
	if proxy_url.scheme != "https":
	return

	self._check_loop_for_start_tls()

	def _check_loop_for_start_tls(self) -> None:
	try:
	self._loop.start_tls
	except AttributeError as attr_exc:
	raise RuntimeError(
	"An HTTPS request is being sent through an HTTPS proxy. "
	"This needs support for TLS in TLS but it is not implemented "
	"in your runtime for the stdlib asyncio.\n\n"
	"Please upgrade to Python 3.11 or higher. For more details, "
	"please see:\n"
	"* https://bugs.python.org/issue37179\n"
	"* https://github.com/python/cpython/pull/28073\n"
	"* https://docs.aiohttp.org/en/stable/"
	"client_advanced.html#proxy-support\n"
	"* https://github.com/aio-libs/aiohttp/discussions/6044\n",
	) from attr_exc

	def _loop_supports_start_tls(self) -> bool:
	try:
	self._check_loop_for_start_tls()
	except RuntimeError:
	return False
	else:
	return True

	def _warn_about_tls_in_tls(
	self,
	underlying_transport: asyncio.Transport,
	req: ClientRequest,
	) -> None:
	"""Issue a warning if the requested URL has HTTPS scheme."""
	if req.request_info.url.scheme != "https":
	return

	asyncio_supports_tls_in_tls = getattr(
	underlying_transport,
	"_start_tls_compatible",
	False,
	)

	if asyncio_supports_tls_in_tls:
	return

	warnings.warn(
	"An HTTPS request is being sent through an HTTPS proxy. "
	"This support for TLS in TLS is known to be disabled "
	"in the stdlib asyncio (Python <3.11). This is why you'll probably see "
	"an error in the log below.\n\n"
	"It is possible to enable it via monkeypatching. "
	"For more details, see:\n"
	"* https://bugs.python.org/issue37179\n"
	"* https://github.com/python/cpython/pull/28073\n\n"
	"You can temporarily patch this as follows:\n"
	"* https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support\n"
	"* https://github.com/aio-libs/aiohttp/discussions/6044\n",
	RuntimeWarning,
	source=self,
	# Why `4`? At least 3 of the calls in the stack originate
	# from the methods in this class.
	stacklevel=3,
	)

	async def _start_tls_connection(
	self,
	underlying_transport: asyncio.Transport,
	req: ClientRequest,
	timeout: "ClientTimeout",
	client_error: Type[Exception] = ClientConnectorError,
	) -> Tuple[asyncio.BaseTransport, ResponseHandler]:
	"""Wrap the raw TCP transport with TLS."""
	tls_proto = self._factory() # Create a brand new proto for TLS
	sslcontext = self._get_ssl_context(req)
	if TYPE_CHECKING:
	# _start_tls_connection is unreachable in the current code path
	# if sslcontext is None.
	assert sslcontext is not None

	try:
	async with ceil_timeout(
	timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
	):
	try:
	tls_transport = await self._loop.start_tls(
	underlying_transport,
	tls_proto,
	sslcontext,
	server_hostname=req.server_hostname or req.host,
	ssl_handshake_timeout=timeout.total,
	)
	except BaseException:
	# We need to close the underlying transport since
	# `start_tls()` probably failed before it had a
	# chance to do this:
	underlying_transport.close()
	raise
	if isinstance(tls_transport, asyncio.Transport):
	fingerprint = self._get_fingerprint(req)
	if fingerprint:
	try:
	fingerprint.check(tls_transport)
	except ServerFingerprintMismatch:
	tls_transport.close()
	if not self._cleanup_closed_disabled:
	self._cleanup_closed_transports.append(tls_transport)
	raise
	except cert_errors as exc:
	raise ClientConnectorCertificateError(req.connection_key, exc) from exc
	except ssl_errors as exc:
	raise ClientConnectorSSLError(req.connection_key, exc) from exc
	except OSError as exc:
	if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
	raise
	raise client_error(req.connection_key, exc) from exc
	except TypeError as type_err:
	# Example cause looks like this:
	# TypeError: transport <asyncio.sslproto._SSLProtocolTransport
	# object at 0x7f760615e460> is not supported by start_tls()

	raise ClientConnectionError(
	"Cannot initialize a TLS-in-TLS connection to host "
	f"{req.host!s}:{req.port:d} through an underlying connection "
	f"to an HTTPS proxy {req.proxy!s} ssl:{req.ssl or 'default'} "
	f"[{type_err!s}]"
	) from type_err
	else:
	if tls_transport is None:
	msg = "Failed to start TLS (possibly caused by closing transport)"
	raise client_error(req.connection_key, OSError(msg))
	tls_proto.connection_made(
	tls_transport
	) # Kick the state machine of the new TLS protocol

	return tls_transport, tls_proto

	def _convert_hosts_to_addr_infos(
	self, hosts: List[ResolveResult]
	) -> List[aiohappyeyeballs.AddrInfoType]:
	"""Converts the list of hosts to a list of addr_infos.

	The list of hosts is the result of a DNS lookup. The list of
	addr_infos is the result of a call to `socket.getaddrinfo()`.
	"""
	addr_infos: List[aiohappyeyeballs.AddrInfoType] = []
	for hinfo in hosts:
	host = hinfo["host"]
	is_ipv6 = ":" in host
	family = socket.AF_INET6 if is_ipv6 else socket.AF_INET
	if self._family and self._family != family:
	continue
	addr = (host, hinfo["port"], 0, 0) if is_ipv6 else (host, hinfo["port"])
	addr_infos.append(
	(family, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", addr)
	)
	return addr_infos

	async def _create_direct_connection(
	self,
	req: ClientRequest,
	traces: List["Trace"],
	timeout: "ClientTimeout",
	*,
	client_error: Type[Exception] = ClientConnectorError,
	) -> Tuple[asyncio.Transport, ResponseHandler]:
	sslcontext = self._get_ssl_context(req)
	fingerprint = self._get_fingerprint(req)

	host = req.url.raw_host
	assert host is not None
	# Replace multiple trailing dots with a single one.
	# A trailing dot is only present for fully-qualified domain names.
	# See https://github.com/aio-libs/aiohttp/pull/7364.
	if host.endswith(".."):
	host = host.rstrip(".") + "."
	port = req.port
	assert port is not None
	try:
	# Cancelling this lookup should not cancel the underlying lookup
	# or else the cancel event will get broadcast to all the waiters
	# across all connections.
	hosts = await self._resolve_host(host, port, traces=traces)
	except OSError as exc:
	if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
	raise
	# in case of proxy it is not ClientProxyConnectionError
	# it is problem of resolving proxy ip itself
	raise ClientConnectorDNSError(req.connection_key, exc) from exc

	last_exc: Optional[Exception] = None
	addr_infos = self._convert_hosts_to_addr_infos(hosts)
	while addr_infos:
	# Strip trailing dots, certificates contain FQDN without dots.
	# See https://github.com/aio-libs/aiohttp/issues/3636
	server_hostname = (
	(req.server_hostname or host).rstrip(".") if sslcontext else None
	)

	try:
	transp, proto = await self._wrap_create_connection(
	self._factory,
	timeout=timeout,
	ssl=sslcontext,
	addr_infos=addr_infos,
	server_hostname=server_hostname,
	req=req,
	client_error=client_error,
	)
	except (ClientConnectorError, asyncio.TimeoutError) as exc:
	last_exc = exc
	aiohappyeyeballs.pop_addr_infos_interleave(addr_infos, self._interleave)
	continue

	if req.is_ssl() and fingerprint:
	try:
	fingerprint.check(transp)
	except ServerFingerprintMismatch as exc:
	transp.close()
	if not self._cleanup_closed_disabled:
	self._cleanup_closed_transports.append(transp)
	last_exc = exc
	# Remove the bad peer from the list of addr_infos
	sock: socket.socket = transp.get_extra_info("socket")
	bad_peer = sock.getpeername()
	aiohappyeyeballs.remove_addr_infos(addr_infos, bad_peer)
	continue

	return transp, proto
	else:
	assert last_exc is not None
	raise last_exc

	async def _create_proxy_connection(
	self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
	) -> Tuple[asyncio.BaseTransport, ResponseHandler]:
	self._fail_on_no_start_tls(req)
	runtime_has_start_tls = self._loop_supports_start_tls()

	headers: Dict[str, str] = {}
	if req.proxy_headers is not None:
	headers = req.proxy_headers # type: ignore[assignment]
	headers[hdrs.HOST] = req.headers[hdrs.HOST]

	url = req.proxy
	assert url is not None
	proxy_req = ClientRequest(
	hdrs.METH_GET,
	url,
	headers=headers,
	auth=req.proxy_auth,
	loop=self._loop,
	ssl=req.ssl,
	)

	# create connection to proxy server
	transport, proto = await self._create_direct_connection(
	proxy_req, [], timeout, client_error=ClientProxyConnectionError
	)

	auth = proxy_req.headers.pop(hdrs.AUTHORIZATION, None)
	if auth is not None:
	if not req.is_ssl():
	req.headers[hdrs.PROXY_AUTHORIZATION] = auth
	else:
	proxy_req.headers[hdrs.PROXY_AUTHORIZATION] = auth

	if req.is_ssl():
	if runtime_has_start_tls:
	self._warn_about_tls_in_tls(transport, req)

	# For HTTPS requests over HTTP proxy
	# we must notify proxy to tunnel connection
	# so we send CONNECT command:
	# CONNECT www.python.org:443 HTTP/1.1
	# Host: www.python.org
	#
	# next we must do TLS handshake and so on
	# to do this we must wrap raw socket into secure one
	# asyncio handles this perfectly
	proxy_req.method = hdrs.METH_CONNECT
	proxy_req.url = req.url
	key = req.connection_key._replace(
	proxy=None, proxy_auth=None, proxy_headers_hash=None
	)
	conn = Connection(self, key, proto, self._loop)
	proxy_resp = await proxy_req.send(conn)
	try:
	protocol = conn._protocol
	assert protocol is not None

	# read_until_eof=True will ensure the connection isn't closed
	# once the response is received and processed allowing
	# START_TLS to work on the connection below.
	protocol.set_response_params(
	read_until_eof=runtime_has_start_tls,
	timeout_ceil_threshold=self._timeout_ceil_threshold,
	)
	resp = await proxy_resp.start(conn)
	except BaseException:
	proxy_resp.close()
	conn.close()
	raise
	else:
	conn._protocol = None
	try:
	if resp.status != 200:
	message = resp.reason
	if message is None:
	message = HTTPStatus(resp.status).phrase
	raise ClientHttpProxyError(
	proxy_resp.request_info,
	resp.history,
	status=resp.status,
	message=message,
	headers=resp.headers,
	)
	if not runtime_has_start_tls:
	rawsock = transport.get_extra_info("socket", default=None)
	if rawsock is None:
	raise RuntimeError(
	"Transport does not expose socket instance"
	)
	# Duplicate the socket, so now we can close proxy transport
	rawsock = rawsock.dup()
	except BaseException:
	# It shouldn't be closed in `finally` because it's fed to
	# `loop.start_tls()` and the docs say not to touch it after
	# passing there.
	transport.close()
	raise
	finally:
	if not runtime_has_start_tls:
	transport.close()

	if not runtime_has_start_tls:
	# HTTP proxy with support for upgrade to HTTPS
	sslcontext = self._get_ssl_context(req)
	return await self._wrap_existing_connection(
	self._factory,
	timeout=timeout,
	ssl=sslcontext,
	sock=rawsock,
	server_hostname=req.host,
	req=req,
	)

	return await self._start_tls_connection(
	# Access the old transport for the last time before it's
	# closed and forgotten forever:
	transport,
	req=req,
	timeout=timeout,
	)
	finally:
	proxy_resp.close()

	return transport, proto


	class UnixConnector(BaseConnector):
	"""Unix socket connector.

	path - Unix socket path.
	keepalive_timeout - (optional) Keep-alive timeout.
	force_close - Set to True to force close and do reconnect
	after each request (and between redirects).
	limit - The total number of simultaneous connections.
	limit_per_host - Number of simultaneous connections to one host.
	loop - Optional event loop.
	"""

	allowed_protocol_schema_set = HIGH_LEVEL_SCHEMA_SET \| frozenset({"unix"})

	def __init__(
	self,
	path: str,
	force_close: bool = False,
	keepalive_timeout: Union[object, float, None] = sentinel,
	limit: int = 100,
	limit_per_host: int = 0,
	loop: Optional[asyncio.AbstractEventLoop] = None,
	) -> None:
	super().__init__(
	force_close=force_close,
	keepalive_timeout=keepalive_timeout,
	limit=limit,
	limit_per_host=limit_per_host,
	loop=loop,
	)
	self._path = path

	@property
	def path(self) -> str:
	"""Path to unix socket."""
	return self._path

	async def _create_connection(
	self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
	) -> ResponseHandler:
	try:
	async with ceil_timeout(
	timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
	):
	_, proto = await self._loop.create_unix_connection(
	self._factory, self._path
	)
	except OSError as exc:
	if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
	raise
	raise UnixClientConnectorError(self.path, req.connection_key, exc) from exc

	return proto


	class NamedPipeConnector(BaseConnector):
	"""Named pipe connector.

	Only supported by the proactor event loop.
	See also: https://docs.python.org/3/library/asyncio-eventloop.html

	path - Windows named pipe path.
	keepalive_timeout - (optional) Keep-alive timeout.
	force_close - Set to True to force close and do reconnect
	after each request (and between redirects).
	limit - The total number of simultaneous connections.
	limit_per_host - Number of simultaneous connections to one host.
	loop - Optional event loop.
	"""

	allowed_protocol_schema_set = HIGH_LEVEL_SCHEMA_SET \| frozenset({"npipe"})

	def __init__(
	self,
	path: str,
	force_close: bool = False,
	keepalive_timeout: Union[object, float, None] = sentinel,
	limit: int = 100,
	limit_per_host: int = 0,
	loop: Optional[asyncio.AbstractEventLoop] = None,
	) -> None:
	super().__init__(
	force_close=force_close,
	keepalive_timeout=keepalive_timeout,
	limit=limit,
	limit_per_host=limit_per_host,
	loop=loop,
	)
	if not isinstance(
	self._loop, asyncio.ProactorEventLoop # type: ignore[attr-defined]
	):
	raise RuntimeError(
	"Named Pipes only available in proactor loop under windows"
	)
	self._path = path

	@property
	def path(self) -> str:
	"""Path to the named pipe."""
	return self._path

	async def _create_connection(
	self, req: ClientRequest, traces: List["Trace"], timeout: "ClientTimeout"
	) -> ResponseHandler:
	try:
	async with ceil_timeout(
	timeout.sock_connect, ceil_threshold=timeout.ceil_threshold
	):
	_, proto = await self._loop.create_pipe_connection( # type: ignore[attr-defined]
	self._factory, self._path
	)
	# the drain is required so that the connection_made is called
	# and transport is set otherwise it is not set before the
	# `assert conn.transport is not None`
	# in client.py's _request method
	await asyncio.sleep(0)
	# other option is to manually set transport like
	# `proto.transport = trans`
	except OSError as exc:
	if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
	raise
	raise ClientConnectorError(req.connection_key, exc) from exc

	return cast(ResponseHandler, proto)