from tempfile import mkdtemp
import zipfile

from .colorlog import enable_colourful_output
from .compat import TOMLDecodeError, toml_load
from .envbuild import BuildEnvironment
from .wrappers import Pep517HookCaller

log = logging.getLogger(__name__)

            

Reported by Pylint.

              import zipfile

from .colorlog import enable_colourful_output
from .compat import TOMLDecodeError, toml_load
from .envbuild import BuildEnvironment
from .wrappers import Pep517HookCaller

log = logging.getLogger(__name__)


            

Reported by Pylint.

              
from .colorlog import enable_colourful_output
from .compat import TOMLDecodeError, toml_load
from .envbuild import BuildEnvironment
from .wrappers import Pep517HookCaller

log = logging.getLogger(__name__)



            

Reported by Pylint.

              from .colorlog import enable_colourful_output
from .compat import TOMLDecodeError, toml_load
from .envbuild import BuildEnvironment
from .wrappers import Pep517HookCaller

log = logging.getLogger(__name__)


def check_build_sdist(hooks, build_sys_requires):

            

Reported by Pylint.

                      try:
            reqs = hooks.get_requires_for_build_sdist({})
            log.info('Got build requires: %s', reqs)
        except Exception:
            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
            return False

        try:
            env.pip_install(reqs)

            

Reported by Pylint.

                          try:
                filename = hooks.build_sdist(td, {})
                log.info('build_sdist returned %r', filename)
            except Exception:
                log.info('Failure in build_sdist', exc_info=True)
                return False

            if not filename.endswith('.tar.gz'):
                log.error(

            

Reported by Pylint.

                      try:
            reqs = hooks.get_requires_for_build_wheel({})
            log.info('Got build requires: %s', reqs)
        except Exception:
            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
            return False

        try:
            env.pip_install(reqs)

            

Reported by Pylint.

                          try:
                filename = hooks.build_wheel(td, {})
                log.info('build_wheel returned %r', filename)
            except Exception:
                log.info('Failure in build_wheel', exc_info=True)
                return False

            if not filename.endswith('.whl'):
                log.error("Filename %s doesn't have .whl extension", filename)

            

Reported by Pylint.

              import os
from os.path import isfile, join as pjoin
import shutil
from subprocess import CalledProcessError
import sys
import tarfile
from tempfile import mkdtemp
import zipfile


            

Reported by Bandit.

              log = logging.getLogger(__name__)


def check_build_sdist(hooks, build_sys_requires):
    with BuildEnvironment() as env:
        try:
            env.pip_install(build_sys_requires)
            log.info('Installed static build dependencies')
        except CalledProcessError:

            

Reported by Pylint.

              import codecs
import re
from typing import (IO, Iterator, Match, NamedTuple, Optional,  # noqa:F401
                    Pattern, Sequence, Tuple)


def make_regex(string: str, extra_flags: int = 0) -> Pattern[str]:
    return re.compile(string, re.UNICODE | extra_flags)


            

Reported by Pylint.

              import codecs
import re
from typing import (IO, Iterator, Match, NamedTuple, Optional,  # noqa:F401
                    Pattern, Sequence, Tuple)


def make_regex(string: str, extra_flags: int = 0) -> Pattern[str]:
    return re.compile(string, re.UNICODE | extra_flags)


            

Reported by Pylint.

                                  Pattern, Sequence, Tuple)


def make_regex(string: str, extra_flags: int = 0) -> Pattern[str]:
    return re.compile(string, re.UNICODE | extra_flags)


_newline = make_regex(r"(\r\n|\n|\r)")
_multiline_whitespace = make_regex(r"\s*", extra_flags=re.MULTILINE)

            

Reported by Pylint.

              )


class Position:
    def __init__(self, chars: int, line: int) -> None:
        self.chars = chars
        self.line = line

    @classmethod

            

Reported by Pylint.

                      self.line = line

    @classmethod
    def start(cls) -> "Position":
        return cls(chars=0, line=1)

    def set(self, other: "Position") -> None:
        self.chars = other.chars
        self.line = other.line

            

