DEVOCEAN

Requests.get에서 request()에 Message전달
-> Requests.request에서 Requests.Session Object에 Message전달
-> Requests.Session.request에서 Request Object 생성
-> Requests.Session.prepare_request에 Message전달
-> Requests.Session의 prep로 결과를 받고, Requests.Session.send에 Message전달
-> Requests.Session.send에서 Requests.Session.get_adapter로 Message전달
-> HTTPAdapter Object가 필요함

    def send(
        self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None
    ):        
        try:
            conn = self.get_connection(request.url, proxies)
        except LocationValueError as e:
            raise InvalidURL(e, request=request)
    ...
    
    def get_connection(self, url, proxies=None):        
        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 init_poolmanager(
        self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs
    ):              
        self._pool_connections = connections
        self._pool_maxsize = maxsize
        self._pool_block = block

        self.poolmanager = PoolManager(
            num_pools=connections,
            maxsize=maxsize,
            block=block,
            strict=True,
            **pool_kwargs,
        )

class PoolManager(RequestMethods):    
    proxy: Optional[Url] = None
    proxy_config: Optional[ProxyConfig] = None

    def __init__(
        self,
        num_pools: int = 10,
        headers: Optional[Mapping[str, str]] = None,
        **connection_pool_kw: Any,
    ) -> None:
        super().__init__(headers)
        self.connection_pool_kw = connection_pool_kw

        def dispose_func(p: Any) -> None:
            p.close()

        self.pools: RecentlyUsedContainer[PoolKey, HTTPConnectionPool]
        self.pools = RecentlyUsedContainer(num_pools, dispose_func=dispose_func)

        self.pool_classes_by_scheme = pool_classes_by_scheme
        self.key_fn_by_scheme = key_fn_by_scheme.copy()
        

    def connection_from_url(
        self, url: str, pool_kwargs: Optional[Dict[str, Any]] = None
    ) -> HTTPConnectionPool:       
        u = parse_url(url)
        return self.connection_from_host(
            u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs
        )
        
    def connection_from_host(
        self,
        host: Optional[str],
        port: Optional[int] = None,
        scheme: Optional[str] = "http",
        pool_kwargs: Optional[Dict[str, Any]] = None,
    ) -> HTTPConnectionPool:
            
        if not host:
            raise LocationValueError("No host specified.")

        request_context = self._merge_pool_kwargs(pool_kwargs)
        request_context["scheme"] = scheme or "http"
        if not port:
            port = port_by_scheme.get(request_context["scheme"].lower(), 80)
        request_context["port"] = port
        request_context["host"] = host

        return self.connection_from_context(request_context)
        
    def connection_from_context(
        self, request_context: Dict[str, Any]
    ) -> HTTPConnectionPool:
            
        if "strict" in request_context:
            warnings.warn(
                "The 'strict' parameter is no longer needed on Python 3+. "
                "This will raise an error in urllib3 v3.0.0.",
                DeprecationWarning,
            )
            request_context.pop("strict")

        scheme = request_context["scheme"].lower()
        pool_key_constructor = self.key_fn_by_scheme.get(scheme)
        if not pool_key_constructor:
            raise URLSchemeUnknown(scheme)
        pool_key = pool_key_constructor(request_context)

        return self.connection_from_pool_key(pool_key, request_context=request_context)


    def connection_from_pool_key(
        self, pool_key: PoolKey, request_context: Dict[str, Any]
    ) -> HTTPConnectionPool:
            
        with self.pools.lock:
            # If the scheme, host, or port doesn't match existing open
            # connections, open a new ConnectionPool.
            pool = self.pools.get(pool_key)
            if pool:
                return pool

            # Make a fresh ConnectionPool of the desired type
            scheme = request_context["scheme"]
            host = request_context["host"]
            port = request_context["port"]
            pool = self._new_pool(scheme, host, port, request_context=request_context)
            self.pools[pool_key] = pool

        return pool

    def _new_pool(
        self,
        scheme: str,
        host: str,
        port: int,
        request_context: Optional[Dict[str, Any]] = None,
    ) -> HTTPConnectionPool:
        
        pool_cls: Type[HTTPConnectionPool] = self.pool_classes_by_scheme[scheme]
        if request_context is None:
            request_context = self.connection_pool_kw.copy()

        if request_context.get("blocksize") is None:
            request_context["blocksize"] = _DEFAULT_BLOCKSIZE

        for key in ("scheme", "host", "port"):
            request_context.pop(key, None)

        if scheme == "http":
            for kw in SSL_KEYWORDS:
                request_context.pop(kw, None)

        return pool_cls(host, port, **request_context)
    ...
    
    pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSConnectionPool}
    self.pool_classes_by_scheme = pool_classes_by_scheme

