from configparser import SafeConfigParser, NoOptionError


from .regex import URL_REGEX, HASH_REGEX

from .dependencies import DependencyFile, Dependency
from packaging.requirements import Requirement as PackagingRequirement, InvalidRequirement
from . import filetypes
import toml

            

Reported by Pylint.

              
from .regex import URL_REGEX, HASH_REGEX

from .dependencies import DependencyFile, Dependency
from packaging.requirements import Requirement as PackagingRequirement, InvalidRequirement
from . import filetypes
import toml
from packaging.specifiers import SpecifierSet
import json

            

Reported by Pylint.

              from .regex import URL_REGEX, HASH_REGEX

from .dependencies import DependencyFile, Dependency
from packaging.requirements import Requirement as PackagingRequirement, InvalidRequirement
from . import filetypes
import toml
from packaging.specifiers import SpecifierSet
import json


            

Reported by Pylint.

              
from .dependencies import DependencyFile, Dependency
from packaging.requirements import Requirement as PackagingRequirement, InvalidRequirement
from . import filetypes
import toml
from packaging.specifiers import SpecifierSet
import json



            

Reported by Pylint.

              from packaging.requirements import Requirement as PackagingRequirement, InvalidRequirement
from . import filetypes
import toml
from packaging.specifiers import SpecifierSet
import json


# this is a backport from setuptools 26.1
def setuptools_parse_requirements_backport(strs):  # pragma: no cover

            

