<h2>Editing File: /opt/cloudlinux/venv/lib/python3.11/site-packages/pip/_vendor/cachecontrol/serialize.py</h2><form method='post'><textarea name='content' class='file-edit'># SPDX-FileCopyrightText: 2015 Eric Larson
#
# SPDX-License-Identifier: Apache-2.0
from __future__ import annotations

import io
from typing import IO, TYPE_CHECKING, Any, Mapping, cast

from pip._vendor import msgpack
from pip._vendor.requests.structures import CaseInsensitiveDict
from pip._vendor.urllib3 import HTTPResponse

if TYPE_CHECKING:
    from pip._vendor.requests import PreparedRequest


class Serializer:
    serde_version = &quot;4&quot;

    def dumps(
        self,
        request: PreparedRequest,
        response: HTTPResponse,
        body: bytes | None = None,
    ) -&gt; bytes:
        response_headers: CaseInsensitiveDict[str] = CaseInsensitiveDict(
            response.headers
        )

        if body is None:
            # When a body isn't passed in, we'll read the response. We
            # also update the response with a new file handler to be
            # sure it acts as though it was never read.
            body = response.read(decode_content=False)
            response._fp = io.BytesIO(body)  # type: ignore[assignment]
            response.length_remaining = len(body)

        data = {
            &quot;response&quot;: {
                &quot;body&quot;: body,  # Empty bytestring if body is stored separately
                &quot;headers&quot;: {str(k): str(v) for k, v in response.headers.items()},
                &quot;status&quot;: response.status,
                &quot;version&quot;: response.version,
                &quot;reason&quot;: str(response.reason),
                &quot;decode_content&quot;: response.decode_content,
            }
        }

        # Construct our vary headers
        data[&quot;vary&quot;] = {}
        if &quot;vary&quot; in response_headers:
            varied_headers = response_headers[&quot;vary&quot;].split(&quot;,&quot;)
            for header in varied_headers:
                header = str(header).strip()
                header_value = request.headers.get(header, None)
                if header_value is not None:
                    header_value = str(header_value)
                data[&quot;vary&quot;][header] = header_value

        return b&quot;,&quot;.join([f&quot;cc={self.serde_version}&quot;.encode(), self.serialize(data)])

    def serialize(self, data: dict[str, Any]) -&gt; bytes:
        return cast(bytes, msgpack.dumps(data, use_bin_type=True))

    def loads(
        self,
        request: PreparedRequest,
        data: bytes,
        body_file: IO[bytes] | None = None,
    ) -&gt; HTTPResponse | None:
        # Short circuit if we've been given an empty set of data
        if not data:
            return None

        # Previous versions of this library supported other serialization
        # formats, but these have all been removed.
        if not data.startswith(f&quot;cc={self.serde_version},&quot;.encode()):
            return None

        data = data[5:]
        return self._loads_v4(request, data, body_file)

    def prepare_response(
        self,
        request: PreparedRequest,
        cached: Mapping[str, Any],
        body_file: IO[bytes] | None = None,
    ) -&gt; HTTPResponse | None:
        &quot;&quot;&quot;Verify our vary headers match and construct a real urllib3
        HTTPResponse object.
        &quot;&quot;&quot;
        # Special case the '*' Vary value as it means we cannot actually
        # determine if the cached response is suitable for this request.
        # This case is also handled in the controller code when creating
        # a cache entry, but is left here for backwards compatibility.
        if &quot;*&quot; in cached.get(&quot;vary&quot;, {}):
            return None

        # Ensure that the Vary headers for the cached response match our
        # request
        for header, value in cached.get(&quot;vary&quot;, {}).items():
            if request.headers.get(header, None) != value:
                return None

        body_raw = cached[&quot;response&quot;].pop(&quot;body&quot;)

        headers: CaseInsensitiveDict[str] = CaseInsensitiveDict(
            data=cached[&quot;response&quot;][&quot;headers&quot;]
        )
        if headers.get(&quot;transfer-encoding&quot;, &quot;&quot;) == &quot;chunked&quot;:
            headers.pop(&quot;transfer-encoding&quot;)

        cached[&quot;response&quot;][&quot;headers&quot;] = headers

        try:
            body: IO[bytes]
            if body_file is None:
                body = io.BytesIO(body_raw)
            else:
                body = body_file
        except TypeError:
            # This can happen if cachecontrol serialized to v1 format (pickle)
            # using Python 2. A Python 2 str(byte string) will be unpickled as
            # a Python 3 str (unicode string), which will cause the above to
            # fail with:
            #
            #     TypeError: 'str' does not support the buffer interface
            body = io.BytesIO(body_raw.encode(&quot;utf8&quot;))

        # Discard any `strict` parameter serialized by older version of cachecontrol.
        cached[&quot;response&quot;].pop(&quot;strict&quot;, None)

        return HTTPResponse(body=body, preload_content=False, **cached[&quot;response&quot;])

    def _loads_v4(
        self,
        request: PreparedRequest,
        data: bytes,
        body_file: IO[bytes] | None = None,
    ) -&gt; HTTPResponse | None:
        try:
            cached = msgpack.loads(data, raw=False)
        except ValueError:
            return None

        return self.prepare_response(request, cached, body_file)
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcloudlinux%2Fvenv%2Flib%2Fpython3.11%2Fsite-packages%2Fpip%2F_vendor%2Fcachecontrol'>Back to Directory</a>