Reported by Pylint.

                  def start(cls) -> "Position":
        return cls(chars=0, line=1)

    def set(self, other: "Position") -> None:
        self.chars = other.chars
        self.line = other.line

    def advance(self, string: str) -> None:
        self.chars += len(string)

            

Reported by Pylint.

                      self.chars = other.chars
        self.line = other.line

    def advance(self, string: str) -> None:
        self.chars += len(string)
        self.line += len(re.findall(_newline, string))


class Error(Exception):

            

Reported by Pylint.

                      self.line += len(re.findall(_newline, string))


class Error(Exception):
    pass


class Reader:
    def __init__(self, stream: IO[str]) -> None:

            

Reported by Pylint.

                  pass


class Reader:
    def __init__(self, stream: IO[str]) -> None:
        self.string = stream.read()
        self.position = Position.start()
        self.mark = Position.start()


            

Reported by Pylint.

                      self.position = Position.start()
        self.mark = Position.start()

    def has_next(self) -> bool:
        return self.position.chars < len(self.string)

    def set_mark(self) -> None:
        self.mark.set(self.position)


            

Reported by Pylint.

              from .base import DataView, DataViewMapping, DataViewSequence
from .hashes import Hash
from .packages import Package
from .scripts import Script
from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package

            

Reported by Pylint.

              from .base import DataView, DataViewMapping, DataViewSequence
from .hashes import Hash
from .packages import Package
from .scripts import Script
from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package

            

Reported by Pylint.

              from .base import DataView, DataViewMapping, DataViewSequence
from .hashes import Hash
from .packages import Package
from .scripts import Script
from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package

            

Reported by Pylint.

              from .base import DataView, DataViewMapping, DataViewSequence
from .hashes import Hash
from .packages import Package
from .scripts import Script
from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package

            

Reported by Pylint.

              from .hashes import Hash
from .packages import Package
from .scripts import Script
from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package


            

Reported by Pylint.

                      try:
            return self._data["python_version"]
        except KeyError:
            raise AttributeError("python_version")

    @property
    def python_full_version(self):
        try:
            return self._data["python_full_version"]

            

Reported by Pylint.

                      try:
            return self._data["python_full_version"]
        except KeyError:
            raise AttributeError("python_full_version")