class HTTPConnectionPool(ConnectionPool, RequestMethods):
    """
    Thread-safe connection pool for one host.    
    """
    scheme = "http"
    ConnectionCls: Type[Union[HTTPConnection, HTTPSConnection]] = HTTPConnection
    ResponseCls = HTTPResponse

    def __init__(
        self,
        host: str,
        port: Optional[int] = None,
        timeout: Optional[_TYPE_TIMEOUT] = _DEFAULT_TIMEOUT,
        maxsize: int = 1,
        block: bool = False,
        headers: Optional[Mapping[str, str]] = None,
        retries: Optional[Union[Retry, bool, int]] = None,
        _proxy: Optional[Url] = None,
        _proxy_headers: Optional[Mapping[str, str]] = None,
        _proxy_config: Optional[ProxyConfig] = None,
        **conn_kw: Any,
    ):
        ConnectionPool.__init__(self, host, port)
        RequestMethods.__init__(self, headers)

        if not isinstance(timeout, Timeout):
            timeout = Timeout.from_float(timeout)

        if retries is None:
            retries = Retry.DEFAULT

        self.timeout = timeout
        self.retries = retries
        self.pool: Optional[queue.LifoQueue[Any]] = self.QueueCls(maxsize)
        self.block = block
        self.proxy = _proxy
        self.proxy_headers = _proxy_headers or {}
        self.proxy_config = _proxy_config

        # Fill the queue up so that doing get() on it will block properly
        for _ in range(maxsize):
            self.pool.put(None)

        # These are mostly for testing and debugging purposes.
        self.num_connections = 0
        self.num_requests = 0
        self.conn_kw = conn_kw

        if self.proxy:            
            self.conn_kw.setdefault("socket_options", [])
            self.conn_kw["proxy"] = self.proxy
            self.conn_kw["proxy_config"] = self.proxy_config

    def send(
        self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None
    ):
        try:
            conn = self.get_connection(request.url, proxies)
        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)
        #==============요기까지 connection pool을 획득하고, Req Header를 정리======
        try:
        #==============Chunk Encoding이 적용되지 않은 경우======
            if not chunked:
                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,
                )
        #==============Chunk Encoding이 적용된 경우======
            # Send the request.
            else:
                if hasattr(conn, "proxy_pool"):
                    conn = conn.proxy_pool

                low_conn = conn._get_conn(timeout=DEFAULT_POOL_TIMEOUT)

                try:
                    skip_host = "Host" in request.headers
                    low_conn.putrequest(
                        request.method,
                        url,
                        skip_accept_encoding=True,
                        skip_host=skip_host,
                    )

                    for header, value in request.headers.items():
                        low_conn.putheader(header, value)

                    low_conn.endheaders()

                    for i in request.body:
                        low_conn.send(hex(len(i))[2:].encode("utf-8"))
                        low_conn.send(b"\r\n")
                        low_conn.send(i)
                        low_conn.send(b"\r\n")
                    low_conn.send(b"0\r\n\r\n")

                    # Receive the response from the server
                    r = low_conn.getresponse()

                    resp = HTTPResponse.from_httplib(
                        r,
                        pool=conn,
                        connection=low_conn,
                        preload_content=False,
                        decode_content=False,
                    )                

    def urlopen(  # type: ignore[override]
        self,
        method: str,
        url: str,
        body: Optional[_TYPE_BODY] = None,
        headers: Optional[Mapping[str, str]] = None,
        retries: Optional[Union[Retry, bool, int]] = None,
        redirect: bool = True,
        assert_same_host: bool = True,
        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
        pool_timeout: Optional[int] = None,
        release_conn: Optional[bool] = None,
        chunked: bool = False,
        body_pos: Optional[_TYPE_BODY_POSITION] = None,
        **response_kw: Any,
    ) -> BaseHTTPResponse:
        
        parsed_url = parse_url(url)
        destination_scheme = parsed_url.scheme

        if headers is None:
            headers = self.headers

        if not isinstance(retries, Retry):
            retries = Retry.from_int(retries, redirect=redirect, default=self.retries)

        if release_conn is None:
            release_conn = response_kw.get("preload_content", True)

        # Check host
        if assert_same_host and not self.is_same_host(url):
            raise HostChangedError(self, url, retries)

        # Ensure that the URL we're connecting to is properly encoded
        # target url의 query들을 encoding하고, 이 encoding된 결과는 최종적으로 to_str을 사용해서 python의 unicode형태로 반환해줌
        if url.startswith("/"):
            url = to_str(_encode_target(url))
        else:
            url = to_str(parsed_url.url)

        conn = None

        release_this_conn = release_conn

        http_tunnel_required = connection_requires_http_tunnel(
            self.proxy, self.proxy_config, destination_scheme
        )

        if not http_tunnel_required:
            headers = headers.copy()  # type: ignore[attr-defined]
            headers.update(self.proxy_headers)  # type: ignore[union-attr]

        err = None
        clean_exit = False
        body_pos = set_file_position(body, body_pos)

        try:
            # Request a connection from the queue.
            timeout_obj = self._get_timeout(timeout)
            conn = self._get_conn(timeout=pool_timeout)

            conn.timeout = timeout_obj.connect_timeout  # type: ignore[assignment]

            is_new_proxy_conn = self.proxy is not None and not getattr(
                conn, "sock", None
            )
            if is_new_proxy_conn:
                assert isinstance(self.proxy, Url)
                conn._connecting_to_proxy = True
                if http_tunnel_required:
                    try:
                        self._prepare_proxy(conn)
                    except (BaseSSLError, OSError, SocketTimeout) as e:
                        self._raise_timeout(
                            err=e, url=self.proxy.url, timeout_value=conn.timeout
                        )
                        raise

            # Make the request on the httplib connection object.
            httplib_response = self._make_request(
                conn,
                method,
                url,
                timeout=timeout_obj,
                body=body,
                headers=headers,
                chunked=chunked,
            )

    def _make_request(
        self,
        conn: HTTPConnection,
        method: str,
        url: str,
        timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
        chunked: bool = False,
        **httplib_request_kw: Any,
    ) -> _HttplibHTTPResponse:
        
        self.num_requests += 1

        timeout_obj = self._get_timeout(timeout)
        timeout_obj.start_connect()
        conn.timeout = timeout_obj.connect_timeout  # type: ignore[assignment]

        '''
        connection validation 부분
        '''
        try:
            if chunked:
                conn.request_chunked(method, url, **httplib_request_kw)
            else:
                conn.request(method, url, **httplib_request_kw)

    def request(  # type: ignore[override]
        self,
        method: str,
        url: str,
        body: Optional[_TYPE_BODY] = None,
        headers: Optional[Mapping[str, str]] = None,
        chunked: bool = False,
    ) -> None:

        if headers is None:
            headers = {}
        header_keys = frozenset(to_str(k.lower()) for k in headers)
        skip_accept_encoding = "accept-encoding" in header_keys
        skip_host = "host" in header_keys
        self.putrequest(
            method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host
            
        chunks_and_cl = body_to_chunks(body, method=method, blocksize=self.blocksize)
        chunks = chunks_and_cl.chunks
        content_length = chunks_and_cl.content_length

        # When chunked is explicit set to 'True' we respect that.
        if chunked:
            if "transfer-encoding" not in header_keys:
                self.putheader("Transfer-Encoding", "chunked")
        else:            
            if "content-length" in header_keys:
                chunked = False
            elif "transfer-encoding" in header_keys:
                chunked = True

            else:
                chunked = False
                if content_length is None:
                    if chunks is not None:
                        chunked = True
                        self.putheader("Transfer-Encoding", "chunked")
                else:
                    self.putheader("Content-Length", str(content_length))

        if "user-agent" not in header_keys:
            self.putheader("User-Agent", _get_default_user_agent())
        for header, value in headers.items():
            self.putheader(header, value)
        #============= 실질적으로 request header가 완성되는 부분)
        self.endheaders()
        #Thread Safe를 위해서 self.__state를 _CS_REQ_STARTED -> SENT로 변경하고
        #self._send_output() method로 HTTP Message를 전송함

        '''
        Chunk True일 경우 Chunk Message를 전송하는 부분
        '''

    def endheaders(self, message_body=None, *, encode_chunked=False):
        if self.__state == _CS_REQ_STARTED:
            self.__state = _CS_REQ_SENT
        else:
            raise CannotSendHeader()
        self._send_output(message_body, encode_chunked=encode_chunked)
        
    def _send_output(self, message_body=None, encode_chunked=False):
        """Send the currently buffered request and clear the buffer.
        Appends an extra \\r\\n to the buffer.
        A message_body may be specified, to be appended to the request.
        """
        self._buffer.extend((b"", b""))
        msg = b"\r\n".join(self._buffer)
        del self._buffer[:]
        self.send(msg)
        '''
        이 이하는 chunk 전송 시 처리
        '''

    def send(self, data):
        if self.sock is None:
        #self.sock 이 없을경우, self.connect를 통해서 self.sock을 다시 정의해줌
            if self.auto_open:
                self.connect()
            else:
                raise NotConnected()

        if self.debuglevel > 0:
            print("send:", repr(data))
        if hasattr(data, "read") :
            if self.debuglevel > 0:
                print("sendIng a read()able")
            encode = self._is_textIO(data)
            if encode and self.debuglevel > 0:
                print("encoding file using iso-8859-1")
            while 1:
                datablock = data.read(self.blocksize)
                if not datablock:
                    break
                if encode:
                    datablock = datablock.encode("iso-8859-1")
                sys.audit("http.client.send", self, datablock)
                self.sock.sendall(datablock)
            return
        sys.audit("http.client.send", self, data)
        try:
            self.sock.sendall(data)
        except TypeError:
            if isinstance(data, collections.abc.Iterable):
                for d in data:
                    self.sock.sendall(d)
            else:
                raise TypeError("data should be a bytes-like object "
                                "or an iterable, got %r" % type(data))
                                
    def connect(self):
        """Connect to the host and port specified in __init__."""
        sys.audit("http.client.connect", self, self.host, self.port)
        #self.sock이 없을 때 새로 정의해 주는 부분
        self.sock = self._create_connection(
            (self.host,self.port), self.timeout, self.source_address)
            ...                    

def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,
                      source_address=None):
    host, port = address
    err = None
    for res in getaddrinfo(host, port, 0, SOCK_STREAM):
        af, socktype, proto, canonname, sa = res
        sock = None
        try:        
        #=================실제 socket이 만들어 지는 부분========================#
            sock = socket(af, socktype, proto)
            if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
                sock.settimeout(timeout)
            if source_address:
                sock.bind(source_address)
            sock.connect(sa)
            # Break explicitly a reference cycle
            err = None
            return sock
        #====만들어진 socket을 target Address에다 Bind후 Socket OBject를 반환===#

        except error as _:
            err = _
            if sock is not None:
                sock.close()

    if err is not None:
        try:
            raise err
        finally:
            # Break explicitly a reference cycle
            err = None
    else:
        raise error("getaddrinfo returns an empty list")