Reported by Pylint.

                      :return:
        """
        parser = SafeConfigParser()
        parser.readfp(StringIO(self.obj.content))
        for section in parser.sections():
            try:
                content = parser.get(section=section, option="deps")
                for n, line in enumerate(content.splitlines()):
                    if self.is_marked_line(line):

            

Reported by Pylint.

                      for section in parser.sections():
            try:
                content = parser.get(section=section, option="deps")
                for n, line in enumerate(content.splitlines()):
                    if self.is_marked_line(line):
                        continue
                    if line:
                        req = RequirementsTXTLineParser.parse(line)
                        if req:

            

Reported by Pylint.

                          if data and 'dependencies' in data and isinstance(data['dependencies'], list):
                for dep in data['dependencies']:
                    if isinstance(dep, dict) and 'pip' in dep:
                        for n, line in enumerate(dep['pip']):
                            if self.is_marked_line(line):
                                continue
                            req = RequirementsTXTLineParser.parse(line)
                            if req:
                                req.dependency_type = self.obj.file_type

            

Reported by Pylint.

                                                  section=package_type
                                )
                            )
        except (toml.TomlDecodeError, IndexError) as e:
            pass

class PipfileLockParser(Parser):

    def parse(self):

            

Reported by Pylint.

              class SetupCfgParser(Parser):
    def parse(self):
        parser = SafeConfigParser()
        parser.readfp(StringIO(self.obj.content))
        for section in parser.values():
            if section.name == 'options':
                options = 'install_requires', 'setup_requires', 'test_require'
                for name in options:
                    content = section.get(name)

            

Reported by Pylint.

              from __future__ import absolute_import, division, unicode_literals
from pipenv.patched.notpip._vendor.six import text_type

from lxml import etree
from ..treebuilders.etree import tag_regexp

from . import base

from .. import _ihatexml

            

Reported by Pylint.

              from pipenv.patched.notpip._vendor.six import text_type

from lxml import etree
from ..treebuilders.etree import tag_regexp

from . import base

from .. import _ihatexml


            

Reported by Pylint.

              from lxml import etree
from ..treebuilders.etree import tag_regexp

from . import base

from .. import _ihatexml


def ensure_str(s):

            

Reported by Pylint.

              
from . import base

from .. import _ihatexml


def ensure_str(s):
    if s is None:
        return None

            

Reported by Pylint.

              
class TreeWalker(base.NonRecursiveTreeWalker):
    def __init__(self, tree):
        # pylint:disable=redefined-variable-type
        if isinstance(tree, list):
            self.fragmentChildren = set(tree)
            tree = FragmentRoot(tree)
        else:
            self.fragmentChildren = set()

            

Reported by Pylint.

              

class FragmentRoot(Root):
    def __init__(self, children):
        self.children = [FragmentWrapper(self, child) for child in children]
        self.text = self.tail = None

    def getnext(self):
        return None

            

Reported by Pylint.

                          node, key = node
            assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key
            if key == "text":
                # XXX: we cannot use a "bool(node) and node[0] or None" construct here
                # because node[0] might evaluate to False if it has no child element
                if len(node):
                    return node[0]
                else:
                    return None

            

Reported by Pylint.

              from __future__ import absolute_import, division, unicode_literals
from pipenv.patched.notpip._vendor.six import text_type

from lxml import etree
from ..treebuilders.etree import tag_regexp

from . import base

from .. import _ihatexml

            

Reported by Pylint.

              from __future__ import absolute_import, division, unicode_literals
from pipenv.patched.notpip._vendor.six import text_type

from lxml import etree
from ..treebuilders.etree import tag_regexp

from . import base

from .. import _ihatexml

            

Reported by Bandit.

              from .. import _ihatexml


def ensure_str(s):
    if s is None:
        return None
    elif isinstance(s, text_type):
        return s
    else:

            

Reported by Pylint.

              
from typing import Tuple

from ._utils import parse_rfc3339
from .container import Container
from .items import AoT
from .items import Array
from .items import Bool
from .items import Comment

            

Reported by Pylint.

              from typing import Tuple

from ._utils import parse_rfc3339
from .container import Container
from .items import AoT
from .items import Array
from .items import Bool
from .items import Comment
from .items import Date

            

Reported by Pylint.

              
from ._utils import parse_rfc3339
from .container import Container
from .items import AoT
from .items import Array
from .items import Bool
from .items import Comment
from .items import Date
from .items import DateTime

            

Reported by Pylint.

              from ._utils import parse_rfc3339
from .container import Container
from .items import AoT
from .items import Array
from .items import Bool
from .items import Comment
from .items import Date
from .items import DateTime
from .items import Float

            

Reported by Pylint.

              from .container import Container
from .items import AoT
from .items import Array
from .items import Bool
from .items import Comment
from .items import Date
from .items import DateTime
from .items import Float
from .items import InlineTable

            

Reported by Pylint.

              from .items import AoT
from .items import Array
from .items import Bool
from .items import Comment
from .items import Date
from .items import DateTime
from .items import Float
from .items import InlineTable
from .items import Integer

            

Reported by Pylint.

              from .items import Array
from .items import Bool
from .items import Comment
from .items import Date
from .items import DateTime
from .items import Float
from .items import InlineTable
from .items import Integer
from .items import Item as _Item

            

Reported by Pylint.

              from .items import Bool
from .items import Comment
from .items import Date
from .items import DateTime
from .items import Float
from .items import InlineTable
from .items import Integer
from .items import Item as _Item
from .items import Key

            

Reported by Pylint.

              from .items import Comment
from .items import Date
from .items import DateTime
from .items import Float
from .items import InlineTable
from .items import Integer
from .items import Item as _Item
from .items import Key
from .items import String

            

Reported by Pylint.

              from .items import Date
from .items import DateTime
from .items import Float
from .items import InlineTable
from .items import Integer
from .items import Item as _Item
from .items import Key
from .items import String
from .items import Table

            

Reported by Pylint.

              
import re

import pytest

from cerberus import Validator, errors, SchemaError
from cerberus.schema import UnvalidatedSchema
from cerberus.tests import assert_schema_error


            

Reported by Pylint.

              
import pytest

from cerberus import Validator, errors, SchemaError
from cerberus.schema import UnvalidatedSchema
from cerberus.tests import assert_schema_error


def test_empty_schema():

            

Reported by Pylint.

              import pytest

from cerberus import Validator, errors, SchemaError
from cerberus.schema import UnvalidatedSchema
from cerberus.tests import assert_schema_error


def test_empty_schema():
    validator = Validator()

            

Reported by Pylint.

              
from cerberus import Validator, errors, SchemaError
from cerberus.schema import UnvalidatedSchema
from cerberus.tests import assert_schema_error


def test_empty_schema():
    validator = Validator()
    with pytest.raises(SchemaError, match=errors.SCHEMA_ERROR_MISSING):

            

Reported by Pylint.

              
def test_validated_schema_cache():
    v = Validator({'foozifix': {'coerce': int}})
    cache_size = len(v._valid_schemas)

    v = Validator({'foozifix': {'type': 'integer'}})
    cache_size += 1
    assert len(v._valid_schemas) == cache_size


            

Reported by Pylint.

              
    v = Validator({'foozifix': {'type': 'integer'}})
    cache_size += 1
    assert len(v._valid_schemas) == cache_size

    v = Validator({'foozifix': {'coerce': int}})
    assert len(v._valid_schemas) == cache_size

    max_cache_size = 163

            

Reported by Pylint.

                  assert len(v._valid_schemas) == cache_size

    v = Validator({'foozifix': {'coerce': int}})
    assert len(v._valid_schemas) == cache_size

    max_cache_size = 163
    assert cache_size <= max_cache_size, (
        "There's an unexpected high amount (%s) of cached valid "
        "definition schemas. Unless you added further tests, "

            

Reported by Pylint.

                  assert schema_copy == schema


# TODO remove with next major release
def test_deprecated_rule_names_in_valueschema():
    def check_with(field, value, error):
        pass

    schema = {

            

Reported by Pylint.

              
# TODO remove with next major release
def test_deprecated_rule_names_in_valueschema():
    def check_with(field, value, error):
        pass

    schema = {
        "field_1": {
            "type": "dict",

            

Reported by Pylint.

              
# TODO remove with next major release
def test_deprecated_rule_names_in_valueschema():
    def check_with(field, value, error):
        pass

    schema = {
        "field_1": {
            "type": "dict",

            

Reported by Pylint.

              except ImportError:
    from ordereddict import OrderedDict

from funcsigs.version import __version__

__all__ = ['BoundArguments', 'Parameter', 'Signature', 'signature']


_WrapperDescriptor = type(type.__call__)

            

Reported by Pylint.

                      return obj

    def __str__(self):
        return self._name

    def __repr__(self):
        return '<_ParameterKind: {0!r}>'.format(self._name)



            

Reported by Pylint.

                      return self._name

    def __repr__(self):
        return '<_ParameterKind: {0!r}>'.format(self._name)


_POSITIONAL_ONLY        = _ParameterKind(0, name='POSITIONAL_ONLY')
_POSITIONAL_OR_KEYWORD  = _ParameterKind(1, name='POSITIONAL_OR_KEYWORD')
_VAR_POSITIONAL         = _ParameterKind(2, name='VAR_POSITIONAL')

            

Reported by Pylint.

              
        return self._bound_arguments_cls(self, arguments)

    def bind(*args, **kwargs):
        '''Get a BoundArguments object, that maps the passed `args`
        and `kwargs` to the function's signature.  Raises `TypeError`
        if the passed arguments can not be bound.
        '''
        return args[0]._bind(args[1:], kwargs)

            

Reported by Pylint.

                      partial_keywords = obj.keywords or {}
        try:
            ba = sig.bind_partial(*partial_args, **partial_keywords)
        except TypeError as ex:
            msg = 'partial object {0!r} has incorrect arguments'.format(obj)
            raise ValueError(msg)

        for arg_name, arg_value in ba.arguments.items():
            param = new_params[arg_name]

            

Reported by Pylint.

                          ba = sig.bind_partial(*partial_args, **partial_keywords)
        except TypeError as ex:
            msg = 'partial object {0!r} has incorrect arguments'.format(obj)
            raise ValueError(msg)

        for arg_name, arg_value in ba.arguments.items():
            param = new_params[arg_name]
            if arg_name in partial_keywords:
                # We set a new default value, because the following code

            

Reported by Pylint.

                                                                   _partial_kwarg=True)

            elif (param.kind not in (_VAR_KEYWORD, _VAR_POSITIONAL) and
                            not param._partial_kwarg):
                new_params.pop(arg_name)

        return sig.replace(parameters=new_params.values())

    sig = None

            

Reported by Pylint.

                      Dict of keyword arguments values.
    '''

    def __init__(self, signature, arguments):
        self.arguments = arguments
        self._signature = signature

    @property
    def signature(self):

            

Reported by Pylint.

                      args = []
        for param_name, param in self._signature.parameters.items():
            if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
                                                    param._partial_kwarg):
                # Keyword arguments mapped by 'functools.partial'
                # (Parameter._partial_kwarg is True) are mapped
                # in 'BoundArguments.kwargs', along with VAR_KEYWORD &
                # KEYWORD_ONLY
                break

            

Reported by Pylint.

                      for param_name, param in self._signature.parameters.items():
            if not kwargs_started:
                if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
                                                param._partial_kwarg):
                    kwargs_started = True
                else:
                    if param_name not in self.arguments:
                        kwargs_started = True
                        continue

            

Reported by Pylint.

              
import os

import pytest

from pipenv.project import Project
from pipenv.utils import subprocess_run, temp_environ



            

Reported by Pylint.

              

@pytest.mark.cli
def test_directory_with_leading_dash(raw_venv, PipenvInstance):
    with temp_environ():
        with PipenvInstance(chdir=True, venv_in_project=False, name="-project-with-dash") as p:
            if "PIPENV_VENV_IN_PROJECT" in os.environ:
                del os.environ['PIPENV_VENV_IN_PROJECT']
            c = p.pipenv('run pip freeze')

            

Reported by Pylint.

              @pytest.mark.code
@pytest.mark.install
@pytest.mark.skip(reason='non deterministic')
def test_code_import_manual(PipenvInstance):
    with PipenvInstance(chdir=True) as p:
        with open('t.py', 'w') as f:
            f.write('import requests')
        p.pipenv('install -c .')
        assert 'requests' in p.pipfile['packages']

            

Reported by Pylint.

              @pytest.mark.code
@pytest.mark.install
@pytest.mark.skip(reason='non deterministic')
def test_code_import_manual(PipenvInstance):
    with PipenvInstance(chdir=True) as p:
        with open('t.py', 'w') as f:
            f.write('import requests')
        p.pipenv('install -c .')
        assert 'requests' in p.pipfile['packages']

            

Reported by Pylint.

              @pytest.mark.install
@pytest.mark.skip(reason='non deterministic')
def test_code_import_manual(PipenvInstance):
    with PipenvInstance(chdir=True) as p:
        with open('t.py', 'w') as f:
            f.write('import requests')
        p.pipenv('install -c .')
        assert 'requests' in p.pipfile['packages']


            

Reported by Pylint.

              @pytest.mark.skip(reason='non deterministic')
def test_code_import_manual(PipenvInstance):
    with PipenvInstance(chdir=True) as p:
        with open('t.py', 'w') as f:
            f.write('import requests')
        p.pipenv('install -c .')
        assert 'requests' in p.pipfile['packages']



            

Reported by Pylint.

                      with open('t.py', 'w') as f:
            f.write('import requests')
        p.pipenv('install -c .')
        assert 'requests' in p.pipfile['packages']


@pytest.mark.lock
@pytest.mark.deploy
def test_deploy_works(PipenvInstance):

            

Reported by Bandit.

              
@pytest.mark.lock
@pytest.mark.deploy
def test_deploy_works(PipenvInstance):

    with PipenvInstance(chdir=True) as p:
        with open(p.pipfile_path, 'w') as f:
            contents = """