META_SECTIONS = {
    "hash": Hash,
    "requires": Requires,

            

Reported by Pylint.

              from .base import DataView, DataViewMapping, DataViewSequence
from .hashes import Hash
from .packages import Package
from .scripts import Script
from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package

            

Reported by Pylint.

              from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package


class ScriptCollection(DataViewMapping):
    item_class = Script

            

Reported by Pylint.

              from .sources import Source


class PackageCollection(DataViewMapping):
    item_class = Package


class ScriptCollection(DataViewMapping):
    item_class = Script

            

Reported by Pylint.

              import datetime
import re

rfc3339_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')

def parse_rfc3339(v):
    m = rfc3339_re.match(v)
    if not m or m.group(0) != v:
        return None

            

Reported by Pylint.

              import datetime
import re

rfc3339_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')

def parse_rfc3339(v):
    m = rfc3339_re.match(v)
    if not m or m.group(0) != v:
        return None

            

Reported by Pylint.

              
rfc3339_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')

def parse_rfc3339(v):
    m = rfc3339_re.match(v)
    if not m or m.group(0) != v:
        return None
    return parse_rfc3339_re(m)


            

Reported by Pylint.

              
rfc3339_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')

def parse_rfc3339(v):
    m = rfc3339_re.match(v)
    if not m or m.group(0) != v:
        return None
    return parse_rfc3339_re(m)


            

Reported by Pylint.

              rfc3339_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')

def parse_rfc3339(v):
    m = rfc3339_re.match(v)
    if not m or m.group(0) != v:
        return None
    return parse_rfc3339_re(m)

def parse_rfc3339_re(m):

            

Reported by Pylint.

                      return None
    return parse_rfc3339_re(m)

def parse_rfc3339_re(m):
    r = map(int, m.groups()[:6])
    if m.group(7):
        micro = float(m.group(7))
    else:
        micro = 0

            

Reported by Pylint.

                      return None
    return parse_rfc3339_re(m)

def parse_rfc3339_re(m):
    r = map(int, m.groups()[:6])
    if m.group(7):
        micro = float(m.group(7))
    else:
        micro = 0

            

Reported by Pylint.

                  return parse_rfc3339_re(m)

def parse_rfc3339_re(m):
    r = map(int, m.groups()[:6])
    if m.group(7):
        micro = float(m.group(7))
    else:
        micro = 0


            

Reported by Pylint.

                      micro = 0

    if m.group(8):
        g = int(m.group(8), 10) * 60 + int(m.group(9), 10)
        tz = _TimeZone(datetime.timedelta(0, g * 60))
    else:
        tz = _TimeZone(datetime.timedelta(0, 0))

    y, m, d, H, M, S = r

            

Reported by Pylint.

              
    if m.group(8):
        g = int(m.group(8), 10) * 60 + int(m.group(9), 10)
        tz = _TimeZone(datetime.timedelta(0, g * 60))
    else:
        tz = _TimeZone(datetime.timedelta(0, 0))

    y, m, d, H, M, S = r
    return datetime.datetime(y, m, d, H, M, S, int(micro * 1000000), tz)

            

Reported by Pylint.

              import sys
import os

from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
from .winterm import WinTerm, WinColor, WinStyle
from .win32 import windll, winapi_test


winterm = None

            

Reported by Pylint.

              import os

from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
from .winterm import WinTerm, WinColor, WinStyle
from .win32 import windll, winapi_test


winterm = None
if windll is not None:

            

Reported by Pylint.

              
from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
from .winterm import WinTerm, WinColor, WinStyle
from .win32 import windll, winapi_test


winterm = None
if windll is not None:
    winterm = WinTerm()

            

Reported by Pylint.

              # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
import re
import sys
import os

from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
from .winterm import WinTerm, WinColor, WinStyle
from .win32 import windll, winapi_test


            

Reported by Pylint.

              from .win32 import windll, winapi_test


winterm = None
if windll is not None:
    winterm = WinTerm()


class StreamWrapper(object):

            

Reported by Pylint.

                  winterm = WinTerm()


class StreamWrapper(object):
    '''
    Wraps a stream (such as stdout), acting as a transparent proxy for all
    attribute access apart from method 'write()', which is delegated to our
    Converter instance.
    '''

            

Reported by Pylint.

                  def __exit__(self, *args, **kwargs):
        return self.__wrapped.__exit__(*args, **kwargs)

    def write(self, text):
        self.__convertor.write(text)

    def isatty(self):
        stream = self.__wrapped
        if 'PYCHARM_HOSTED' in os.environ:

            

Reported by Pylint.

                  def write(self, text):
        self.__convertor.write(text)

    def isatty(self):
        stream = self.__wrapped
        if 'PYCHARM_HOSTED' in os.environ:
            if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__):
                return True
        try:

            

Reported by Pylint.

                          return stream_isatty()

    @property
    def closed(self):
        stream = self.__wrapped
        try:
            return stream.closed
        except AttributeError:
            return True

            

Reported by Pylint.

                          return True


class AnsiToWin32(object):
    '''
    Implements a 'write()' method which, on Windows, will strip ANSI character
    sequences from the text, and if outputting to a tty, will convert them into
    win32 function calls.
    '''

            

Reported by Pylint.

              

class InvalidControlChar(ParseError):
    def __init__(self, line, col, char, type):  # type: (int, int, int, str) -> None
        display_code = "\\u00"

        if char < 16:
            display_code += "0"


            

Reported by Pylint.

              from __future__ import unicode_literals

from typing import Optional


class TOMLKitError(Exception):

    pass


            

Reported by Pylint.

              from typing import Optional


class TOMLKitError(Exception):

    pass


class ParseError(ValueError, TOMLKitError):

            

Reported by Pylint.

                      if message is None:
            message = "TOML parse error"

        super(ParseError, self).__init__(
            "{} at line {} col {}".format(message, self._line, self._col)
        )

    @property
    def line(self):

            