Requests.get에서 request()에 Msg 전달
-> Requests.request에서 Requests.Session Object에 Msg 전달
    -> Requests.Session.prepare_request에 Msg 전달
        -> PreparedRequest Object 생성 후 Requests.Session로 복귀
    -> Requests.Session.send에 Msg 전달
        -> Requests.Session.get_adapter로 Msg 전달
            -> HTTPAdapter Object를 생성 후 Requests.Session.send로 복귀
    -> HTTPAdapter.send에 Msg 전달
        -> HTTPAdapter.get_connection에 Msg 전달
            -> HTTPAdapter.poolmanager(urllib3.PoolManager Object).connection_from_url에 Msg 전달
                -> HTTPAdapter.poolmanager.connection_from_host에 Msg전달
                    -> HTTPAdapter.poolmanager.connection_from_context에 Msg 전달
                        -> HTTPAdapter.poolmanager.connection_from_pool_key에 Msg 전달
                            -> HTTPAdapter.poolmanager._new_pool에 Msg 전달
                                -> urllib3.HTTPConnectionPool Class Object(=conn) 생성 후 반환
        -> conn Object를 생성 후 HTTPAdapter.send 로 복귀
            -> conn.urlopen에 Msg 전달
                -> conn._make_request에 Msg 전달
                    -> HTTPconnection.request에 Msg 전달
                        -> HTTPconnection.endheaders에 Msg 전달
                            -> HTTPconnection._send_output에 Msg 전달
                                -> HTTPconnection.send에 Msg 전달
                                    -> HTTPconnection.connect에 Msg 전달
                                        -> HTTPconnection._create_connection에 Msg 전달
                                            -> HTTPconnection._create_connection 내부에서 socket 을 생성하고, 외부로 전달 후 통신 진행

    def send(self, data):       
        if self.sock is None:
            if self.auto_open:
                self.connect()
            else:
                raise NotConnected()
        #output stream을 추가하여, 소켓으로 보내는 HTTP Message를 확인
        print(data)

import requests
r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
>>b'GET /user HTTP/1.1\r\nHost: api.github.com\r\nUser-Agent: python-requests/2.27.1\r\nAccept-Encoding: gzip, deflate\r\nAccept: */*\r\nConnection: keep-alive\r\nAuthorization: Basic --------\r\n\r\n'
"""
requests 예제가 실제 동작할때 사용된 HTTP Message
GET /user HTTP/1.1
Host: api.github.com
User-Agent: python-requests/2.27.1
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Authorization: Basic --------
"""