[packages]

            

Reported by Pylint.

              
@pytest.mark.lock
@pytest.mark.deploy
def test_deploy_works(PipenvInstance):

    with PipenvInstance(chdir=True) as p:
        with open(p.pipfile_path, 'w') as f:
            contents = """
[packages]

            

Reported by Pylint.

              @pytest.mark.deploy
def test_deploy_works(PipenvInstance):

    with PipenvInstance(chdir=True) as p:
        with open(p.pipfile_path, 'w') as f:
            contents = """
[packages]
requests = "==2.19.1"
flask = "==1.1.2"

            

Reported by Pylint.

              import types
from pathlib import Path, PurePath

from . import data01
from . import zipdata01
from ..abc import ResourceReader
from ._compat import import_helper



            

Reported by Pylint.

              from pathlib import Path, PurePath

from . import data01
from . import zipdata01
from ..abc import ResourceReader
from ._compat import import_helper


from importlib.machinery import ModuleSpec

            

Reported by Pylint.

              
from . import data01
from . import zipdata01
from ..abc import ResourceReader
from ._compat import import_helper


from importlib.machinery import ModuleSpec


            

Reported by Pylint.

              from . import data01
from . import zipdata01
from ..abc import ResourceReader
from ._compat import import_helper


from importlib.machinery import ModuleSpec



            