Reported by Pylint.

                      )

    @property
    def line(self):
        return self._line

    @property
    def col(self):
        return self._col

            

Reported by Pylint.

                      return self._line

    @property
    def col(self):
        return self._col


class MixedArrayTypesError(ParseError):
    """

            

Reported by Pylint.

                  def __init__(self, line, col):  # type: (int, int) -> None
        message = "Mixed types found in array"

        super(MixedArrayTypesError, self).__init__(line, col, message=message)


class InvalidNumberError(ParseError):
    """
    A numeric field was improperly specified.

            

Reported by Pylint.

                  def __init__(self, line, col):  # type: (int, int) -> None
        message = "Invalid number"

        super(InvalidNumberError, self).__init__(line, col, message=message)


class InvalidDateTimeError(ParseError):
    """
    A datetime field was improperly specified.

            

Reported by Pylint.

                  def __init__(self, line, col):  # type: (int, int) -> None
        message = "Invalid datetime"

        super(InvalidDateTimeError, self).__init__(line, col, message=message)


class InvalidDateError(ParseError):
    """
    A date field was improperly specified.

            

Reported by Pylint.

                  def __init__(self, line, col):  # type: (int, int) -> None
        message = "Invalid date"

        super(InvalidDateError, self).__init__(line, col, message=message)