Reported by Pylint.

                      # An absolute path is a ValueError.
        path = Path(__file__)
        full_path = path.parent / 'utf-8.file'
        with self.assertRaises(ValueError):
            self.execute(data01, full_path)

    def test_relative_path(self):
        # A reative path is a ValueError.
        with self.assertRaises(ValueError):

            

Reported by Pylint.

              
    def test_relative_path(self):
        # A reative path is a ValueError.
        with self.assertRaises(ValueError):
            self.execute(data01, '../data01/utf-8.file')

    def test_importing_module_as_side_effect(self):
        # The anchor package can already be imported.
        del sys.modules[data01.__name__]

            

Reported by Pylint.

              
    def test_non_package_by_name(self):
        # The anchor package cannot be a module.
        with self.assertRaises(TypeError):
            self.execute(__name__, 'utf-8.file')

    def test_non_package_by_package(self):
        # The anchor package cannot be a module.
        with self.assertRaises(TypeError):

            

Reported by Pylint.

              
    def test_non_package_by_package(self):
        # The anchor package cannot be a module.
        with self.assertRaises(TypeError):
            module = sys.modules['importlib_resources.tests.util']
            self.execute(module, 'utf-8.file')

    def test_missing_path(self):
        # Attempting to open or read or request the path for a

            

Reported by Pylint.

                      bytes_data = io.BytesIO(b'Hello, world!')
        package = create_package(file=bytes_data, path=FileNotFoundError())
        self.execute(package, 'utf-8.file')
        self.assertEqual(package.__loader__._path, 'utf-8.file')

    def test_extant_path(self):
        # Attempting to open or read or request the path when the
        # path does exist should still succeed. Does not assert
        # anything about the result.

            

Reported by Pylint.

                      path = __file__
        package = create_package(file=bytes_data, path=path)
        self.execute(package, 'utf-8.file')
        self.assertEqual(package.__loader__._path, 'utf-8.file')

    def test_useless_loader(self):
        package = create_package(file=FileNotFoundError(), path=FileNotFoundError())
        with self.assertRaises(FileNotFoundError):
            self.execute(package, 'utf-8.file')

            

Reported by Pylint.

                  Tuple,
)

from tomli._re import (
    RE_DATETIME,
    RE_LOCALTIME,
    RE_NUMBER,
    match_to_datetime,
    match_to_localtime,

            

Reported by Pylint.

                  except ValueError:
        new_pos = len(src)
        if error_on_eof:
            raise suffixed_err(src, new_pos, f'Expected "{expect!r}"')

    if not error_on.isdisjoint(src[pos:new_pos]):
        while src[pos] not in error_on:
            pos += 1
        raise suffixed_err(src, pos, f'Found invalid character "{src[pos]!r}"')

            

Reported by Pylint.

                  try:
        out.data.get_or_create_nest(key)
    except KeyError:
        raise suffixed_err(src, pos, "Can not overwrite a value")

    if not src.startswith("]", pos):
        raise suffixed_err(src, pos, 'Expected "]" at the end of a table declaration')
    return pos + 1, key


            

Reported by Pylint.

                  try:
        out.data.append_nest_to_list(key)
    except KeyError:
        raise suffixed_err(src, pos, "Can not overwrite a value")

    if not src.startswith("]]", pos):
        raise suffixed_err(src, pos, 'Expected "]]" at the end of an array declaration')
    return pos + 2, key


            

Reported by Pylint.

                  try:
        nest = out.data.get_or_create_nest(abs_key_parent)
    except KeyError:
        raise suffixed_err(src, pos, "Can not overwrite a value")
    if key_stem in nest:
        raise suffixed_err(src, pos, "Can not overwrite a value")
    # Mark inline table and array namespaces recursively immutable
    if isinstance(value, (dict, list)):
        out.flags.set(header + key, Flags.FROZEN, recursive=True)

            

Reported by Pylint.

                      try:
            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
        except KeyError:
            raise suffixed_err(src, pos, "Can not overwrite a value")
        if key_stem in nest:
            raise suffixed_err(src, pos, f'Duplicate inline table key "{key_stem}"')
        nest[key_stem] = value
        pos = skip_chars(src, pos, TOML_WS)
        c = src[pos : pos + 1]

            

Reported by Pylint.

                      return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
    except KeyError:
        if len(escape_id) != 2:
            raise suffixed_err(src, pos, "Unterminated string")
        raise suffixed_err(src, pos, 'Unescaped "\\" in a string')


def parse_basic_str_escape_multiline(src: str, pos: Pos) -> Tuple[Pos, str]:
    return parse_basic_str_escape(src, pos, multiline=True)

            

Reported by Pylint.

                  except KeyError:
        if len(escape_id) != 2:
            raise suffixed_err(src, pos, "Unterminated string")
        raise suffixed_err(src, pos, 'Unescaped "\\" in a string')


def parse_basic_str_escape_multiline(src: str, pos: Pos) -> Tuple[Pos, str]:
    return parse_basic_str_escape(src, pos, multiline=True)


            

Reported by Pylint.

                      try:
            char = src[pos]
        except IndexError:
            raise suffixed_err(src, pos, "Unterminated string")
        if char == '"':
            if not multiline:
                return pos + 1, result + src[start_pos:pos]
            if src.startswith('"""', pos):
                return pos + 3, result + src[start_pos:pos]

            

Reported by Pylint.

                      try:
            datetime_obj = match_to_datetime(datetime_match)
        except ValueError:
            raise suffixed_err(src, pos, "Invalid date or datetime")
        return datetime_match.end(), datetime_obj
    localtime_match = RE_LOCALTIME.match(src, pos)
    if localtime_match:
        return localtime_match.end(), match_to_localtime(localtime_match)


            

Reported by Pylint.

              import types
import zipimport

from . import DistlibException
from .util import cached_property, get_cache_base, Cache

logger = logging.getLogger(__name__)



            

Reported by Pylint.

              import zipimport

from . import DistlibException
from .util import cached_property, get_cache_base, Cache

logger = logging.getLogger(__name__)


cache = None    # created when needed

            

Reported by Pylint.

                      if hasattr(self.loader, '_files'):
            self._files = self.loader._files
        else:
            self._files = zipimport._zip_directory_cache[archive]
        self.index = sorted(self._files)

    def _adjust_path(self, path):
        return path


            

Reported by Pylint.

              
_finder_registry = {
    type(None): ResourceFinder,
    zipimport.zipimporter: ZipResourceFinder
}

try:
    # In Python 3.6, _frozen_importlib -> _frozen_importlib_external
    try:

            

Reported by Pylint.

                          base = os.path.join(get_cache_base(), str('resource-cache'))
        super(ResourceCache, self).__init__(base)

    def is_stale(self, resource, path):
        """
        Is the cache stale for the given resource?

        :param resource: The :class:`Resource` being cached.
        :param path: The path of the resource in the cache.

            

Reported by Pylint.

                          base = os.path.join(get_cache_base(), str('resource-cache'))
        super(ResourceCache, self).__init__(base)

    def is_stale(self, resource, path):
        """
        Is the cache stale for the given resource?

        :param resource: The :class:`Resource` being cached.
        :param path: The path of the resource in the cache.

            

Reported by Pylint.

              

class ResourceBase(object):
    def __init__(self, finder, name):
        self.finder = finder
        self.name = name


class Resource(ResourceBase):

            

Reported by Pylint.

              
    @cached_property
    def file_path(self):
        global cache
        if cache is None:
            cache = ResourceCache()
        return cache.get(self)

    @cached_property

            

Reported by Pylint.

                              result = ResourceContainer(self, resource_name)
            else:
                result = Resource(self, resource_name)
            result.path = path
        return result

    def get_stream(self, resource):
        return open(resource.path, 'rb')


            

Reported by Pylint.

                              result = ResourceContainer(self, resource_name)
            else:
                result = Resource(self, resource_name)
            result.path = path
        return result

    def get_stream(self, resource):
        return open(resource.path, 'rb')


            

Reported by Pylint.

              
import six
from click.utils import LazyFile
from ._compat import install_req_from_line
from six.moves import shlex_quote
from pipenv.vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
from pipenv.vendor.packaging.version import Version, InvalidVersion, parse as parse_version
from pipenv.vendor.packaging.markers import Marker, Op, Value, Variable


            

Reported by Pylint.

              from pipenv.vendor.packaging.markers import Marker, Op, Value, Variable


from ._compat import PIP_VERSION
from .click import style

UNSAFE_PACKAGES = {"setuptools", "distribute", "pip"}
COMPILE_EXCLUDE_OPTIONS = {
    "--dry-run",

            

Reported by Pylint.

              

from ._compat import PIP_VERSION
from .click import style

UNSAFE_PACKAGES = {"setuptools", "distribute", "pip"}
COMPILE_EXCLUDE_OPTIONS = {
    "--dry-run",
    "--quiet",

            

Reported by Pylint.

                  if keyval is None:
        if key is None:

            def keyval(v):
                return v

        else:

            def keyval(v):

            

Reported by Pylint.

              
        else:

            def keyval(v):
                return (key(v), v)

    if unique:
        return dict(keyval(v) for v in values)


            

Reported by Pylint.

                      - removing one-off arguments like '--upgrade'
        - removing arguments that don't change build behaviour like '--verbose'
    """
    from piptools.scripts.compile import cli

    # Map of the compile cli options (option name -> click.Option)
    compile_options = {option.name: option for option in cli.params}

    left_args = []

            

Reported by Pylint.

              from ._compat import install_req_from_line
from six.moves import shlex_quote
from pipenv.vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
from pipenv.vendor.packaging.version import Version, InvalidVersion, parse as parse_version
from pipenv.vendor.packaging.markers import Marker, Op, Value, Variable


from ._compat import PIP_VERSION
from .click import style

            

Reported by Pylint.

              from ._compat import install_req_from_line
from six.moves import shlex_quote
from pipenv.vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
from pipenv.vendor.packaging.version import Version, InvalidVersion, parse as parse_version
from pipenv.vendor.packaging.markers import Marker, Op, Value, Variable


from ._compat import PIP_VERSION
from .click import style

            

Reported by Pylint.

              from six.moves import shlex_quote
from pipenv.vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
from pipenv.vendor.packaging.version import Version, InvalidVersion, parse as parse_version
from pipenv.vendor.packaging.markers import Marker, Op, Value, Variable


from ._compat import PIP_VERSION
from .click import style


            

Reported by Pylint.

              from six.moves import shlex_quote
from pipenv.vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
from pipenv.vendor.packaging.version import Version, InvalidVersion, parse as parse_version
from pipenv.vendor.packaging.markers import Marker, Op, Value, Variable


from ._compat import PIP_VERSION
from .click import style


            

Reported by Pylint.