class InvalidTimeError(ParseError):
    """
    A date field was improperly specified.

            

Reported by Pylint.

              
about = {}
with open(os.path.join(here, "..", "pipenv", "__version__.py")) as f:
    exec(f.read(), about)

# -- General configuration ------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#

            

Reported by Pylint.

              
about = {}
with open(os.path.join(here, "..", "pipenv", "__version__.py")) as f:
    exec(f.read(), about)

# -- General configuration ------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#

            

Reported by Bandit.

              
# General information about the project.
project = 'pipenv'
copyright = '2020. A project founded by <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a>'
author = 'Python Packaging Authority'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.

            

Reported by Pylint.

              #
# pipenv documentation build configuration file, created by
# sphinx-quickstart on Mon Jan 30 13:28:36 2017.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.

            

Reported by Pylint.

              # You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'

# The master toctree document.
master_doc = 'index'

# General information about the project.

            

Reported by Pylint.

              source_suffix = '.rst'

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = 'pipenv'
copyright = '2020. A project founded by <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a>'
author = 'Python Packaging Authority'

            

Reported by Pylint.

              master_doc = 'index'

# General information about the project.
project = 'pipenv'
copyright = '2020. A project founded by <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a>'
author = 'Python Packaging Authority'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the

            

Reported by Pylint.

              
# General information about the project.
project = 'pipenv'
copyright = '2020. A project founded by <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a>'
author = 'Python Packaging Authority'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.

            

Reported by Pylint.

              
# General information about the project.
project = 'pipenv'
copyright = '2020. A project founded by <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a>'
author = 'Python Packaging Authority'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.

            

Reported by Pylint.

              # General information about the project.
project = 'pipenv'
copyright = '2020. A project founded by <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a>'
author = 'Python Packaging Authority'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#

            

Reported by Pylint.

                      except KeyError:
            pass
        except Exception:
            raise AttributeError(attr)
        raise AttributeError(attr)

    def __setattr__(self, attr, value):
        if attr.startswith('_'):
            return object.__setattr__(self, attr, value)

            

Reported by Pylint.

                      with winreg.CreateKeyEx(rootkey, name, 0, winreg.KEY_WRITE | self._flags) as key:
            for k, v in info:
                if isinstance(v, PythonWrappedDict):
                    self._set_all_values(key, k, v._items(), errors)
                elif isinstance(v, dict):
                    self._set_all_values(key, k, v.items(), errors)
                elif v is None:
                    winreg.DeleteValue(key, k)
                elif isinstance(v, str):

            

Reported by Pylint.

                  def set_all_values(self, info):
        errors = []
        if isinstance(info, PythonWrappedDict):
            items = info._items()
        elif isinstance(info, dict):
            items = info.items()
        else:
            raise TypeError('info must be a dictionary')


            

Reported by Pylint.

              #-------------------------------------------------------------------------
# Copyright (c) Steve Dower
# All rights reserved.
#
# Distributed under the terms of the MIT License
#-------------------------------------------------------------------------

__all__ = ['open_source', 'REGISTRY_SOURCE_LM', 'REGISTRY_SOURCE_LM_WOW6432', 'REGISTRY_SOURCE_CU']


            

Reported by Pylint.

              
_REG_KEY_INFO = {
    REGISTRY_SOURCE_LM: (winreg.HKEY_LOCAL_MACHINE, r'Software\Python', winreg.KEY_WOW64_64KEY),
    REGISTRY_SOURCE_LM_WOW6432: (winreg.HKEY_LOCAL_MACHINE, r'Software\Python', winreg.KEY_WOW64_32KEY),
    REGISTRY_SOURCE_CU: (winreg.HKEY_CURRENT_USER, r'Software\Python', 0),
}

def get_value_from_tuple(value, vtype):
    if vtype == winreg.REG_SZ:

            

Reported by Pylint.

                  REGISTRY_SOURCE_CU: (winreg.HKEY_CURRENT_USER, r'Software\Python', 0),
}

def get_value_from_tuple(value, vtype):
    if vtype == winreg.REG_SZ:
        if '\0' in value:
            return value[:value.index('\0')]
        return value
    return None

            

Reported by Pylint.

                      return value
    return None

def join(x, y):
    return x + '\\' + y

_VALID_ATTR = re.compile('^[a-z_]+$')
_VALID_KEY = re.compile('^[A-Za-z]+$')
_KEY_TO_ATTR = re.compile('([A-Z]+[a-z]+)')

            

Reported by Pylint.

                      return value
    return None

def join(x, y):
    return x + '\\' + y

_VALID_ATTR = re.compile('^[a-z_]+$')
_VALID_KEY = re.compile('^[A-Za-z]+$')
_KEY_TO_ATTR = re.compile('([A-Z]+[a-z]+)')

            

Reported by Pylint.

                      return value
    return None

def join(x, y):
    return x + '\\' + y

_VALID_ATTR = re.compile('^[a-z_]+$')
_VALID_KEY = re.compile('^[A-Za-z]+$')
_KEY_TO_ATTR = re.compile('([A-Z]+[a-z]+)')

            

Reported by Pylint.

              _VALID_KEY = re.compile('^[A-Za-z]+$')
_KEY_TO_ATTR = re.compile('([A-Z]+[a-z]+)')

class PythonWrappedDict(object):
    @staticmethod
    def _attr_to_key(attr):
        if not attr:
            return ''
        if not _VALID_ATTR.match(attr):

            

Reported by Pylint.

              ]

logger = logging.getLogger(__name__)
operators = Specifier._operators.keys()


def is_archive_file(name):
    # type: (str) -> bool
    """Return True if `name` is a considered as an archive file."""

            

Reported by Pylint.

                                  " case, use the '-r' flag to install" + \
                    " the packages specified within it."
        except RequirementParseError:
            logger.debug("Cannot parse '%s' as requirements \
            file" % (req), exc_info=True)
    else:
        msg += " File '%s' does not exist." % (req)
    return msg


            

Reported by Pylint.

                      try:
            req = Requirement(name)
        except InvalidRequirement:
            raise InstallationError("Invalid requirement: '%s'" % name)
    else:
        req = None

    link = Link(url)


            

Reported by Pylint.

                          )
            if add_msg:
                msg += '\nHint: {}'.format(add_msg)
            raise InstallationError(msg)
    else:
        req = None

    return RequirementParts(req, link, markers, extras)


            

Reported by Pylint.

                  try:
        req = Requirement(req_string)
    except InvalidRequirement:
        raise InstallationError("Invalid requirement: '%s'" % req_string)

    domains_not_allowed = [
        PyPI.file_storage_domain,
        TestPyPI.file_storage_domain,
    ]

            

Reported by Pylint.

              
def _strip_extras(path):
    # type: (str) -> Tuple[str, Optional[str]]
    m = re.match(r'^(.+)(\[[^\]]+\])$', path)
    extras = None
    if m:
        path_no_extras = m.group(1)
        extras = m.group(2)
    else:

            

Reported by Pylint.

                  return path_no_extras, extras


def convert_extras(extras):
    # type: (Optional[str]) -> Set[str]
    if not extras:
        return set()
    return Requirement("placeholder" + extras.lower()).extras


            

Reported by Pylint.

              
    if url_no_extras.lower().startswith('file:'):
        package_name = Link(url_no_extras).egg_fragment
        if extras:
            return (
                package_name,
                url_no_extras,
                Requirement("placeholder" + extras.lower()).extras,
            )

            

Reported by Pylint.

                      msg = " It does exist."
        # Try to parse and check if it is a requirements file.
        try:
            with open(req, 'r') as fp:
                # parse first line only
                next(parse_requirements(fp.read()))
                msg += " The argument you provided " + \
                    "(%s) appears to be a" % (req) + \
                    " requirements file. If that is the" + \

            

Reported by Pylint.

                  return msg


class RequirementParts(object):
    def __init__(
            self,
            requirement,  # type: Optional[Requirement]
            link,         # type: Optional[Link]
            markers,      # type: Optional[Marker]

            

Reported by Pylint.

              from pipenv.patched.notpip._vendor import msgpack
from pipenv.patched.notpip._vendor.requests.structures import CaseInsensitiveDict

from .compat import HTTPResponse, pickle, text_type


def _b64_decode_bytes(b):
    return base64.b64decode(b.encode("ascii"))


            

Reported by Pylint.

                          #       result being a `body` argument is *always* passed
            #       into cache_response, and in turn,
            #       `Serializer.dump`.
            response._fp = io.BytesIO(body)

        # NOTE: This is all a bit weird, but it's really important that on
        #       Python 2.x these objects are unicode and not str, even when
        #       they contain only ascii. The problem here is that msgpack
        #       understands the difference between unicode and bytes and we

            

Reported by Pylint.

              
        return HTTPResponse(body=body, preload_content=False, **cached["response"])

    def _loads_v0(self, request, data):
        # The original legacy cache data. This doesn't contain enough
        # information to construct everything we need, so we'll treat this as
        # a miss.
        return


            

Reported by Pylint.

              
        return HTTPResponse(body=body, preload_content=False, **cached["response"])

    def _loads_v0(self, request, data):
        # The original legacy cache data. This doesn't contain enough
        # information to construct everything we need, so we'll treat this as
        # a miss.
        return


            

Reported by Pylint.

              
        return self.prepare_response(request, cached)

    def _loads_v3(self, request, data):
        # Due to Python 2 encoding issues, it's impossible to know for sure
        # exactly how to load v3 entries, thus we'll treat these as a miss so
        # that they get rewritten out as v4 entries.
        return


            

Reported by Pylint.

              
        return self.prepare_response(request, cached)

    def _loads_v3(self, request, data):
        # Due to Python 2 encoding issues, it's impossible to know for sure
        # exactly how to load v3 entries, thus we'll treat these as a miss so
        # that they get rewritten out as v4 entries.
        return


            

Reported by Pylint.

              import base64
import io
import json
import zlib

from pipenv.patched.notpip._vendor import msgpack
from pipenv.patched.notpip._vendor.requests.structures import CaseInsensitiveDict

from .compat import HTTPResponse, pickle, text_type

            

Reported by Pylint.

              from .compat import HTTPResponse, pickle, text_type


def _b64_decode_bytes(b):
    return base64.b64decode(b.encode("ascii"))


def _b64_decode_str(s):
    return _b64_decode_bytes(s).decode("utf8")

            

Reported by Pylint.

                  return base64.b64decode(b.encode("ascii"))


def _b64_decode_str(s):
    return _b64_decode_bytes(s).decode("utf8")


class Serializer(object):


            

Reported by Pylint.

                  return _b64_decode_bytes(s).decode("utf8")


class Serializer(object):

    def dumps(self, request, response, body=None):
        response_headers = CaseInsensitiveDict(response.headers)

        if body is None:

            

Reported by Pylint.