mirror of
https://github.com/kennethreitz/pipenv.git
synced 2026-06-05 06:46:15 +00:00
Update to py36 plus syntax
This commit is contained in:
Frost Ming
+7
-8
@@ -1,4 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# pipenv documentation build configuration file, created by
|
||||
# sphinx-quickstart on Mon Jan 30 13:28:36 2017.
|
||||
@@ -56,9 +55,9 @@ source_suffix = '.rst'
|
||||
master_doc = 'index'
|
||||
|
||||
# General information about the project.
|
||||
project = u'pipenv'
|
||||
copyright = u'2020. A project founded by <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a>'
|
||||
author = u'Python Packaging Authority'
|
||||
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
|
||||
@@ -157,8 +156,8 @@ latex_elements = {
|
||||
# (source start file, target name, title,
|
||||
# author, documentclass [howto, manual, or own class]).
|
||||
latex_documents = [
|
||||
(master_doc, 'pipenv.tex', u'pipenv Documentation',
|
||||
u'Kenneth Reitz', 'manual'),
|
||||
(master_doc, 'pipenv.tex', 'pipenv Documentation',
|
||||
'Kenneth Reitz', 'manual'),
|
||||
]
|
||||
|
||||
|
||||
@@ -167,7 +166,7 @@ latex_documents = [
|
||||
# One entry per manual page. List of tuples
|
||||
# (source start file, name, description, authors, manual section).
|
||||
man_pages = [
|
||||
(master_doc, 'pipenv', u'pipenv Documentation',
|
||||
(master_doc, 'pipenv', 'pipenv Documentation',
|
||||
[author], 1)
|
||||
]
|
||||
|
||||
@@ -178,7 +177,7 @@ man_pages = [
|
||||
# (source start file, target name, title, author,
|
||||
# dir menu entry, description, category)
|
||||
texinfo_documents = [
|
||||
(master_doc, 'pipenv', u'pipenv Documentation',
|
||||
(master_doc, 'pipenv', 'pipenv Documentation',
|
||||
author, 'pipenv', 'One line description of project.',
|
||||
'Miscellaneous'),
|
||||
]
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
# |~~\' |~~
|
||||
# |__/||~~\|--|/~\\ /
|
||||
# | ||__/|__| |\/
|
||||
|
||||
+10
-29
@@ -1,4 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
"""A compatibility module for pipenv's backports and manipulations.
|
||||
|
||||
Exposes a standard API that enables compatibility across python versions,
|
||||
@@ -7,26 +6,18 @@ operating systems, etc.
|
||||
import sys
|
||||
import warnings
|
||||
|
||||
import six
|
||||
import vistir
|
||||
|
||||
from .vendor.vistir.compat import (
|
||||
NamedTemporaryFile, Path, ResourceWarning, TemporaryDirectory
|
||||
)
|
||||
|
||||
|
||||
# Backport required for earlier versions of Python.
|
||||
if sys.version_info < (3, 3):
|
||||
from .vendor.backports.shutil_get_terminal_size import get_terminal_size
|
||||
else:
|
||||
from shutil import get_terminal_size
|
||||
|
||||
warnings.filterwarnings("ignore", category=ResourceWarning)
|
||||
|
||||
|
||||
__all__ = [
|
||||
"NamedTemporaryFile", "Path", "ResourceWarning", "TemporaryDirectory",
|
||||
"get_terminal_size", "getpreferredencoding", "DEFAULT_ENCODING", "canonical_encoding_name",
|
||||
"getpreferredencoding", "DEFAULT_ENCODING", "canonical_encoding_name",
|
||||
"force_encoding", "UNICODE_TO_ASCII_TRANSLATION_MAP", "decode_output", "fix_utf8"
|
||||
]
|
||||
|
||||
@@ -35,12 +26,7 @@ def getpreferredencoding():
|
||||
import locale
|
||||
# Borrowed from Invoke
|
||||
# (see https://github.com/pyinvoke/invoke/blob/93af29d/invoke/runners.py#L881)
|
||||
_encoding = locale.getpreferredencoding(False)
|
||||
if six.PY2 and sys.platform != "win32":
|
||||
_default_encoding = locale.getdefaultlocale()[1]
|
||||
if _default_encoding is not None:
|
||||
_encoding = _default_encoding
|
||||
return _encoding
|
||||
return locale.getpreferredencoding(False)
|
||||
|
||||
|
||||
DEFAULT_ENCODING = getpreferredencoding()
|
||||
@@ -69,7 +55,7 @@ def force_encoding():
|
||||
return DEFAULT_ENCODING, DEFAULT_ENCODING
|
||||
stdout_encoding = canonical_encoding_name(sys.stdout.encoding)
|
||||
stderr_encoding = canonical_encoding_name(sys.stderr.encoding)
|
||||
if sys.platform == "win32" and sys.version_info >= (3, 1):
|
||||
if sys.platform == "win32":
|
||||
return DEFAULT_ENCODING, DEFAULT_ENCODING
|
||||
if stdout_encoding != "utf-8" or stderr_encoding != "utf-8":
|
||||
|
||||
@@ -110,10 +96,10 @@ OUT_ENCODING, ERR_ENCODING = force_encoding()
|
||||
|
||||
|
||||
UNICODE_TO_ASCII_TRANSLATION_MAP = {
|
||||
8230: u"...",
|
||||
8211: u"-",
|
||||
10004: u"OK",
|
||||
10008: u"x",
|
||||
8230: "...",
|
||||
8211: "-",
|
||||
10004: "OK",
|
||||
10008: "x",
|
||||
}
|
||||
|
||||
|
||||
@@ -124,26 +110,21 @@ def decode_for_output(output, target=sys.stdout):
|
||||
|
||||
|
||||
def decode_output(output):
|
||||
if not isinstance(output, six.string_types):
|
||||
if not isinstance(output, str):
|
||||
return output
|
||||
try:
|
||||
output = output.encode(DEFAULT_ENCODING)
|
||||
except (AttributeError, UnicodeDecodeError, UnicodeEncodeError):
|
||||
if six.PY2:
|
||||
output = unicode.translate(vistir.misc.to_text(output), # noqa
|
||||
UNICODE_TO_ASCII_TRANSLATION_MAP)
|
||||
else:
|
||||
output = output.translate(UNICODE_TO_ASCII_TRANSLATION_MAP)
|
||||
output = output.encode(DEFAULT_ENCODING, "replace")
|
||||
return vistir.misc.to_text(output, encoding=DEFAULT_ENCODING, errors="replace")
|
||||
|
||||
|
||||
def fix_utf8(text):
|
||||
if not isinstance(text, six.string_types):
|
||||
if not isinstance(text, str):
|
||||
return text
|
||||
try:
|
||||
text = decode_output(text)
|
||||
except UnicodeDecodeError:
|
||||
if six.PY2:
|
||||
text = unicode.translate(vistir.misc.to_text(text), UNICODE_TO_ASCII_TRANSLATION_MAP) # noqa
|
||||
pass
|
||||
return text
|
||||
|
||||
@@ -1,4 +1 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
from __future__ import absolute_import
|
||||
|
||||
from .command import cli # noqa
|
||||
|
||||
+11
-14
@@ -1,6 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
@@ -81,7 +78,7 @@ def cli(
|
||||
shell = shells.detect_info()[0]
|
||||
except shells.ShellDetectionFailure:
|
||||
echo(
|
||||
"Fail to detect shell. Please provide the {0} environment "
|
||||
"Fail to detect shell. Please provide the {} environment "
|
||||
"variable.".format(crayons.normal("PIPENV_SHELL", bold=True)),
|
||||
err=True,
|
||||
)
|
||||
@@ -115,9 +112,9 @@ def cli(
|
||||
from .. import environments
|
||||
for key in environments.__dict__:
|
||||
if key.startswith("PIPENV"):
|
||||
echo(" - {0}".format(crayons.normal(key, bold=True)))
|
||||
echo(f" - {crayons.normal(key, bold=True)}")
|
||||
echo(
|
||||
"\nYou can learn more at:\n {0}".format(
|
||||
"\nYou can learn more at:\n {}".format(
|
||||
crayons.green(
|
||||
"https://pipenv.pypa.io/en/latest/advanced/#configuration-with-environment-variables"
|
||||
)
|
||||
@@ -175,7 +172,7 @@ def cli(
|
||||
loc = project.virtualenv_location
|
||||
echo(
|
||||
crayons.normal(
|
||||
u"{0} ({1})...".format(
|
||||
"{} ({})...".format(
|
||||
crayons.normal("Removing virtualenv", bold=True),
|
||||
crayons.green(loc),
|
||||
)
|
||||
@@ -413,7 +410,7 @@ def shell(
|
||||
venv_name = os.environ.get("VIRTUAL_ENV", "UNKNOWN_VIRTUAL_ENVIRONMENT")
|
||||
if not anyway:
|
||||
echo(
|
||||
"{0} {1} {2}\nNo action taken to avoid nested environments.".format(
|
||||
"{} {} {}\nNo action taken to avoid nested environments.".format(
|
||||
crayons.normal("Shell for"),
|
||||
crayons.green(venv_name, bold=True),
|
||||
crayons.normal("already activated.", bold=True),
|
||||
@@ -530,9 +527,9 @@ def check(
|
||||
@cli.command(short_help="Runs lock, then sync.", context_settings=CONTEXT_SETTINGS)
|
||||
@option("--bare", is_flag=True, default=False, help="Minimal output.")
|
||||
@option(
|
||||
"--outdated", is_flag=True, default=False, help=u"List out-of-date dependencies."
|
||||
"--outdated", is_flag=True, default=False, help="List out-of-date dependencies."
|
||||
)
|
||||
@option("--dry-run", is_flag=True, default=None, help=u"List out-of-date dependencies.")
|
||||
@option("--dry-run", is_flag=True, default=None, help="List out-of-date dependencies.")
|
||||
@install_options
|
||||
@pass_state
|
||||
@pass_context
|
||||
@@ -564,7 +561,7 @@ def update(
|
||||
editable = [p for p in state.installstate.editables if p]
|
||||
if not packages:
|
||||
echo(
|
||||
"{0} {1} {2} {3}{4}".format(
|
||||
"{} {} {} {}{}".format(
|
||||
crayons.normal("Running", bold=True),
|
||||
crayons.yellow("$ pipenv lock", bold=True),
|
||||
crayons.normal("then", bold=True),
|
||||
@@ -576,7 +573,7 @@ def update(
|
||||
for package in packages + editable:
|
||||
if package not in project.all_packages:
|
||||
echo(
|
||||
"{0}: {1} was not found in your Pipfile! Aborting."
|
||||
"{}: {} was not found in your Pipfile! Aborting."
|
||||
"".format(
|
||||
crayons.red("Warning", bold=True),
|
||||
crayons.green(package, bold=True),
|
||||
@@ -608,7 +605,7 @@ def update(
|
||||
|
||||
|
||||
@cli.command(
|
||||
short_help=u"Displays currently-installed dependency graph information.",
|
||||
short_help="Displays currently-installed dependency graph information.",
|
||||
context_settings=CONTEXT_SETTINGS
|
||||
)
|
||||
@option("--bare", is_flag=True, default=False, help="Minimal output.")
|
||||
@@ -656,7 +653,7 @@ def run_open(state, module, *args, **kwargs):
|
||||
p = os.path.dirname(c.out.strip().rstrip("cdo"))
|
||||
else:
|
||||
p = c.out.strip().rstrip("cdo")
|
||||
echo(crayons.normal("Opening {0!r} in your EDITOR.".format(p), bold=True))
|
||||
echo(crayons.normal(f"Opening {p!r} in your EDITOR.", bold=True))
|
||||
inline_activate_virtual_environment()
|
||||
edit(filename=p)
|
||||
return 0
|
||||
|
||||
+8
-11
@@ -1,6 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
from __future__ import absolute_import
|
||||
|
||||
import os
|
||||
|
||||
import click.types
|
||||
@@ -51,7 +48,7 @@ class PipenvGroup(DYMMixin, Group):
|
||||
)
|
||||
|
||||
|
||||
class State(object):
|
||||
class State:
|
||||
def __init__(self):
|
||||
self.index = None
|
||||
self.extra_index_urls = []
|
||||
@@ -68,7 +65,7 @@ class State(object):
|
||||
self.lockoptions = LockOptions()
|
||||
|
||||
|
||||
class InstallState(object):
|
||||
class InstallState:
|
||||
def __init__(self):
|
||||
self.dev = False
|
||||
self.pre = False
|
||||
@@ -84,7 +81,7 @@ class InstallState(object):
|
||||
self.editables = []
|
||||
|
||||
|
||||
class LockOptions(object):
|
||||
class LockOptions:
|
||||
def __init__(self):
|
||||
self.dev_only = False
|
||||
self.emit_requirements = False
|
||||
@@ -110,7 +107,7 @@ def extra_index_option(f):
|
||||
state.extra_index_urls.extend(list(value))
|
||||
return value
|
||||
return option("--extra-index-url", multiple=True, expose_value=False,
|
||||
help=u"URLs to the extra PyPI compatible indexes to query for package look-ups.",
|
||||
help="URLs to the extra PyPI compatible indexes to query for package look-ups.",
|
||||
callback=callback, envvar="PIP_EXTRA_INDEX_URL")(f)
|
||||
|
||||
|
||||
@@ -142,7 +139,7 @@ def skip_lock_option(f):
|
||||
state.installstate.skip_lock = value
|
||||
return value
|
||||
return option("--skip-lock", is_flag=True, default=False, expose_value=False,
|
||||
help=u"Skip locking mechanisms and use the Pipfile instead during operation.",
|
||||
help="Skip locking mechanisms and use the Pipfile instead during operation.",
|
||||
envvar="PIPENV_SKIP_LOCK", callback=callback, type=click.types.BOOL,
|
||||
show_envvar=True)(f)
|
||||
|
||||
@@ -153,7 +150,7 @@ def keep_outdated_option(f):
|
||||
state.installstate.keep_outdated = value
|
||||
return value
|
||||
return option("--keep-outdated", is_flag=True, default=False, expose_value=False,
|
||||
help=u"Keep out-dated dependencies from being updated in Pipfile.lock.",
|
||||
help="Keep out-dated dependencies from being updated in Pipfile.lock.",
|
||||
callback=callback, type=click.types.BOOL, show_envvar=True)(f)
|
||||
|
||||
|
||||
@@ -204,7 +201,7 @@ def pre_option(f):
|
||||
state = ctx.ensure_object(State)
|
||||
state.installstate.pre = value
|
||||
return value
|
||||
return option("--pre", is_flag=True, default=False, help=u"Allow pre-releases.",
|
||||
return option("--pre", is_flag=True, default=False, help="Allow pre-releases.",
|
||||
callback=callback, type=click.types.BOOL, expose_value=False)(f)
|
||||
|
||||
|
||||
@@ -371,7 +368,7 @@ def deploy_option(f):
|
||||
state.installstate.deploy = value
|
||||
return value
|
||||
return option("--deploy", is_flag=True, default=False, type=click.types.BOOL,
|
||||
help=u"Abort if the Pipfile.lock is out-of-date, or Python version is"
|
||||
help="Abort if the Pipfile.lock is out-of-date, or Python version is"
|
||||
" wrong.", callback=callback, expose_value=False)(f)
|
||||
|
||||
|
||||
|
||||
+1
-3
@@ -2,8 +2,6 @@ import itertools
|
||||
import re
|
||||
import shlex
|
||||
|
||||
import six
|
||||
|
||||
|
||||
class ScriptEmptyError(ValueError):
|
||||
pass
|
||||
@@ -28,7 +26,7 @@ class Script(object):
|
||||
|
||||
@classmethod
|
||||
def parse(cls, value):
|
||||
if isinstance(value, six.string_types):
|
||||
if isinstance(value, str):
|
||||
value = shlex.split(value)
|
||||
if not value:
|
||||
raise ScriptEmptyError(value)
|
||||
|
||||
+187
-193
File diff suppressed because it is too large
Load Diff
+34
-40
@@ -1,9 +1,5 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
|
||||
import contextlib
|
||||
import importlib
|
||||
import io
|
||||
import json
|
||||
import operator
|
||||
import os
|
||||
@@ -14,7 +10,6 @@ from sysconfig import get_paths, get_python_version
|
||||
|
||||
import itertools
|
||||
import pkg_resources
|
||||
import six
|
||||
|
||||
import pipenv
|
||||
|
||||
@@ -37,7 +32,7 @@ BASE_WORKING_SET = pkg_resources.WorkingSet(sys.path)
|
||||
# TODO: Unittests for this class
|
||||
|
||||
|
||||
class Environment(object):
|
||||
class Environment:
|
||||
def __init__(
|
||||
self,
|
||||
prefix=None, # type: Optional[str]
|
||||
@@ -48,7 +43,7 @@ class Environment(object):
|
||||
sources=None, # type: Optional[List[TSource]]
|
||||
project=None # type: Optional[Project]
|
||||
):
|
||||
super(Environment, self).__init__()
|
||||
super().__init__()
|
||||
self._modules = {'pkg_resources': pkg_resources, 'pipenv': pipenv}
|
||||
self.base_working_set = base_working_set if base_working_set else BASE_WORKING_SET
|
||||
prefix = normalize_path(prefix)
|
||||
@@ -89,8 +84,8 @@ class Environment(object):
|
||||
module = importlib.import_module(name)
|
||||
if name in sys.modules:
|
||||
try:
|
||||
six.moves.reload_module(module)
|
||||
six.moves.reload_module(sys.modules[name])
|
||||
importlib.reload(module)
|
||||
importlib.reload(sys.modules[name])
|
||||
except TypeError:
|
||||
del sys.modules[name]
|
||||
sys.modules[name] = self._modules[name]
|
||||
@@ -115,7 +110,7 @@ class Environment(object):
|
||||
try:
|
||||
reqs = dist.requires()
|
||||
# KeyError = limited metadata can be found
|
||||
except (KeyError, AttributeError, OSError, IOError): # The METADATA file can't be found
|
||||
except (KeyError, AttributeError, OSError): # The METADATA file can't be found
|
||||
return deps
|
||||
for req in reqs:
|
||||
try:
|
||||
@@ -336,20 +331,20 @@ class Environment(object):
|
||||
sysconfig_line = "sysconfig.get_path('{0}')"
|
||||
if python_lib:
|
||||
for key, var, val in (("pure", "lib", "0"), ("plat", "lib", "1")):
|
||||
dist_prefix = "{0}lib".format(key)
|
||||
dist_prefix = f"{key}lib"
|
||||
# XXX: We need to get 'stdlib' or 'platstdlib'
|
||||
sys_prefix = "{0}stdlib".format("" if key == "pure" else key)
|
||||
pylib_lines.append("u'%s': u'{{0}}'.format(%s)" % (dist_prefix, distutils_line.format(var, val)))
|
||||
pylib_lines.append("u'%s': u'{{0}}'.format(%s)" % (sys_prefix, sysconfig_line.format(sys_prefix)))
|
||||
sys_prefix = "{}stdlib".format("" if key == "pure" else key)
|
||||
pylib_lines.append(f"u'{dist_prefix}': u'{{{{0}}}}'.format({distutils_line.format(var, val)})")
|
||||
pylib_lines.append(f"u'{sys_prefix}': u'{{{{0}}}}'.format({sysconfig_line.format(sys_prefix)})")
|
||||
if python_inc:
|
||||
for key, var, val in (("include", "inc", "0"), ("platinclude", "inc", "1")):
|
||||
pylib_lines.append("u'%s': u'{{0}}'.format(%s)" % (key, distutils_line.format(var, val)))
|
||||
pylib_lines.append(f"u'{key}': u'{{{{0}}}}'.format({distutils_line.format(var, val)})")
|
||||
lines = pylib_lines + pyinc_lines
|
||||
if scripts:
|
||||
lines.append("u'scripts': u'{{0}}'.format(%s)" % sysconfig_line.format("scripts"))
|
||||
if py_version:
|
||||
lines.append("u'py_version_short': u'{{0}}'.format(distutils.sysconfig.get_python_version()),")
|
||||
lines_as_str = u",".join(lines)
|
||||
lines_as_str = ",".join(lines)
|
||||
py_command = py_command % lines_as_str
|
||||
return py_command
|
||||
|
||||
@@ -371,7 +366,7 @@ class Environment(object):
|
||||
)
|
||||
if c.returncode == 0:
|
||||
paths = {}
|
||||
with io.open(tmpfile_path, "r", encoding="utf-8") as fh:
|
||||
with open(tmpfile_path, "r", encoding="utf-8") as fh:
|
||||
paths = json.load(fh)
|
||||
if "purelib" in paths:
|
||||
paths["libdir"] = paths["purelib"] = make_posix(paths["purelib"])
|
||||
@@ -380,8 +375,8 @@ class Environment(object):
|
||||
paths[key] = make_posix(paths[key])
|
||||
return paths
|
||||
else:
|
||||
vistir.misc.echo("Failed to load paths: {0}".format(c.err), fg="yellow")
|
||||
vistir.misc.echo("Output: {0}".format(c.out), fg="yellow")
|
||||
vistir.misc.echo(f"Failed to load paths: {c.err}", fg="yellow")
|
||||
vistir.misc.echo(f"Output: {c.out}", fg="yellow")
|
||||
return None
|
||||
|
||||
def get_lib_paths(self):
|
||||
@@ -402,7 +397,7 @@ class Environment(object):
|
||||
paths = None
|
||||
if c.returncode == 0:
|
||||
paths = {}
|
||||
with io.open(tmpfile_path, "r", encoding="utf-8") as fh:
|
||||
with open(tmpfile_path, "r", encoding="utf-8") as fh:
|
||||
paths = json.load(fh)
|
||||
if "purelib" in paths:
|
||||
paths["libdir"] = paths["purelib"] = make_posix(paths["purelib"])
|
||||
@@ -411,8 +406,8 @@ class Environment(object):
|
||||
paths[key] = make_posix(paths[key])
|
||||
return paths
|
||||
else:
|
||||
vistir.misc.echo("Failed to load paths: {0}".format(c.err), fg="yellow")
|
||||
vistir.misc.echo("Output: {0}".format(c.out), fg="yellow")
|
||||
vistir.misc.echo(f"Failed to load paths: {c.err}", fg="yellow")
|
||||
vistir.misc.echo(f"Output: {c.out}", fg="yellow")
|
||||
if not paths:
|
||||
if not self.prefix.joinpath("lib").exists():
|
||||
return {}
|
||||
@@ -455,15 +450,15 @@ class Environment(object):
|
||||
)
|
||||
if c.returncode == 0:
|
||||
paths = []
|
||||
with io.open(tmpfile_path, "r", encoding="utf-8") as fh:
|
||||
with open(tmpfile_path, "r", encoding="utf-8") as fh:
|
||||
paths = json.load(fh)
|
||||
for key in ("include", "platinclude"):
|
||||
if key in paths:
|
||||
paths[key] = make_posix(paths[key])
|
||||
return paths
|
||||
else:
|
||||
vistir.misc.echo("Failed to load paths: {0}".format(c.err), fg="yellow")
|
||||
vistir.misc.echo("Output: {0}".format(c.out), fg="yellow")
|
||||
vistir.misc.echo(f"Failed to load paths: {c.err}", fg="yellow")
|
||||
vistir.misc.echo(f"Output: {c.out}", fg="yellow")
|
||||
return None
|
||||
|
||||
@cached_property
|
||||
@@ -558,14 +553,13 @@ class Environment(object):
|
||||
pkg_resources = self.safe_import("pkg_resources")
|
||||
libdirs = self.base_paths["libdirs"].split(os.pathsep)
|
||||
dists = (pkg_resources.find_distributions(libdir) for libdir in libdirs)
|
||||
for dist in itertools.chain.from_iterable(dists):
|
||||
yield dist
|
||||
yield from itertools.chain.from_iterable(dists)
|
||||
|
||||
def find_egg(self, egg_dist):
|
||||
# type: (pkg_resources.Distribution) -> str
|
||||
"""Find an egg by name in the given environment"""
|
||||
site_packages = self.libdir[1]
|
||||
search_filename = "{0}.egg-link".format(egg_dist.project_name)
|
||||
search_filename = f"{egg_dist.project_name}.egg-link"
|
||||
try:
|
||||
user_site = site.getusersitepackages()
|
||||
except AttributeError:
|
||||
@@ -704,12 +698,12 @@ class Environment(object):
|
||||
packages = [p for p in packages if p.key == pkg]
|
||||
|
||||
tree = PackageDAG.from_pkgs(packages).sort()
|
||||
branch_keys = set(r.key for r in flatten(tree.values()))
|
||||
branch_keys = {r.key for r in flatten(tree.values())}
|
||||
if pkg is not None:
|
||||
nodes = [p for p in tree.keys() if p.key == pkg]
|
||||
else:
|
||||
nodes = [p for p in tree.keys() if p.key not in branch_keys]
|
||||
key_tree = dict((k.key, v) for k, v in tree.items())
|
||||
key_tree = {k.key: v for k, v in tree.items()}
|
||||
|
||||
return [self._get_requirements_for_package(p, key_tree) for p in nodes]
|
||||
|
||||
@@ -751,9 +745,9 @@ class Environment(object):
|
||||
for k in list(rdeps.keys()):
|
||||
entry = rdeps[k]
|
||||
if entry.get("parents"):
|
||||
rdeps[k]["parents"] = set([
|
||||
rdeps[k]["parents"] = {
|
||||
p for p, version in chunked(2, unnest(entry["parents"]))
|
||||
])
|
||||
}
|
||||
return rdeps
|
||||
|
||||
def get_working_set(self):
|
||||
@@ -832,8 +826,8 @@ class Environment(object):
|
||||
"""
|
||||
|
||||
c = None
|
||||
if isinstance(cmd, six.string_types):
|
||||
script = vistir.cmdparse.Script.parse("{0} -c {1}".format(self.python, cmd))
|
||||
if isinstance(cmd, str):
|
||||
script = vistir.cmdparse.Script.parse(f"{self.python} -c {cmd}")
|
||||
else:
|
||||
script = vistir.cmdparse.Script.parse([self.python, "-c"] + list(cmd))
|
||||
with self.activated():
|
||||
@@ -845,8 +839,8 @@ class Environment(object):
|
||||
if self.is_venv:
|
||||
activate_this = os.path.join(self.scripts_dir, "activate_this.py")
|
||||
if not os.path.isfile(activate_this):
|
||||
raise OSError("No such file: {0!s}".format(activate_this))
|
||||
with open(activate_this, "r") as f:
|
||||
raise OSError(f"No such file: {activate_this!s}")
|
||||
with open(activate_this) as f:
|
||||
code = compile(f.read(), activate_this, "exec")
|
||||
exec(code, dict(__file__=activate_this))
|
||||
|
||||
@@ -919,7 +913,7 @@ class Environment(object):
|
||||
finally:
|
||||
sys.path = original_path
|
||||
sys.prefix = original_prefix
|
||||
six.moves.reload_module(pkg_resources)
|
||||
importlib.reload(pkg_resources)
|
||||
|
||||
@cached_property
|
||||
def finders(self):
|
||||
@@ -950,11 +944,11 @@ class Environment(object):
|
||||
install_args = [
|
||||
self.environment.python, "-u", "-c", SETUPTOOLS_SHIM % setup_path,
|
||||
install_arg, "--single-version-externally-managed", "--no-deps",
|
||||
"--prefix={0}".format(self.base_paths["prefix"]), "--no-warn-script-location"
|
||||
"--prefix={}".format(self.base_paths["prefix"]), "--no-warn-script-location"
|
||||
]
|
||||
for key in install_keys:
|
||||
install_args.append(
|
||||
"--install-{0}={1}".format(key, self.base_paths[key])
|
||||
f"--install-{key}={self.base_paths[key]}"
|
||||
)
|
||||
return install_args
|
||||
|
||||
@@ -1030,7 +1024,7 @@ class Environment(object):
|
||||
return
|
||||
|
||||
|
||||
class PatchedUninstaller(object):
|
||||
class PatchedUninstaller:
|
||||
def _permitted(self, path):
|
||||
return True
|
||||
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
@@ -30,7 +28,7 @@ def env_to_bool(val):
|
||||
return False
|
||||
if val.lower() in _true_values:
|
||||
return True
|
||||
raise ValueError("Value is not a valid boolean-like: {0}".format(val))
|
||||
raise ValueError(f"Value is not a valid boolean-like: {val}")
|
||||
|
||||
|
||||
def _is_env_truthy(name):
|
||||
@@ -55,11 +53,11 @@ def get_from_env(arg, prefix="PIPENV", check_for_negation=True):
|
||||
:return: The value from the environment if available
|
||||
:rtype: Optional[Union[str, bool]]
|
||||
"""
|
||||
negative_lookup = "NO_{0}".format(arg)
|
||||
negative_lookup = f"NO_{arg}"
|
||||
positive_lookup = arg
|
||||
if prefix:
|
||||
positive_lookup = "{0}_{1}".format(prefix, arg)
|
||||
negative_lookup = "{0}_{1}".format(prefix, negative_lookup)
|
||||
positive_lookup = f"{prefix}_{arg}"
|
||||
negative_lookup = f"{prefix}_{negative_lookup}"
|
||||
if positive_lookup in os.environ:
|
||||
value = os.environ[positive_lookup]
|
||||
try:
|
||||
@@ -391,9 +389,9 @@ def is_in_virtualenv():
|
||||
return virtual_env and not (pipenv_active or ignore_virtualenvs)
|
||||
|
||||
|
||||
PIPENV_SPINNER_FAIL_TEXT = fix_utf8(u"✘ {0}") if not PIPENV_HIDE_EMOJIS else ("{0}")
|
||||
PIPENV_SPINNER_FAIL_TEXT = fix_utf8("✘ {0}") if not PIPENV_HIDE_EMOJIS else ("{0}")
|
||||
|
||||
PIPENV_SPINNER_OK_TEXT = fix_utf8(u"✔ {0}") if not PIPENV_HIDE_EMOJIS else ("{0}")
|
||||
PIPENV_SPINNER_OK_TEXT = fix_utf8("✔ {0}") if not PIPENV_HIDE_EMOJIS else ("{0}")
|
||||
|
||||
|
||||
def is_type_checking():
|
||||
|
||||
+47
-51
@@ -1,5 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
|
||||
import itertools
|
||||
import re
|
||||
import sys
|
||||
@@ -7,8 +5,6 @@ import sys
|
||||
from collections import namedtuple
|
||||
from traceback import format_tb
|
||||
|
||||
import six
|
||||
|
||||
from . import environments
|
||||
from ._compat import decode_for_output
|
||||
from .patched import crayons
|
||||
@@ -19,7 +15,7 @@ from .vendor.vistir.misc import echo as click_echo
|
||||
import vistir
|
||||
|
||||
ANSI_REMOVAL_RE = re.compile(r"\033\[((?:\d|;)*)([a-zA-Z])", re.MULTILINE)
|
||||
STRING_TYPES = (six.string_types, crayons.ColoredString)
|
||||
STRING_TYPES = ((str,), crayons.ColoredString)
|
||||
|
||||
if sys.version_info[:2] >= (3, 7):
|
||||
KnownException = namedtuple(
|
||||
@@ -52,10 +48,10 @@ def handle_exception(exc_type, exception, traceback, hook=sys.excepthook):
|
||||
for line in lines:
|
||||
line = line.strip("'").strip('"').strip("\n").strip()
|
||||
if not line.startswith("File"):
|
||||
line = " {0}".format(line)
|
||||
line = f" {line}"
|
||||
else:
|
||||
line = " {0}".format(line)
|
||||
line = "[{0!s}]: {1}".format(
|
||||
line = f" {line}"
|
||||
line = "[{!s}]: {}".format(
|
||||
exception.__class__.__name__, line
|
||||
)
|
||||
formatted_lines.append(line)
|
||||
@@ -86,12 +82,12 @@ class PipenvException(ClickException):
|
||||
if isinstance(self.extra, STRING_TYPES):
|
||||
self.extra = [self.extra]
|
||||
for extra in self.extra:
|
||||
extra = "[pipenv.exceptions.{0!s}]: {1}".format(
|
||||
extra = "[pipenv.exceptions.{!s}]: {}".format(
|
||||
self.__class__.__name__, extra
|
||||
)
|
||||
extra = decode_for_output(extra, file)
|
||||
click_echo(extra, file=file)
|
||||
click_echo(decode_for_output("{0}".format(self.message), file), file=file)
|
||||
click_echo(decode_for_output(f"{self.message}", file), file=file)
|
||||
|
||||
|
||||
class PipenvCmdError(PipenvException):
|
||||
@@ -100,23 +96,23 @@ class PipenvCmdError(PipenvException):
|
||||
self.out = out
|
||||
self.err = err
|
||||
self.exit_code = exit_code
|
||||
message = "Error running command: {0}".format(cmd)
|
||||
message = f"Error running command: {cmd}"
|
||||
PipenvException.__init__(self, message)
|
||||
|
||||
def show(self, file=None):
|
||||
if file is None:
|
||||
file = vistir.misc.get_text_stderr()
|
||||
click_echo("{0} {1}".format(
|
||||
click_echo("{} {}".format(
|
||||
crayons.red("Error running command: "),
|
||||
crayons.normal(decode_for_output("$ {0}".format(self.cmd), file), bold=True)
|
||||
crayons.normal(decode_for_output(f"$ {self.cmd}", file), bold=True)
|
||||
), err=True)
|
||||
if self.out:
|
||||
click_echo("{0} {1}".format(
|
||||
click_echo("{} {}".format(
|
||||
crayons.normal("OUTPUT: "),
|
||||
decode_for_output(self.out, file)
|
||||
), err=True)
|
||||
if self.err:
|
||||
click_echo("{0} {1}".format(
|
||||
click_echo("{} {}".format(
|
||||
crayons.normal("STDERR: "),
|
||||
decode_for_output(self.err, file)
|
||||
), err=True)
|
||||
@@ -130,13 +126,13 @@ class JSONParseError(PipenvException):
|
||||
def show(self, file=None):
|
||||
if file is None:
|
||||
file = vistir.misc.get_text_stderr()
|
||||
message = "{0}\n{1}".format(
|
||||
message = "{}\n{}".format(
|
||||
crayons.normal("Failed parsing JSON results:", bold=True),
|
||||
decode_for_output(self.message.strip(), file)
|
||||
)
|
||||
click_echo(message, err=True)
|
||||
if self.error_text:
|
||||
click_echo("{0} {1}".format(
|
||||
click_echo("{} {}".format(
|
||||
crayons.normal("ERROR TEXT:", bold=True),
|
||||
decode_for_output(self.error_text, file)
|
||||
), err=True)
|
||||
@@ -187,7 +183,7 @@ class PipenvFileError(FileError):
|
||||
if not message:
|
||||
message = crayons.normal("Please ensure that the file exists!", bold=True)
|
||||
message = self.formatted_message.format(
|
||||
crayons.normal("{0} not found!".format(filename), bold=True),
|
||||
crayons.normal(f"{filename} not found!", bold=True),
|
||||
message
|
||||
)
|
||||
FileError.__init__(self, filename=filename, hint=decode_for_output(message), **kwargs)
|
||||
@@ -208,7 +204,7 @@ class PipfileNotFound(PipenvFileError):
|
||||
def __init__(self, filename="Pipfile", extra=None, **kwargs):
|
||||
extra = kwargs.pop("extra", [])
|
||||
message = (
|
||||
"{0} {1}".format(
|
||||
"{} {}".format(
|
||||
crayons.red("Aborting!", bold=True),
|
||||
crayons.normal(
|
||||
"Please ensure that the file exists and is located in your"
|
||||
@@ -216,18 +212,18 @@ class PipfileNotFound(PipenvFileError):
|
||||
)
|
||||
)
|
||||
)
|
||||
super(PipfileNotFound, self).__init__(filename, message=message, extra=extra, **kwargs)
|
||||
super().__init__(filename, message=message, extra=extra, **kwargs)
|
||||
|
||||
|
||||
class LockfileNotFound(PipenvFileError):
|
||||
def __init__(self, filename="Pipfile.lock", extra=None, **kwargs):
|
||||
extra = kwargs.pop("extra", [])
|
||||
message = "{0} {1} {2}".format(
|
||||
message = "{} {} {}".format(
|
||||
crayons.normal("You need to run", bold=True),
|
||||
crayons.red("$ pipenv lock", bold=True),
|
||||
crayons.normal("before you can continue.", bold=True)
|
||||
)
|
||||
super(LockfileNotFound, self).__init__(filename, message=message, extra=extra, **kwargs)
|
||||
super().__init__(filename, message=message, extra=extra, **kwargs)
|
||||
|
||||
|
||||
class DeployException(PipenvUsageError):
|
||||
@@ -250,16 +246,16 @@ class SystemUsageError(PipenvOptionsError):
|
||||
def __init__(self, option_name="system", message=None, ctx=None, **kwargs):
|
||||
extra = kwargs.pop("extra", [])
|
||||
extra += [
|
||||
"{0}: --system is intended to be used for Pipfile installation, "
|
||||
"{}: --system is intended to be used for Pipfile installation, "
|
||||
"not installation of specific packages. Aborting.".format(
|
||||
crayons.red("Warning", bold=True)
|
||||
),
|
||||
]
|
||||
if message is None:
|
||||
message = str(
|
||||
crayons.cyan("See also: {0}".format(crayons.normal("--deploy flag.")))
|
||||
crayons.cyan("See also: {}".format(crayons.normal("--deploy flag.")))
|
||||
)
|
||||
super(SystemUsageError, self).__init__(option_name, message=message, ctx=ctx, extra=extra, **kwargs)
|
||||
super().__init__(option_name, message=message, ctx=ctx, extra=extra, **kwargs)
|
||||
|
||||
|
||||
class PipfileException(PipenvFileError):
|
||||
@@ -267,7 +263,7 @@ class PipfileException(PipenvFileError):
|
||||
from .core import project
|
||||
|
||||
if not hint:
|
||||
hint = "{0} {1}".format(crayons.red("ERROR (PACKAGE NOT INSTALLED):"), hint)
|
||||
hint = "{} {}".format(crayons.red("ERROR (PACKAGE NOT INSTALLED):"), hint)
|
||||
filename = project.pipfile_location
|
||||
extra = kwargs.pop("extra", [])
|
||||
PipenvFileError.__init__(self, filename, hint, extra=extra, **kwargs)
|
||||
@@ -310,7 +306,7 @@ class VirtualenvCreationException(VirtualenvException):
|
||||
# note we need the format interpolation because ``crayons.ColoredString``
|
||||
# is not an actual string type but is only a preparation for interpolation
|
||||
# so replacement or parsing requires this step
|
||||
extra = ANSI_REMOVAL_RE.sub("", "{0}".format(extra))
|
||||
extra = ANSI_REMOVAL_RE.sub("", f"{extra}")
|
||||
if "KeyboardInterrupt" in extra:
|
||||
extra = str(
|
||||
crayons.red("Virtualenv creation interrupted by user", bold=True)
|
||||
@@ -322,17 +318,17 @@ class VirtualenvCreationException(VirtualenvException):
|
||||
class UninstallError(PipenvException):
|
||||
def __init__(self, package, command, return_values, return_code, **kwargs):
|
||||
extra = [
|
||||
"{0} {1}".format(
|
||||
"{} {}".format(
|
||||
crayons.cyan("Attempted to run command: "),
|
||||
crayons.yellow("$ {0!r}".format(command), bold=True)
|
||||
crayons.yellow(f"$ {command!r}", bold=True)
|
||||
)
|
||||
]
|
||||
extra.extend([crayons.cyan(line.strip()) for line in return_values.splitlines()])
|
||||
if isinstance(package, (tuple, list, set)):
|
||||
package = " ".join(package)
|
||||
message = "{0!s} {1!s}...".format(
|
||||
message = "{!s} {!s}...".format(
|
||||
crayons.normal("Failed to uninstall package(s)"),
|
||||
crayons.yellow("{0}!s".format(package), bold=True)
|
||||
crayons.yellow(f"{package}!s", bold=True)
|
||||
)
|
||||
self.exit_code = return_code
|
||||
PipenvException.__init__(self, message=message, extra=extra)
|
||||
@@ -343,11 +339,11 @@ class InstallError(PipenvException):
|
||||
def __init__(self, package, **kwargs):
|
||||
package_message = ""
|
||||
if package is not None:
|
||||
package_message = "Couldn't install package: {0}\n".format(
|
||||
crayons.normal("{0!s}".format(package), bold=True)
|
||||
package_message = "Couldn't install package: {}\n".format(
|
||||
crayons.normal(f"{package!s}", bold=True)
|
||||
)
|
||||
message = "{0} {1}".format(
|
||||
"{0}".format(package_message),
|
||||
message = "{} {}".format(
|
||||
f"{package_message}",
|
||||
crayons.yellow("Package installation failed...")
|
||||
)
|
||||
extra = kwargs.pop("extra", [])
|
||||
@@ -356,9 +352,9 @@ class InstallError(PipenvException):
|
||||
|
||||
class CacheError(PipenvException):
|
||||
def __init__(self, path, **kwargs):
|
||||
message = "{0} {1}\n{2}".format(
|
||||
message = "{} {}\n{}".format(
|
||||
crayons.cyan("Corrupt cache file"),
|
||||
crayons.normal("{0!s}".format(path)),
|
||||
crayons.normal(f"{path!s}"),
|
||||
crayons.normal('Consider trying "pipenv lock --clear" to clear the cache.')
|
||||
)
|
||||
PipenvException.__init__(self, message=message)
|
||||
@@ -366,7 +362,7 @@ class CacheError(PipenvException):
|
||||
|
||||
class DependencyConflict(PipenvException):
|
||||
def __init__(self, message):
|
||||
extra = ["{0} {1}".format(
|
||||
extra = ["{} {}".format(
|
||||
crayons.red("The operation failed...", bold=True),
|
||||
crayons.red("A dependency conflict was detected and could not be resolved."),
|
||||
)]
|
||||
@@ -376,12 +372,12 @@ class DependencyConflict(PipenvException):
|
||||
class ResolutionFailure(PipenvException):
|
||||
def __init__(self, message, no_version_found=False):
|
||||
extra = (
|
||||
"{0}: Your dependencies could not be resolved. You likely have a "
|
||||
"{}: Your dependencies could not be resolved. You likely have a "
|
||||
"mismatch in your sub-dependencies.\n "
|
||||
"First try clearing your dependency cache with {1}, then try the original command again.\n "
|
||||
"Alternatively, you can use {2} to bypass this mechanism, then run "
|
||||
"{3} to inspect the situation.\n "
|
||||
"Hint: try {4} if it is a pre-release dependency."
|
||||
"First try clearing your dependency cache with {}, then try the original command again.\n "
|
||||
"Alternatively, you can use {} to bypass this mechanism, then run "
|
||||
"{} to inspect the situation.\n "
|
||||
"Hint: try {} if it is a pre-release dependency."
|
||||
"".format(
|
||||
crayons.red("Warning", bold=True),
|
||||
crayons.yellow("$ pipenv lock --clear"),
|
||||
@@ -392,9 +388,9 @@ class ResolutionFailure(PipenvException):
|
||||
)
|
||||
if "no version found at all" in message:
|
||||
no_version_found = True
|
||||
message = crayons.yellow("{0}".format(message))
|
||||
message = crayons.yellow(f"{message}")
|
||||
if no_version_found:
|
||||
message = "{0}\n{1}".format(
|
||||
message = "{}\n{}".format(
|
||||
message,
|
||||
crayons.cyan(
|
||||
"Please check your version specifier and version number. "
|
||||
@@ -426,18 +422,18 @@ class RequirementError(PipenvException):
|
||||
if getattr(req, k, None)
|
||||
]
|
||||
req_value = "\n".join([
|
||||
" {0}: {1}".format(k, v) for k, v in slot_vals
|
||||
f" {k}: {v}" for k, v in slot_vals
|
||||
])
|
||||
elif keys_fn:
|
||||
values = [(k, req.get(k)) for k in keys_fn() if req.get(k)]
|
||||
req_value = "\n".join([
|
||||
" {0}: {1}".format(k, v) for k, v in values
|
||||
f" {k}: {v}" for k, v in values
|
||||
])
|
||||
else:
|
||||
req_value = getattr(req.line_instance, "line", None)
|
||||
message = "{0} {1}".format(
|
||||
message = "{} {}".format(
|
||||
crayons.normal(decode_for_output("Failed creating requirement instance")),
|
||||
crayons.normal(decode_for_output("{0!r}".format(req_value)))
|
||||
crayons.normal(decode_for_output(f"{req_value!r}"))
|
||||
)
|
||||
extra = [str(req)]
|
||||
PipenvException.__init__(self, message, extra=extra)
|
||||
@@ -460,8 +456,8 @@ def prettify_exc(error):
|
||||
_, error, info = error.rpartition(exc.prefix)
|
||||
else:
|
||||
_, error, info = error.rpartition(split_string)
|
||||
errors.append("{0} {1}".format(error, info))
|
||||
errors.append(f"{error} {info}")
|
||||
if not errors:
|
||||
return "{}".format(vistir.misc.decode_for_output(error))
|
||||
return f"{vistir.misc.decode_for_output(error)}"
|
||||
|
||||
return "\n".join(errors)
|
||||
|
||||
+13
-14
@@ -1,4 +1,3 @@
|
||||
# coding: utf-8
|
||||
import os
|
||||
import pprint
|
||||
import sys
|
||||
@@ -20,11 +19,11 @@ def print_utf(line):
|
||||
def get_pipenv_diagnostics():
|
||||
print("<details><summary>$ pipenv --support</summary>")
|
||||
print("")
|
||||
print("Pipenv version: `{0!r}`".format(pipenv.__version__))
|
||||
print(f"Pipenv version: `{pipenv.__version__!r}`")
|
||||
print("")
|
||||
print("Pipenv location: `{0!r}`".format(os.path.dirname(pipenv.__file__)))
|
||||
print(f"Pipenv location: `{os.path.dirname(pipenv.__file__)!r}`")
|
||||
print("")
|
||||
print("Python location: `{0!r}`".format(sys.executable))
|
||||
print(f"Python location: `{sys.executable!r}`")
|
||||
print("")
|
||||
print("Python installations found:")
|
||||
print("")
|
||||
@@ -32,7 +31,7 @@ def get_pipenv_diagnostics():
|
||||
finder = pythonfinder.Finder(system=False, global_search=True)
|
||||
python_paths = finder.find_all_python_versions()
|
||||
for python in python_paths:
|
||||
print(" - `{}`: `{}`".format(python.py_version.version, python.path))
|
||||
print(f" - `{python.py_version.version}`: `{python.path}`")
|
||||
|
||||
print("")
|
||||
print("PEP 508 Information:")
|
||||
@@ -44,39 +43,39 @@ def get_pipenv_diagnostics():
|
||||
print("System environment variables:")
|
||||
print("")
|
||||
for key in os.environ:
|
||||
print(" - `{0}`".format(key))
|
||||
print(f" - `{key}`")
|
||||
print("")
|
||||
print_utf(u"Pipenv–specific environment variables:")
|
||||
print_utf("Pipenv–specific environment variables:")
|
||||
print("")
|
||||
for key in os.environ:
|
||||
if key.startswith("PIPENV"):
|
||||
print(" - `{0}`: `{1}`".format(key, os.environ[key]))
|
||||
print(f" - `{key}`: `{os.environ[key]}`")
|
||||
print("")
|
||||
print_utf(u"Debug–specific environment variables:")
|
||||
print_utf("Debug–specific environment variables:")
|
||||
print("")
|
||||
for key in ("PATH", "SHELL", "EDITOR", "LANG", "PWD", "VIRTUAL_ENV"):
|
||||
if key in os.environ:
|
||||
print(" - `{0}`: `{1}`".format(key, os.environ[key]))
|
||||
print(f" - `{key}`: `{os.environ[key]}`")
|
||||
print("")
|
||||
print("")
|
||||
print("---------------------------")
|
||||
print("")
|
||||
if project.pipfile_exists:
|
||||
print_utf(u"Contents of `Pipfile` ({0!r}):".format(project.pipfile_location))
|
||||
print_utf(f"Contents of `Pipfile` ({project.pipfile_location!r}):")
|
||||
print("")
|
||||
print("```toml")
|
||||
with open(project.pipfile_location, "r") as f:
|
||||
with open(project.pipfile_location) as f:
|
||||
print(f.read())
|
||||
print("```")
|
||||
print("")
|
||||
if project.lockfile_exists:
|
||||
print("")
|
||||
print_utf(
|
||||
u"Contents of `Pipfile.lock` ({0!r}):".format(project.lockfile_location)
|
||||
f"Contents of `Pipfile.lock` ({project.lockfile_location!r}):"
|
||||
)
|
||||
print("")
|
||||
print("```json")
|
||||
with open(project.lockfile_location, "r") as f:
|
||||
with open(project.lockfile_location) as f:
|
||||
print(f.read())
|
||||
print("```")
|
||||
print("</details>")
|
||||
|
||||
+9
-11
@@ -1,7 +1,6 @@
|
||||
import os
|
||||
import operator
|
||||
import re
|
||||
import six
|
||||
from abc import ABCMeta, abstractmethod
|
||||
|
||||
|
||||
@@ -11,7 +10,7 @@ from .utils import find_windows_executable
|
||||
|
||||
|
||||
@attr.s
|
||||
class Version(object):
|
||||
class Version:
|
||||
|
||||
major = attr.ib()
|
||||
minor = attr.ib()
|
||||
@@ -29,7 +28,7 @@ class Version(object):
|
||||
"""
|
||||
match = re.match(r'^(\d+)\.(\d+)(?:\.(\d+))?$', name)
|
||||
if not match:
|
||||
raise ValueError('invalid version name {0!r}'.format(name))
|
||||
raise ValueError(f'invalid version name {name!r}')
|
||||
major = int(match.group(1))
|
||||
minor = int(match.group(2))
|
||||
patch = match.group(3)
|
||||
@@ -59,17 +58,16 @@ class InstallerNotFound(RuntimeError):
|
||||
|
||||
class InstallerError(RuntimeError):
|
||||
def __init__(self, desc, c):
|
||||
super(InstallerError, self).__init__(desc)
|
||||
super().__init__(desc)
|
||||
self.out = c.out
|
||||
self.err = c.err
|
||||
|
||||
|
||||
@six.add_metaclass(ABCMeta)
|
||||
class Installer(object):
|
||||
class Installer(metaclass=ABCMeta):
|
||||
|
||||
def __init__(self):
|
||||
self.cmd = self._find_installer()
|
||||
super(Installer, self).__init__()
|
||||
super().__init__()
|
||||
|
||||
def __str__(self):
|
||||
return self.__class__.__name__
|
||||
@@ -109,7 +107,7 @@ class Installer(object):
|
||||
# Check for explicitly set install locations (e.g. PYENV_ROOT, ASDF_DIR).
|
||||
os.path.join(os.path.expanduser(os.getenv(env_var, '/dev/null')), 'bin', name),
|
||||
# Check the pyenv/asdf-recommended from-source install locations
|
||||
os.path.join(os.path.expanduser('~/.{}'.format(name)), 'bin', name),
|
||||
os.path.join(os.path.expanduser(f'~/.{name}'), 'bin', name),
|
||||
):
|
||||
if candidate is not None and os.path.isfile(candidate) and os.access(candidate, os.X_OK):
|
||||
return candidate
|
||||
@@ -119,12 +117,12 @@ class Installer(object):
|
||||
timeout = kwargs.pop('timeout', delegator.TIMEOUT)
|
||||
if kwargs:
|
||||
k = list(kwargs.keys())[0]
|
||||
raise TypeError('unexpected keyword argument {0!r}'.format(k))
|
||||
raise TypeError(f'unexpected keyword argument {k!r}')
|
||||
args = (self.cmd,) + tuple(args)
|
||||
c = delegator.run(args, block=False, timeout=timeout)
|
||||
c.block()
|
||||
if c.return_code != 0:
|
||||
raise InstallerError('failed to run {0}'.format(args), c)
|
||||
raise InstallerError(f'failed to run {args}', c)
|
||||
return c
|
||||
|
||||
@abstractmethod
|
||||
@@ -149,7 +147,7 @@ class Installer(object):
|
||||
), key=operator.attrgetter('cmpkey'))
|
||||
except ValueError:
|
||||
raise ValueError(
|
||||
'no installable version found for {0!r}'.format(name),
|
||||
f'no installable version found for {name!r}',
|
||||
)
|
||||
return best_match
|
||||
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
import json
|
||||
import os
|
||||
import platform
|
||||
|
||||
+2
-4
@@ -1,4 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
clint.textui.progress
|
||||
~~~~~~~~~~~~~~~~~
|
||||
@@ -7,7 +6,6 @@ This module provides the progressbar functionality.
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import absolute_import
|
||||
|
||||
import os
|
||||
import sys
|
||||
@@ -37,7 +35,7 @@ else:
|
||||
BAR_EMPTY_CHAR = str(crayons.black("▉"))
|
||||
|
||||
if (sys.version_info[0] >= 3) and (os.name != "nt"):
|
||||
BAR_TEMPLATE = u" %s%s%s %i/%i — {0}\r".format(crayons.black("%s"))
|
||||
BAR_TEMPLATE = " %s%s%s %i/%i — {}\r".format(crayons.black("%s"))
|
||||
else:
|
||||
if os.name == "nt":
|
||||
BAR_TEMPLATE = " %s%s%s %i/%i - %s\r"
|
||||
@@ -51,7 +49,7 @@ ETA_INTERVAL = 1
|
||||
ETA_SMA_WINDOW = 9
|
||||
|
||||
|
||||
class Bar(object):
|
||||
class Bar:
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
|
||||
+6
-6
@@ -9,8 +9,8 @@ import operator
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import urllib.parse
|
||||
|
||||
import six
|
||||
import toml
|
||||
import tomlkit
|
||||
import vistir
|
||||
@@ -89,13 +89,13 @@ class _LockFileEncoder(json.JSONEncoder):
|
||||
|
||||
def encode(self, obj):
|
||||
content = super(_LockFileEncoder, self).encode(obj)
|
||||
if not isinstance(content, six.text_type):
|
||||
if not isinstance(content, str):
|
||||
content = content.decode("utf-8")
|
||||
return content
|
||||
|
||||
|
||||
def preferred_newlines(f):
|
||||
if isinstance(f.newlines, six.text_type):
|
||||
if isinstance(f.newlines, str):
|
||||
return f.newlines
|
||||
return DEFAULT_NEWLINES
|
||||
|
||||
@@ -568,7 +568,7 @@ class Project(object):
|
||||
_pipfile_cache.clear()
|
||||
|
||||
def _parse_pipfile(self, contents):
|
||||
# type: () -> Union[tomlkit.toml_document.TOMLDocument, TPipfile]
|
||||
# type: (str) -> Union[tomlkit.toml_document.TOMLDocument, TPipfile]
|
||||
try:
|
||||
return tomlkit.parse(contents)
|
||||
except Exception:
|
||||
@@ -614,7 +614,7 @@ class Project(object):
|
||||
return False
|
||||
|
||||
def build_script(self, name, extra_args=None):
|
||||
# type: (str, Optional[List[str]])
|
||||
# type: (str, Optional[List[str]]) -> Script
|
||||
try:
|
||||
script = Script.parse(self.parsed_pipfile["scripts"][name])
|
||||
except KeyError:
|
||||
@@ -1011,7 +1011,7 @@ class Project(object):
|
||||
self.write_toml(p)
|
||||
|
||||
def src_name_from_url(self, index_url):
|
||||
name, _, tld_guess = six.moves.urllib.parse.urlsplit(index_url).netloc.rpartition(
|
||||
name, _, tld_guess = urllib.parse.urlsplit(index_url).netloc.rpartition(
|
||||
"."
|
||||
)
|
||||
src_name = name.replace(".", "")
|
||||
|
||||
+22
-26
@@ -1,6 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
from __future__ import absolute_import, print_function
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
@@ -20,12 +17,12 @@ def find_site_path(pkg, site_dir=None):
|
||||
base_name = dist.project_name if dist.project_name else dist.key
|
||||
name = None
|
||||
if "top_level.txt" in dist.metadata_listdir(""):
|
||||
name = next(iter([l.strip() for l in dist.get_metadata_lines("top_level.txt") if l is not None]), None)
|
||||
name = next(iter([line.strip() for line in dist.get_metadata_lines("top_level.txt") if line is not None]), None)
|
||||
if name is None:
|
||||
name = pkg_resources.safe_name(base_name).replace("-", "_")
|
||||
if not any(pkg == _ for _ in [base_name, name]):
|
||||
continue
|
||||
path_options = [name, "{0}.py".format(name)]
|
||||
path_options = [name, f"{name}.py"]
|
||||
path_options = [os.path.join(root, p) for p in path_options if p is not None]
|
||||
path = next(iter(p for p in path_options if os.path.exists(p)), None)
|
||||
if path is not None:
|
||||
@@ -92,11 +89,11 @@ def handle_parsed_args(parsed):
|
||||
return parsed
|
||||
|
||||
|
||||
class Entry(object):
|
||||
class Entry:
|
||||
"""A resolved entry from a resolver run"""
|
||||
|
||||
def __init__(self, name, entry_dict, project, resolver, reverse_deps=None, dev=False):
|
||||
super(Entry, self).__init__()
|
||||
super().__init__()
|
||||
from pipenv.vendor.requirementslib.models.utils import tomlkit_value_to_python
|
||||
self.name = name
|
||||
if isinstance(entry_dict, dict):
|
||||
@@ -173,7 +170,7 @@ class Entry(object):
|
||||
markers = set()
|
||||
keys_in_dict = [k for k in marker_keys if k in entry_dict]
|
||||
markers = {
|
||||
normalize_marker_str("{k} {v}".format(k=k, v=entry_dict.pop(k)))
|
||||
normalize_marker_str(f"{k} {entry_dict.pop(k)}")
|
||||
for k in keys_in_dict
|
||||
}
|
||||
if "markers" in entry_dict:
|
||||
@@ -216,18 +213,17 @@ class Entry(object):
|
||||
from pipenv.vendor.requirementslib.models.markers import normalize_marker_str
|
||||
if not marker:
|
||||
return None
|
||||
from pipenv.vendor import six
|
||||
from pipenv.vendor.vistir.compat import Mapping
|
||||
marker_str = None
|
||||
if isinstance(marker, Mapping):
|
||||
marker_dict, _ = Entry.get_markers_from_dict(marker)
|
||||
if marker_dict:
|
||||
marker_str = "{0}".format(marker_dict.popitem()[1])
|
||||
marker_str = f"{marker_dict.popitem()[1]}"
|
||||
elif isinstance(marker, (list, set, tuple)):
|
||||
marker_str = " and ".join([normalize_marker_str(m) for m in marker if m])
|
||||
elif isinstance(marker, six.string_types):
|
||||
marker_str = "{0}".format(normalize_marker_str(marker))
|
||||
if isinstance(marker_str, six.string_types):
|
||||
elif isinstance(marker, str):
|
||||
marker_str = f"{normalize_marker_str(marker)}"
|
||||
if isinstance(marker_str, str):
|
||||
return marker_str
|
||||
return None
|
||||
|
||||
@@ -317,9 +313,9 @@ class Entry(object):
|
||||
if not any(specifier.startswith(k) for k in Specifier._operators.keys()):
|
||||
if specifier.strip().lower() in ["any", "<any>", "*"]:
|
||||
return "*"
|
||||
specifier = "=={0}".format(specifier)
|
||||
specifier = f"=={specifier}"
|
||||
elif specifier.startswith("==") and specifier.count("=") > 3:
|
||||
specifier = "=={0}".format(specifier.lstrip("="))
|
||||
specifier = "=={}".format(specifier.lstrip("="))
|
||||
return specifier
|
||||
|
||||
@staticmethod
|
||||
@@ -448,7 +444,7 @@ class Entry(object):
|
||||
self.can_use_updated = False
|
||||
satisfied_by_value = getattr(constraint, "satisfied_by", None)
|
||||
if satisfied_by_value:
|
||||
satisfied_by = "{0}".format(
|
||||
satisfied_by = "{}".format(
|
||||
self.clean_specifier(str(satisfied_by_value.version))
|
||||
)
|
||||
satisfied_by_versions.add(satisfied_by)
|
||||
@@ -525,9 +521,9 @@ class Entry(object):
|
||||
str(pinned_version), prereleases=True
|
||||
):
|
||||
if is_verbose():
|
||||
print("Tried constraint: {0!r}".format(constraint), file=sys.stderr)
|
||||
print(f"Tried constraint: {constraint!r}", file=sys.stderr)
|
||||
msg = (
|
||||
"Cannot resolve conflicting version {0}{1} while {2}{3} is "
|
||||
"Cannot resolve conflicting version {}{} while {}{} is "
|
||||
"locked.".format(
|
||||
self.name, constraint.req.specifier,
|
||||
self.name, self.updated_specifier
|
||||
@@ -543,8 +539,8 @@ class Entry(object):
|
||||
if not parent.validate_specifiers():
|
||||
from pipenv.exceptions import DependencyConflict
|
||||
msg = (
|
||||
"Cannot resolve conflicting versions: (Root: {0}) {1}{2} (Pipfile) "
|
||||
"Incompatible with {3}{4} (resolved)\n".format(
|
||||
"Cannot resolve conflicting versions: (Root: {}) {}{} (Pipfile) "
|
||||
"Incompatible with {}{} (resolved)\n".format(
|
||||
self.name, parent.pipfile_name,
|
||||
parent.pipfile_entry.requirement.specifiers, parent.name,
|
||||
parent.updated_specifiers
|
||||
@@ -565,7 +561,7 @@ class Entry(object):
|
||||
except AttributeError:
|
||||
result = getattr(entry, key)
|
||||
except AttributeError:
|
||||
result = super(Entry, self).__getattribute__(key)
|
||||
result = super().__getattribute__(key)
|
||||
return result
|
||||
if any(key.startswith(v) for v in old_version):
|
||||
lockfile_entry = Entry.__getattribute__(self, "lockfile_entry")
|
||||
@@ -576,9 +572,9 @@ class Entry(object):
|
||||
except AttributeError:
|
||||
result = getattr(lockfile_entry, key)
|
||||
except AttributeError:
|
||||
result = super(Entry, self).__getattribute__(key)
|
||||
result = super().__getattribute__(key)
|
||||
return result
|
||||
return super(Entry, self).__getattribute__(key)
|
||||
return super().__getattribute__(key)
|
||||
|
||||
|
||||
def clean_results(results, resolver, project, dev=False):
|
||||
@@ -751,9 +747,9 @@ def main():
|
||||
warnings.simplefilter("ignore", category=ResourceWarning)
|
||||
replace_with_text_stream("stdout")
|
||||
replace_with_text_stream("stderr")
|
||||
os.environ["PIP_DISABLE_PIP_VERSION_CHECK"] = str("1")
|
||||
os.environ["PYTHONIOENCODING"] = str("utf-8")
|
||||
os.environ["PYTHONUNBUFFERED"] = str("1")
|
||||
os.environ["PIP_DISABLE_PIP_VERSION_CHECK"] = "1"
|
||||
os.environ["PYTHONIOENCODING"] = "utf-8"
|
||||
os.environ["PYTHONUNBUFFERED"] = "1"
|
||||
parsed = handle_parsed_args(parsed)
|
||||
_main(parsed.pre, parsed.clear, parsed.verbose, parsed.system, parsed.write,
|
||||
parsed.requirements_dir, parsed.packages, parse_only=parsed.parse_only,
|
||||
|
||||
+13
-13
@@ -52,7 +52,7 @@ def _get_activate_script(cmd, venv):
|
||||
# for proper activation.
|
||||
venv_location = re.sub(r'([ &$()\[\]])', r"\\\1", str(venv))
|
||||
# The leading space can make history cleaner in some shells.
|
||||
return " {2} {0}/bin/activate{1}".format(venv_location, suffix, command)
|
||||
return f" {command} {venv_location}/bin/activate{suffix}"
|
||||
|
||||
|
||||
def _handover(cmd, args):
|
||||
@@ -63,7 +63,7 @@ def _handover(cmd, args):
|
||||
sys.exit(subprocess.call(args, shell=True, universal_newlines=True))
|
||||
|
||||
|
||||
class Shell(object):
|
||||
class Shell:
|
||||
def __init__(self, cmd):
|
||||
self.cmd = cmd
|
||||
self.args = []
|
||||
@@ -77,7 +77,7 @@ class Shell(object):
|
||||
@contextlib.contextmanager
|
||||
def inject_path(self, venv):
|
||||
with temp_environ():
|
||||
os.environ["PATH"] = "{0}{1}{2}".format(
|
||||
os.environ["PATH"] = "{}{}{}".format(
|
||||
os.pathsep.join(str(p.parent) for p in _iter_python(venv)),
|
||||
os.pathsep,
|
||||
os.environ["PATH"],
|
||||
@@ -90,9 +90,9 @@ class Shell(object):
|
||||
name = os.path.basename(venv)
|
||||
os.environ["VIRTUAL_ENV"] = str(venv)
|
||||
if "PROMPT" in os.environ:
|
||||
os.environ["PROMPT"] = "({0}) {1}".format(name, os.environ["PROMPT"])
|
||||
os.environ["PROMPT"] = "({}) {}".format(name, os.environ["PROMPT"])
|
||||
if "PS1" in os.environ:
|
||||
os.environ["PS1"] = "({0}) {1}".format(name, os.environ["PS1"])
|
||||
os.environ["PS1"] = "({}) {}".format(name, os.environ["PS1"])
|
||||
with self.inject_path(venv):
|
||||
os.chdir(cwd)
|
||||
_handover(self.cmd, self.args + list(args))
|
||||
@@ -147,10 +147,10 @@ class Bash(Shell):
|
||||
bashrc_path = Path.home().joinpath(".bashrc")
|
||||
with NamedTemporaryFile("w+") as rcfile:
|
||||
if bashrc_path.is_file():
|
||||
base_rc_src = 'source "{0}"\n'.format(bashrc_path.as_posix())
|
||||
base_rc_src = f'source "{bashrc_path.as_posix()}"\n'
|
||||
rcfile.write(base_rc_src)
|
||||
|
||||
export_path = 'export PATH="{0}:$PATH"\n'.format(":".join(
|
||||
export_path = 'export PATH="{}:$PATH"\n'.format(":".join(
|
||||
self._format_path(python)
|
||||
for python in _iter_python(venv)
|
||||
))
|
||||
@@ -162,18 +162,18 @@ class Bash(Shell):
|
||||
|
||||
class MsysBash(Bash):
|
||||
def _format_path(self, python):
|
||||
s = super(MsysBash, self)._format_path(python)
|
||||
s = super()._format_path(python)
|
||||
if not python.drive:
|
||||
return s
|
||||
# Convert "C:/something" to "/c/something".
|
||||
return '/{drive}{path}'.format(drive=s[0].lower(), path=s[2:])
|
||||
return f'/{s[0].lower()}{s[2:]}'
|
||||
|
||||
|
||||
class CmderEmulatedShell(Shell):
|
||||
def fork(self, venv, cwd, args):
|
||||
if cwd:
|
||||
os.environ["CMDER_START"] = cwd
|
||||
super(CmderEmulatedShell, self).fork(venv, cwd, args)
|
||||
super().fork(venv, cwd, args)
|
||||
|
||||
|
||||
class CmderCommandPrompt(CmderEmulatedShell):
|
||||
@@ -181,7 +181,7 @@ class CmderCommandPrompt(CmderEmulatedShell):
|
||||
rc = os.path.expandvars("%CMDER_ROOT%\\vendor\\init.bat")
|
||||
if os.path.exists(rc):
|
||||
self.args.extend(["/k", rc])
|
||||
super(CmderCommandPrompt, self).fork(venv, cwd, args)
|
||||
super().fork(venv, cwd, args)
|
||||
|
||||
|
||||
class CmderPowershell(Shell):
|
||||
@@ -196,10 +196,10 @@ class CmderPowershell(Shell):
|
||||
"-NoProfile",
|
||||
"-NoExit",
|
||||
"-Command",
|
||||
"Invoke-Expression '. ''{0}'''".format(rc),
|
||||
f"Invoke-Expression '. ''{rc}'''",
|
||||
]
|
||||
)
|
||||
super(CmderPowershell, self).fork(venv, cwd, args)
|
||||
super().fork(venv, cwd, args)
|
||||
|
||||
|
||||
# Two dimensional dict. First is the shell type, second is the emulator type.
|
||||
|
||||
+69
-74
@@ -1,6 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import print_function
|
||||
|
||||
import contextlib
|
||||
import errno
|
||||
import logging
|
||||
@@ -14,11 +11,10 @@ import sys
|
||||
import warnings
|
||||
from contextlib import contextmanager
|
||||
from distutils.spawn import find_executable
|
||||
from urllib.parse import urlparse
|
||||
|
||||
import six
|
||||
import toml
|
||||
from click import echo as click_echo
|
||||
from six.moves.urllib.parse import urlparse
|
||||
|
||||
import crayons
|
||||
import parse
|
||||
@@ -137,7 +133,7 @@ def run_command(cmd, *args, **kwargs):
|
||||
from ._compat import decode_for_output
|
||||
from .cmdparse import Script
|
||||
catch_exceptions = kwargs.pop("catch_exceptions", True)
|
||||
if isinstance(cmd, (six.string_types, list, tuple)):
|
||||
if isinstance(cmd, ((str,), list, tuple)):
|
||||
cmd = Script.parse(cmd)
|
||||
if not isinstance(cmd, Script):
|
||||
raise TypeError("Command input must be a string, list or tuple")
|
||||
@@ -147,14 +143,14 @@ def run_command(cmd, *args, **kwargs):
|
||||
try:
|
||||
cmd_string = cmd.cmdify()
|
||||
except TypeError:
|
||||
click_echo("Error turning command into string: {0}".format(cmd), err=True)
|
||||
click_echo(f"Error turning command into string: {cmd}", err=True)
|
||||
sys.exit(1)
|
||||
if environments.is_verbose():
|
||||
click_echo("Running command: $ {0}".format(cmd_string, err=True))
|
||||
click_echo(f"Running command: $ {cmd_string}")
|
||||
c = delegator.run(cmd_string, *args, **kwargs)
|
||||
return_code = c.return_code
|
||||
if environments.is_verbose():
|
||||
click_echo("Command output: {0}".format(
|
||||
click_echo("Command output: {}".format(
|
||||
crayons.cyan(decode_for_output(c.out))
|
||||
), err=True)
|
||||
if not c.ok and catch_exceptions:
|
||||
@@ -223,10 +219,10 @@ def escape_grouped_arguments(s):
|
||||
|
||||
def clean_pkg_version(version):
|
||||
"""Uses pip to prepare a package version string, from our internal version."""
|
||||
return six.u(pep440_version(str(version).replace("==", "")))
|
||||
return pep440_version(str(version).replace("==", ""))
|
||||
|
||||
|
||||
class HackedPythonVersion(object):
|
||||
class HackedPythonVersion:
|
||||
"""A Beautiful hack, which allows us to tell pip which version of Python we're using."""
|
||||
|
||||
def __init__(self, python_version, python_path):
|
||||
@@ -260,9 +256,9 @@ def prepare_pip_source_args(sources, pip_args=None):
|
||||
# Trust the host if it's not verified.
|
||||
if not sources[0].get("verify_ssl", True):
|
||||
url_parts = urllib3_util.parse_url(package_url)
|
||||
url_port = ":{0}".format(url_parts.port) if url_parts.port else ""
|
||||
url_port = f":{url_parts.port}" if url_parts.port else ""
|
||||
pip_args.extend(
|
||||
["--trusted-host", "{0}{1}".format(url_parts.host, url_port)]
|
||||
["--trusted-host", f"{url_parts.host}{url_port}"]
|
||||
)
|
||||
# Add additional sources as extra indexes.
|
||||
if len(sources) > 1:
|
||||
@@ -274,9 +270,9 @@ def prepare_pip_source_args(sources, pip_args=None):
|
||||
# Trust the host if it's not verified.
|
||||
if not source.get("verify_ssl", True):
|
||||
url_parts = urllib3_util.parse_url(url)
|
||||
url_port = ":{0}".format(url_parts.port) if url_parts.port else ""
|
||||
url_port = f":{url_parts.port}" if url_parts.port else ""
|
||||
pip_args.extend(
|
||||
["--trusted-host", "{0}{1}".format(url_parts.host, url_port)]
|
||||
["--trusted-host", f"{url_parts.host}{url_port}"]
|
||||
)
|
||||
return pip_args
|
||||
|
||||
@@ -314,7 +310,7 @@ def get_source_list(
|
||||
if index:
|
||||
sources.append(get_project_index(index))
|
||||
if extra_indexes:
|
||||
if isinstance(extra_indexes, six.string_types):
|
||||
if isinstance(extra_indexes, str):
|
||||
extra_indexes = [extra_indexes]
|
||||
for source in extra_indexes:
|
||||
extra_src = get_project_index(source)
|
||||
@@ -375,7 +371,7 @@ def get_pipenv_sitedir():
|
||||
return None
|
||||
|
||||
|
||||
class Resolver(object):
|
||||
class Resolver:
|
||||
def __init__(
|
||||
self, constraints, req_dir, project, sources, index_lookup=None,
|
||||
markers_lookup=None, skipped=None, clear=False, pre=False
|
||||
@@ -495,13 +491,13 @@ class Resolver(object):
|
||||
except ValueError:
|
||||
direct_url = DIRECT_URL_RE.match(line)
|
||||
if direct_url:
|
||||
line = "{0}#egg={1}".format(line, direct_url.groupdict()["name"])
|
||||
line = "{}#egg={}".format(line, direct_url.groupdict()["name"])
|
||||
try:
|
||||
req = Requirement.from_line(line)
|
||||
except ValueError:
|
||||
raise ResolutionFailure("Failed to resolve requirement from line: {0!s}".format(line))
|
||||
raise ResolutionFailure(f"Failed to resolve requirement from line: {line!s}")
|
||||
else:
|
||||
raise ResolutionFailure("Failed to resolve requirement from line: {0!s}".format(line))
|
||||
raise ResolutionFailure(f"Failed to resolve requirement from line: {line!s}")
|
||||
if url:
|
||||
try:
|
||||
index_lookup[req.normalized_name] = project.get_source(
|
||||
@@ -680,8 +676,8 @@ class Resolver(object):
|
||||
index_lookup, markers_lookup = {}, {}
|
||||
deps = set()
|
||||
if dev:
|
||||
deps.update(set([req.as_line() for req in pipfile.dev_packages]))
|
||||
deps.update(set([req.as_line() for req in pipfile.packages]))
|
||||
deps.update({req.as_line() for req in pipfile.dev_packages})
|
||||
deps.update({req.as_line() for req in pipfile.packages})
|
||||
constraints, skipped, index_lookup, markers_lookup = cls.get_metadata(
|
||||
list(deps), index_lookup, markers_lookup, project, project.sources,
|
||||
req_dir=req_dir, pre=pre, clear=clear
|
||||
@@ -737,9 +733,9 @@ class Resolver(object):
|
||||
if self.sources:
|
||||
requirementstxt_sources = " ".join(args_to_add) if args_to_add else ""
|
||||
requirementstxt_sources = requirementstxt_sources.replace(" --", "\n--")
|
||||
constraints_file.write(u"{0}\n".format(requirementstxt_sources))
|
||||
constraints_file.write(f"{requirementstxt_sources}\n")
|
||||
constraints = self.initial_constraints
|
||||
constraints_file.write(u"\n".join([c for c in constraints]))
|
||||
constraints_file.write("\n".join([c for c in constraints]))
|
||||
constraints_file.close()
|
||||
return constraints_file.name
|
||||
|
||||
@@ -820,7 +816,7 @@ class Resolver(object):
|
||||
from pipenv.patched.piptools.cache import CorruptCacheError
|
||||
from .exceptions import CacheError, ResolutionFailure
|
||||
with temp_environ():
|
||||
os.environ["PIP_NO_USE_PEP517"] = str("")
|
||||
os.environ["PIP_NO_USE_PEP517"] = ""
|
||||
try:
|
||||
results = self.resolver.resolve(max_rounds=environments.PIPENV_MAX_ROUNDS)
|
||||
except CorruptCacheError as e:
|
||||
@@ -876,7 +872,7 @@ class Resolver(object):
|
||||
if not checksum:
|
||||
continue
|
||||
if not checksum.startswith("sha256:"):
|
||||
checksum = "sha256:{0}".format(checksum)
|
||||
checksum = f"sha256:{checksum}"
|
||||
cleaned_checksums.append(checksum)
|
||||
return cleaned_checksums
|
||||
|
||||
@@ -895,7 +891,7 @@ class Resolver(object):
|
||||
"python.org" in source["url"] or "pypi.org" in source["url"]
|
||||
for source in self.sources
|
||||
):
|
||||
pkg_url = "https://pypi.org/pypi/{0}/json".format(ireq.name)
|
||||
pkg_url = f"https://pypi.org/pypi/{ireq.name}/json"
|
||||
session = _get_requests_session()
|
||||
try:
|
||||
# Grab the hashes from the new warehouse API.
|
||||
@@ -916,7 +912,7 @@ class Resolver(object):
|
||||
except (ValueError, KeyError, ConnectionError):
|
||||
if environments.is_verbose():
|
||||
click_echo(
|
||||
"{0}: Error generating hash for {1}".format(
|
||||
"{}: Error generating hash for {}".format(
|
||||
crayons.red("Warning", bold=True), ireq.name
|
||||
), err=True
|
||||
)
|
||||
@@ -1056,7 +1052,7 @@ def format_requirement_for_lockfile(req, markers_lookup, index_lookup, hashes=No
|
||||
name, pf_entry = req.pipfile_entry
|
||||
name = pep423_name(req.name)
|
||||
entry = {}
|
||||
if isinstance(pf_entry, six.string_types):
|
||||
if isinstance(pf_entry, str):
|
||||
entry["version"] = pf_entry.lstrip("=")
|
||||
else:
|
||||
entry.update(pf_entry)
|
||||
@@ -1150,7 +1146,7 @@ def resolve(cmd, sp):
|
||||
while True:
|
||||
result = None
|
||||
try:
|
||||
result = c.expect(u"\n", timeout=environments.PIPENV_INSTALL_TIMEOUT)
|
||||
result = c.expect("\n", timeout=environments.PIPENV_INSTALL_TIMEOUT)
|
||||
except TIMEOUT:
|
||||
pass
|
||||
except EOF:
|
||||
@@ -1160,7 +1156,7 @@ def resolve(cmd, sp):
|
||||
break
|
||||
if result:
|
||||
_out = c.subprocess.before
|
||||
_out = decode_output("{0}".format(_out))
|
||||
_out = decode_output(f"{_out}")
|
||||
out += _out
|
||||
# sp.text = to_native_string("{0}".format(_out[:100]))
|
||||
if environments.is_verbose():
|
||||
@@ -1342,13 +1338,13 @@ def venv_resolve_deps(
|
||||
if c.ok:
|
||||
sp.green.ok(environments.PIPENV_SPINNER_OK_TEXT.format("Success!"))
|
||||
if not environments.is_verbose() and c.out.strip():
|
||||
click_echo(crayons.yellow("Warning: {0}".format(c.out.strip())), err=True)
|
||||
click_echo(crayons.yellow(f"Warning: {c.out.strip()}"), err=True)
|
||||
else:
|
||||
sp.red.fail(environments.PIPENV_SPINNER_FAIL_TEXT.format("Locking Failed!"))
|
||||
click_echo("Output: {0}".format(c.out.strip()), err=True)
|
||||
click_echo("Error: {0}".format(c.err.strip()), err=True)
|
||||
click_echo(f"Output: {c.out.strip()}", err=True)
|
||||
click_echo(f"Error: {c.err.strip()}", err=True)
|
||||
try:
|
||||
with open(target_file.name, "r") as fh:
|
||||
with open(target_file.name) as fh:
|
||||
results = json.load(fh)
|
||||
except (IndexError, JSONDecodeError):
|
||||
click_echo(c.out.strip(), err=True)
|
||||
@@ -1432,13 +1428,13 @@ def resolve_deps(
|
||||
|
||||
|
||||
def is_star(val):
|
||||
return isinstance(val, six.string_types) and val == "*"
|
||||
return isinstance(val, str) and val == "*"
|
||||
|
||||
|
||||
def is_pinned(val):
|
||||
if isinstance(val, Mapping):
|
||||
val = val.get("version")
|
||||
return isinstance(val, six.string_types) and val.startswith("==")
|
||||
return isinstance(val, str) and val.startswith("==")
|
||||
|
||||
|
||||
def convert_deps_to_pip(deps, project=None, r=True, include_index=True):
|
||||
@@ -1477,7 +1473,7 @@ def mkdir_p(newdir):
|
||||
pass
|
||||
elif os.path.isfile(newdir):
|
||||
raise OSError(
|
||||
"a file with the same name as the desired dir, '{0}', already exists.".format(
|
||||
"a file with the same name as the desired dir, '{}', already exists.".format(
|
||||
newdir
|
||||
)
|
||||
)
|
||||
@@ -1530,7 +1526,7 @@ def is_installable_file(path):
|
||||
key for key in path.keys() if key in ["file", "path"]
|
||||
):
|
||||
path = urlparse(path["file"]).path if "file" in path else path["path"]
|
||||
if not isinstance(path, six.string_types) or path == "*":
|
||||
if not isinstance(path, str) or path == "*":
|
||||
return False
|
||||
|
||||
# If the string starts with a valid specifier operator, test if it is a valid
|
||||
@@ -1548,7 +1544,7 @@ def is_installable_file(path):
|
||||
return False
|
||||
|
||||
lookup_path = Path(path)
|
||||
absolute_path = "{0}".format(lookup_path.absolute())
|
||||
absolute_path = f"{lookup_path.absolute()}"
|
||||
if lookup_path.is_dir() and is_installable_dir(absolute_path):
|
||||
return True
|
||||
|
||||
@@ -1595,11 +1591,11 @@ def proper_case(package_name):
|
||||
"""Properly case project name from pypi.org."""
|
||||
# Hit the simple API.
|
||||
r = _get_requests_session().get(
|
||||
"https://pypi.org/pypi/{0}/json".format(package_name), timeout=0.3, stream=True
|
||||
f"https://pypi.org/pypi/{package_name}/json", timeout=0.3, stream=True
|
||||
)
|
||||
if not r.ok:
|
||||
raise IOError(
|
||||
"Unable to find package {0} in PyPI repository.".format(package_name)
|
||||
raise OSError(
|
||||
f"Unable to find package {package_name} in PyPI repository."
|
||||
)
|
||||
|
||||
r = parse.parse("https://pypi.org/pypi/{name}/json", r.url)
|
||||
@@ -1646,7 +1642,7 @@ def normalize_path(path):
|
||||
|
||||
|
||||
def get_url_name(url):
|
||||
if not isinstance(url, six.string_types):
|
||||
if not isinstance(url, str):
|
||||
return
|
||||
return urllib3_util.parse_url(url).host
|
||||
|
||||
@@ -1656,10 +1652,10 @@ def get_canonical_names(packages):
|
||||
from .vendor.packaging.utils import canonicalize_name
|
||||
|
||||
if not isinstance(packages, Sequence):
|
||||
if not isinstance(packages, six.string_types):
|
||||
if not isinstance(packages, str):
|
||||
return packages
|
||||
packages = [packages]
|
||||
return set([canonicalize_name(pkg) for pkg in packages if pkg])
|
||||
return {canonicalize_name(pkg) for pkg in packages if pkg}
|
||||
|
||||
|
||||
def walk_up(bottom):
|
||||
@@ -1686,8 +1682,7 @@ def walk_up(bottom):
|
||||
if new_path == bottom:
|
||||
return
|
||||
|
||||
for x in walk_up(new_path):
|
||||
yield x
|
||||
yield from walk_up(new_path)
|
||||
|
||||
|
||||
def find_requirements(max_depth=3):
|
||||
@@ -1733,7 +1728,7 @@ def load_path(python):
|
||||
import json
|
||||
python = Path(python).as_posix()
|
||||
json_dump_commmand = '"import json, sys; print(json.dumps(sys.path));"'
|
||||
c = delegator.run('"{0}" -c {1}'.format(python, json_dump_commmand))
|
||||
c = delegator.run(f'"{python}" -c {json_dump_commmand}')
|
||||
if c.return_code == 0:
|
||||
return json.loads(c.out.strip())
|
||||
else:
|
||||
@@ -1768,7 +1763,7 @@ def download_file(url, filename):
|
||||
"""Downloads file from url to a path with filename"""
|
||||
r = _get_requests_session().get(url, stream=True)
|
||||
if not r.ok:
|
||||
raise IOError("Unable to download file")
|
||||
raise OSError("Unable to download file")
|
||||
|
||||
with open(filename, "wb") as f:
|
||||
f.write(r.content)
|
||||
@@ -1783,13 +1778,13 @@ def normalize_drive(path):
|
||||
|
||||
See: <https://github.com/pypa/pipenv/issues/1218>
|
||||
"""
|
||||
if os.name != "nt" or not isinstance(path, six.string_types):
|
||||
if os.name != "nt" or not isinstance(path, str):
|
||||
return path
|
||||
|
||||
drive, tail = os.path.splitdrive(path)
|
||||
# Only match (lower cased) local drives (e.g. 'c:'), not UNC mounts.
|
||||
if drive.islower() and len(drive) == 2 and drive[1] == ":":
|
||||
return "{}{}".format(drive.upper(), tail)
|
||||
return f"{drive.upper()}{tail}"
|
||||
|
||||
return path
|
||||
|
||||
@@ -1806,7 +1801,7 @@ def is_readonly_path(fn):
|
||||
|
||||
|
||||
def set_write_bit(fn):
|
||||
if isinstance(fn, six.string_types) and not os.path.exists(fn):
|
||||
if isinstance(fn, str) and not os.path.exists(fn):
|
||||
return
|
||||
os.chmod(fn, stat.S_IWRITE | stat.S_IWUSR | stat.S_IRUSR)
|
||||
return
|
||||
@@ -1834,7 +1829,7 @@ def handle_remove_readonly(func, path, exc):
|
||||
set_write_bit(path)
|
||||
try:
|
||||
func(path)
|
||||
except (OSError, IOError) as e:
|
||||
except OSError as e:
|
||||
if e.errno in [errno.EACCES, errno.EPERM]:
|
||||
warnings.warn(default_warning_message.format(path), ResourceWarning)
|
||||
return
|
||||
@@ -1848,14 +1843,14 @@ def handle_remove_readonly(func, path, exc):
|
||||
|
||||
def escape_cmd(cmd):
|
||||
if any(special_char in cmd for special_char in ["<", ">", "&", ".", "^", "|", "?"]):
|
||||
cmd = '\"{0}\"'.format(cmd)
|
||||
cmd = f'\"{cmd}\"'
|
||||
return cmd
|
||||
|
||||
|
||||
def safe_expandvars(value):
|
||||
"""Call os.path.expandvars if value is a string, otherwise do nothing.
|
||||
"""
|
||||
if isinstance(value, six.string_types):
|
||||
if isinstance(value, str):
|
||||
return os.path.expandvars(value)
|
||||
return value
|
||||
|
||||
@@ -1932,13 +1927,13 @@ def translate_markers(pipfile_entry):
|
||||
if 'extra' not in marker:
|
||||
marker_set.add(marker)
|
||||
for m in pipfile_markers:
|
||||
entry = "{0}".format(pipfile_entry[m])
|
||||
entry = f"{pipfile_entry[m]}"
|
||||
if m != "markers":
|
||||
marker_set.add(str(Marker("{0} {1}".format(m, entry))))
|
||||
marker_set.add(str(Marker(f"{m} {entry}")))
|
||||
new_pipfile.pop(m)
|
||||
if marker_set:
|
||||
new_pipfile["markers"] = str(Marker(" or ".join(
|
||||
"{0}".format(s) if " and " in s else s
|
||||
f"{s}" if " and " in s else s
|
||||
for s in sorted(dedup(marker_set))
|
||||
))).replace('"', "'")
|
||||
return new_pipfile
|
||||
@@ -1951,9 +1946,9 @@ def clean_resolved_dep(dep, is_top_level=False, pipfile_entry=None):
|
||||
# We use this to determine if there are any markers on top level packages
|
||||
# So we can make sure those win out during resolution if the packages reoccur
|
||||
if "version" in dep and dep["version"] and not dep.get("editable", False):
|
||||
version = "{0}".format(dep["version"])
|
||||
version = "{}".format(dep["version"])
|
||||
if not version.startswith("=="):
|
||||
version = "=={0}".format(version)
|
||||
version = f"=={version}"
|
||||
lockfile["version"] = version
|
||||
if is_vcs(dep):
|
||||
ref = dep.get("ref", None)
|
||||
@@ -2139,10 +2134,10 @@ def is_url_equal(url, other_url):
|
||||
"https://mydomain.com/some?some_query")
|
||||
False
|
||||
"""
|
||||
if not isinstance(url, six.string_types):
|
||||
raise TypeError("Expected string for url, received {0!r}".format(url))
|
||||
if not isinstance(other_url, six.string_types):
|
||||
raise TypeError("Expected string for url, received {0!r}".format(other_url))
|
||||
if not isinstance(url, str):
|
||||
raise TypeError(f"Expected string for url, received {url!r}")
|
||||
if not isinstance(other_url, str):
|
||||
raise TypeError(f"Expected string for url, received {other_url!r}")
|
||||
parsed_url = urllib3_util.parse_url(url)
|
||||
parsed_other_url = urllib3_util.parse_url(other_url)
|
||||
unparsed = parsed_url._replace(auth=None, query=None, fragment=None).url
|
||||
@@ -2167,14 +2162,14 @@ def make_posix(path):
|
||||
>>> make_posix("c:\\users\\user\\venvs\\some_venv")
|
||||
"c:/users/user/venvs/some_venv"
|
||||
"""
|
||||
if not isinstance(path, six.string_types):
|
||||
raise TypeError("Expected a string for path, received {0!r}...".format(path))
|
||||
if not isinstance(path, str):
|
||||
raise TypeError(f"Expected a string for path, received {path!r}...")
|
||||
starts_with_sep = path.startswith(os.path.sep)
|
||||
separated = normalize_path(path).split(os.path.sep)
|
||||
if isinstance(separated, (list, tuple)):
|
||||
path = posixpath.join(*separated)
|
||||
if starts_with_sep:
|
||||
path = "/{0}".format(path)
|
||||
path = f"/{path}"
|
||||
return path
|
||||
|
||||
|
||||
@@ -2198,9 +2193,9 @@ def find_python(finder, line=None):
|
||||
:rtype: str
|
||||
"""
|
||||
|
||||
if line and not isinstance(line, six.string_types):
|
||||
if line and not isinstance(line, str):
|
||||
raise TypeError(
|
||||
"Invalid python search type: expected string, received {0!r}".format(line)
|
||||
f"Invalid python search type: expected string, received {line!r}"
|
||||
)
|
||||
if line and os.path.isabs(line):
|
||||
if os.name == "nt":
|
||||
@@ -2218,11 +2213,11 @@ def find_python(finder, line=None):
|
||||
if not result:
|
||||
result = finder.which(line)
|
||||
if not result and not line.startswith("python"):
|
||||
line = "python{0}".format(line)
|
||||
line = f"python{line}"
|
||||
result = find_python(finder, line)
|
||||
|
||||
if result:
|
||||
if not isinstance(result, six.string_types):
|
||||
if not isinstance(result, str):
|
||||
return result.path.as_posix()
|
||||
return result
|
||||
return
|
||||
@@ -2239,8 +2234,8 @@ def is_python_command(line):
|
||||
:rtype: bool
|
||||
"""
|
||||
|
||||
if not isinstance(line, six.string_types):
|
||||
raise TypeError("Not a valid command to check: {0!r}".format(line))
|
||||
if not isinstance(line, str):
|
||||
raise TypeError(f"Not a valid command to check: {line!r}")
|
||||
|
||||
from pipenv.vendor.pythonfinder.utils import PYTHON_IMPLEMENTATIONS
|
||||
is_version = re.match(r'\d+(\.\d+)*', line)
|
||||
|
||||
@@ -4,9 +4,14 @@ license = MIT
|
||||
license_file = LICENSE
|
||||
|
||||
[flake8]
|
||||
exclude =
|
||||
.git,__pycache__,docs/,pipenv/vendor/,pipenv/patched,get-pipenv.py,
|
||||
.eggs/,setup.py,tests/fixtures/
|
||||
extend-exclude =
|
||||
docs/,
|
||||
pipenv/vendor/,
|
||||
pipenv/patched/,
|
||||
get-pipenv.py,
|
||||
setup.py,
|
||||
tests/fixtures/,
|
||||
tests/test_artifacts/
|
||||
ignore =
|
||||
# The default ignore list:
|
||||
E121,E123,E126,E226,E24,E704,
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
import codecs
|
||||
import os
|
||||
import sys
|
||||
@@ -53,7 +52,7 @@ class DebCommand(Command):
|
||||
@staticmethod
|
||||
def status(s):
|
||||
"""Prints things in bold."""
|
||||
print("\033[1m{0}\033[0m".format(s))
|
||||
print(f"\033[1m{s}\033[0m")
|
||||
|
||||
def initialize_options(self):
|
||||
pass
|
||||
@@ -67,12 +66,12 @@ class DebCommand(Command):
|
||||
rmtree(os.path.join(here, "deb_dist"))
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
self.status(u"Creating debian mainfest...")
|
||||
self.status("Creating debian mainfest...")
|
||||
os.system(
|
||||
"python setup.py --command-packages=stdeb.command sdist_dsc -z artful --package3=pipenv --depends3=python3-virtualenv-clone"
|
||||
)
|
||||
self.status(u"Building .deb...")
|
||||
os.chdir("deb_dist/pipenv-{0}".format(about["__version__"]))
|
||||
self.status("Building .deb...")
|
||||
os.chdir("deb_dist/pipenv-{}".format(about["__version__"]))
|
||||
os.system("dpkg-buildpackage -rfakeroot -uc -us")
|
||||
|
||||
|
||||
@@ -85,7 +84,7 @@ class UploadCommand(Command):
|
||||
@staticmethod
|
||||
def status(s):
|
||||
"""Prints things in bold."""
|
||||
print("\033[1m{0}\033[0m".format(s))
|
||||
print(f"\033[1m{s}\033[0m")
|
||||
|
||||
def initialize_options(self):
|
||||
pass
|
||||
@@ -100,11 +99,11 @@ class UploadCommand(Command):
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
self.status("Building Source distribution...")
|
||||
os.system("{0} setup.py sdist bdist_wheel".format(sys.executable))
|
||||
os.system(f"{sys.executable} setup.py sdist bdist_wheel")
|
||||
self.status("Uploading the package to PyPI via Twine...")
|
||||
os.system("twine upload dist/*")
|
||||
self.status("Pushing git tags...")
|
||||
os.system("git tag v{0}".format(about["__version__"]))
|
||||
os.system("git tag v{}".format(about["__version__"]))
|
||||
os.system("git push --tags")
|
||||
sys.exit()
|
||||
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
# Copied from pip's vendoring process
|
||||
# see https://github.com/pypa/pip/blob/95bcf8c5f6394298035a7332c441868f3b0169f4/tasks/__init__.py
|
||||
from pathlib import Path
|
||||
|
||||
+7
-8
@@ -1,4 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
import datetime
|
||||
import os
|
||||
import pathlib
|
||||
@@ -107,11 +106,11 @@ def release(ctx, manual=False, local=False, dry_run=False, pre=False, tag=None,
|
||||
if pre:
|
||||
log("generating towncrier draft...")
|
||||
ctx.run("towncrier --draft > CHANGELOG.draft.rst")
|
||||
ctx.run("git add {0}".format(get_version_file(ctx).as_posix()))
|
||||
ctx.run(f"git add {get_version_file(ctx).as_posix()}")
|
||||
else:
|
||||
ctx.run("towncrier")
|
||||
ctx.run(
|
||||
"git add CHANGELOG.rst news/ {0}".format(get_version_file(ctx).as_posix())
|
||||
f"git add CHANGELOG.rst news/ {get_version_file(ctx).as_posix()}"
|
||||
)
|
||||
log("removing changelog draft if present")
|
||||
draft_changelog = pathlib.Path("CHANGELOG.draft.rst")
|
||||
@@ -283,12 +282,12 @@ def date_offset(dt, month_offset=0, day_offset=0, truncate=False):
|
||||
"month": dt.month + month_offset,
|
||||
"year": dt.year + year_offset,
|
||||
}
|
||||
log("Getting updated date from date: {0} using month offset: {1} and year offset {2}".format(
|
||||
log("Getting updated date from date: {} using month offset: {} and year offset {}".format(
|
||||
dt, new_month, replace_args["year"]
|
||||
))
|
||||
if day_offset:
|
||||
dt = dt + datetime.timedelta(days=day_offset)
|
||||
log("updated date using day offset: {0} => {1}".format(day_offset, dt))
|
||||
log(f"updated date using day offset: {day_offset} => {dt}")
|
||||
if truncate:
|
||||
log("Truncating...")
|
||||
replace_args["day"] = 1
|
||||
@@ -317,7 +316,7 @@ def bump_version(ctx, dry_run=False, dev=False, pre=False, tag=None, commit=Fals
|
||||
day_offset=day_offset,
|
||||
truncate=trunc_month
|
||||
)
|
||||
log("target_day: {0}".format(target_day))
|
||||
log(f"target_day: {target_day}")
|
||||
target_timetuple = target_day.timetuple()[:3]
|
||||
new_version = current_version.replace(release=target_timetuple)
|
||||
if pre and dev:
|
||||
@@ -338,7 +337,7 @@ def bump_version(ctx, dry_run=False, dev=False, pre=False, tag=None, commit=Fals
|
||||
new_version = new_version.replace(dev=None)
|
||||
if new_version.pre_tag:
|
||||
if new_version.pre_tag != tag:
|
||||
log("Swapping prerelease tag: {0} for {1}".format(new_version.pre_tag, tag))
|
||||
log(f"Swapping prerelease tag: {new_version.pre_tag} for {tag}")
|
||||
new_version = new_version.replace(pre_tag=tag, pre=tag_version)
|
||||
else:
|
||||
new_version = new_version.replace(pre_tag=tag, pre=tag_version)
|
||||
@@ -359,7 +358,7 @@ def bump_version(ctx, dry_run=False, dev=False, pre=False, tag=None, commit=Fals
|
||||
file_contents.replace(version, str(new_version.normalize()))
|
||||
)
|
||||
if commit:
|
||||
ctx.run("git add {0}".format(version_file.as_posix()))
|
||||
ctx.run(f"git add {version_file.as_posix()}")
|
||||
log("Committing...")
|
||||
ctx.run('git commit -s -m "Bumped version."')
|
||||
return str(new_version)
|
||||
|
||||
+56
-57
@@ -1,4 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
# Taken from pip
|
||||
# see https://github.com/pypa/pip/blob/95bcf8c5f6394298035a7332c441868f3b0169f4/tasks/vendoring/__init__.py
|
||||
""""Vendoring script, python 3.5 needed"""
|
||||
@@ -102,7 +101,7 @@ def remove_all(paths):
|
||||
|
||||
|
||||
def log(msg):
|
||||
print("[vendoring.%s] %s" % (TASK_NAME, msg))
|
||||
print(f"[vendoring.{TASK_NAME}] {msg}")
|
||||
|
||||
|
||||
def _get_git_root(ctx):
|
||||
@@ -222,8 +221,8 @@ def update_safety(ctx):
|
||||
log("generating lockfile...")
|
||||
packages = "\n".join(["safety", "requests[security]"])
|
||||
env = {"PIPENV_PACKAGES": packages}
|
||||
resolve_cmd = "python {0}".format(root.joinpath("pipenv/resolver.py").as_posix())
|
||||
py27_resolve_cmd = "python2.7 {0}".format(root.joinpath("pipenv/resolver.py").as_posix())
|
||||
resolve_cmd = "python {}".format(root.joinpath("pipenv/resolver.py").as_posix())
|
||||
py27_resolve_cmd = "python2.7 {}".format(root.joinpath("pipenv/resolver.py").as_posix())
|
||||
_, _, resolved = ctx.run(resolve_cmd, hide=True, env=env).stdout.partition("RESULTS:")
|
||||
_, _, resolved_py2 = ctx.run(py27_resolve_cmd, hide=True, env=env).stdout.partition("RESULTS:")
|
||||
resolved = json.loads(resolved.strip())
|
||||
@@ -231,11 +230,11 @@ def update_safety(ctx):
|
||||
pkg_dict, pkg_dict_py2 = {}, {}
|
||||
for pkg in resolved:
|
||||
name = pkg.pop("name")
|
||||
pkg["version"] = "=={0}".format(pkg["version"])
|
||||
pkg["version"] = "=={}".format(pkg["version"])
|
||||
pkg_dict[name] = pkg
|
||||
for pkg in resolved_py2:
|
||||
name = pkg.pop("name")
|
||||
pkg["version"] = "=={0}".format(pkg["version"])
|
||||
pkg["version"] = "=={}".format(pkg["version"])
|
||||
pkg_dict_py2[name] = pkg
|
||||
merged = merge_items([pkg_dict, pkg_dict_py2])
|
||||
lf = Lockfile.create(safety_dir.as_posix())
|
||||
@@ -255,12 +254,12 @@ def update_safety(ctx):
|
||||
]
|
||||
safety_dir.joinpath("requirements.txt").write_text("\n".join(requirements))
|
||||
if build_dir.exists() and build_dir.is_dir():
|
||||
log("dropping pre-existing build dir at {0}".format(build_dir.as_posix()))
|
||||
log(f"dropping pre-existing build dir at {build_dir.as_posix()}")
|
||||
drop_dir(build_dir)
|
||||
pip_command = "pip download -b {0} --no-binary=:all: --no-clean --no-deps -d {1} pyyaml safety".format(
|
||||
pip_command = "pip download -b {} --no-binary=:all: --no-clean --no-deps -d {} pyyaml safety".format(
|
||||
build_dir.absolute().as_posix(), str(download_dir.name),
|
||||
)
|
||||
log("downloading deps via pip: {0}".format(pip_command))
|
||||
log(f"downloading deps via pip: {pip_command}")
|
||||
ctx.run(pip_command)
|
||||
|
||||
yaml_build_dir = build_dir / "pyyaml"
|
||||
@@ -268,8 +267,8 @@ def update_safety(ctx):
|
||||
|
||||
with ctx.cd(str(safety_dir)):
|
||||
lib_dir.mkdir(exist_ok=True)
|
||||
install_cmd = "python2.7 -m pip install --ignore-requires-python -t {0} -r {1}".format(lib_dir.as_posix(), safety_dir.joinpath("requirements.txt").as_posix())
|
||||
log("installing dependencies: {0}".format(install_cmd))
|
||||
install_cmd = "python2.7 -m pip install --ignore-requires-python -t {} -r {}".format(lib_dir.as_posix(), safety_dir.joinpath("requirements.txt").as_posix())
|
||||
log(f"installing dependencies: {install_cmd}")
|
||||
ctx.run(install_cmd)
|
||||
safety_dir = safety_dir.absolute()
|
||||
yaml_dir = lib_dir / "yaml"
|
||||
@@ -299,23 +298,23 @@ def update_safety(ctx):
|
||||
log("dropping ignored files...")
|
||||
for pattern in ignore_patterns:
|
||||
for path in lib_dir.rglob(pattern):
|
||||
log("removing {0!s}".format(path))
|
||||
log(f"removing {path!s}")
|
||||
path.unlink()
|
||||
for dep in ignore_subdeps:
|
||||
if lib_dir.joinpath(dep).exists():
|
||||
log("cleaning up {0}".format(dep))
|
||||
log(f"cleaning up {dep}")
|
||||
drop_dir(lib_dir.joinpath(dep))
|
||||
for path in itertools.chain.from_iterable((
|
||||
lib_dir.rglob("{0}*.egg-info".format(dep)),
|
||||
lib_dir.rglob("{0}*.dist-info".format(dep))
|
||||
lib_dir.rglob(f"{dep}*.egg-info"),
|
||||
lib_dir.rglob(f"{dep}*.dist-info")
|
||||
)):
|
||||
log("cleaning up {0}".format(path))
|
||||
log(f"cleaning up {path}")
|
||||
drop_dir(path)
|
||||
for fn in ignore_files:
|
||||
for path in lib_dir.rglob(fn):
|
||||
log("cleaning up {0}".format(path))
|
||||
log(f"cleaning up {path}")
|
||||
path.unlink()
|
||||
zip_name = "{0}/safety.zip".format(str(patched_dir))
|
||||
zip_name = f"{str(patched_dir)}/safety.zip"
|
||||
log("writing zipfile...")
|
||||
with zipfile.ZipFile(zip_name, 'w', compression=zipfile.ZIP_DEFLATED, compresslevel=6) as zf:
|
||||
_recursive_write_to_zip(zf, safety_dir)
|
||||
@@ -329,7 +328,7 @@ def rename_if_needed(ctx, vendor_dir, item):
|
||||
if item.name in rename_dict or item.name in LIBRARY_DIRNAMES:
|
||||
new_name = rename_dict.get(item.name, LIBRARY_DIRNAMES.get(item.name))
|
||||
new_path = item.parent / new_name
|
||||
log("Renaming %s => %s" % (item.name, new_path))
|
||||
log(f"Renaming {item.name} => {new_path}")
|
||||
# handle existing directories
|
||||
try:
|
||||
item.rename(str(new_path))
|
||||
@@ -346,7 +345,7 @@ def write_backport_imports(ctx, vendor_dir):
|
||||
backport_libs = detect_vendored_libs(backport_dir)
|
||||
init_py_lines = backport_init.read_text().splitlines()
|
||||
for lib in backport_libs:
|
||||
lib_line = "from . import {0}".format(lib)
|
||||
lib_line = f"from . import {lib}"
|
||||
if lib_line not in init_py_lines:
|
||||
log("Adding backport %s to __init__.py exports" % lib)
|
||||
init_py_lines.append(lib_line)
|
||||
@@ -366,29 +365,29 @@ def _ensure_package_in_requirements(ctx, requirements_file, package):
|
||||
if m.lower() == package or (
|
||||
specifiers and m[: min(specifiers)].lower() == package
|
||||
):
|
||||
matched_req = "{0}".format(m)
|
||||
matched_req = f"{m}"
|
||||
requirement = matched_req
|
||||
log("Matched req: %r" % matched_req)
|
||||
if not matched_req:
|
||||
req_file_lines.append("{0}".format(package))
|
||||
req_file_lines.append(f"{package}")
|
||||
log("Writing requirements file: %s" % requirements_file)
|
||||
requirements_file.write_text("\n".join(req_file_lines))
|
||||
requirement = "{0}".format(package)
|
||||
requirement = f"{package}"
|
||||
return requirement
|
||||
|
||||
|
||||
def install_pyyaml(ctx, vendor_dir):
|
||||
build_dir = vendor_dir / "build"
|
||||
if build_dir.exists() and build_dir.is_dir():
|
||||
log("dropping pre-existing build dir at {0}".format(build_dir.as_posix()))
|
||||
log(f"dropping pre-existing build dir at {build_dir.as_posix()}")
|
||||
drop_dir(build_dir)
|
||||
build_dir.mkdir()
|
||||
with TemporaryDirectory(prefix="pipenv-", suffix="-safety") as download_dir:
|
||||
pip_command = "pip download -b {0} --no-binary=:all: --no-clean --no-deps -d {1} pyyaml safety".format(
|
||||
pip_command = "pip download -b {} --no-binary=:all: --no-clean --no-deps -d {} pyyaml safety".format(
|
||||
build_dir.absolute().as_posix(), str(download_dir.name),
|
||||
)
|
||||
temp_env = "TEMP" if os.name == "nt" else "TMPDIR"
|
||||
log("downloading deps via pip: {0}".format(pip_command))
|
||||
log(f"downloading deps via pip: {pip_command}")
|
||||
ctx.run(pip_command, env={temp_env: str(build_dir)})
|
||||
yaml_build_dir = next(build_dir.glob('pip-download-*/pyyaml_*'))
|
||||
yaml_dir = vendor_dir / "yaml"
|
||||
@@ -404,8 +403,8 @@ def install_pyyaml(ctx, vendor_dir):
|
||||
|
||||
|
||||
def install(ctx, vendor_dir, package=None):
|
||||
requirements_file = vendor_dir / "{0}.txt".format(vendor_dir.name)
|
||||
requirement = "-r {0}".format(requirements_file.as_posix())
|
||||
requirements_file = vendor_dir / f"{vendor_dir.name}.txt"
|
||||
requirement = f"-r {requirements_file.as_posix()}"
|
||||
log("Using requirements file: %s" % requirement)
|
||||
if package:
|
||||
requirement = _ensure_package_in_requirements(ctx, requirements_file, package)
|
||||
@@ -413,7 +412,7 @@ def install(ctx, vendor_dir, package=None):
|
||||
# are added to vendor.txt, this includes all dependencies recursively up
|
||||
# the chain.
|
||||
ctx.run(
|
||||
"pip install -t {0} --no-compile --no-deps --upgrade {1}".format(
|
||||
"pip install -t {} --no-compile --no-deps --upgrade {}".format(
|
||||
vendor_dir.as_posix(), requirement,
|
||||
)
|
||||
)
|
||||
@@ -427,20 +426,20 @@ def install(ctx, vendor_dir, package=None):
|
||||
vendor_dir.joinpath(pkg).joinpath("LICENSE").write_text(
|
||||
license_file.read_text()
|
||||
)
|
||||
elif vendor_dir.joinpath("{0}.py".format(pkg)).exists():
|
||||
vendor_dir.joinpath("{0}.LICENSE".format(pkg)).write_text(
|
||||
elif vendor_dir.joinpath(f"{pkg}.py").exists():
|
||||
vendor_dir.joinpath(f"{pkg}.LICENSE").write_text(
|
||||
license_file.read_text()
|
||||
)
|
||||
else:
|
||||
pkg = pkg.replace("-", "?").replace("_", "?")
|
||||
matched_path = next(
|
||||
iter(pth for pth in vendor_dir.glob("{0}*".format(pkg))), None
|
||||
iter(pth for pth in vendor_dir.glob(f"{pkg}*")), None
|
||||
)
|
||||
if matched_path is not None:
|
||||
if matched_path.is_dir():
|
||||
target = vendor_dir.joinpath(matched_path).joinpath("LICENSE")
|
||||
else:
|
||||
target = vendor_dir.joinpath("{0}.LICENSE".format(matched_path))
|
||||
target = vendor_dir.joinpath(f"{matched_path}.LICENSE")
|
||||
target.write_text(
|
||||
license_file.read_text()
|
||||
)
|
||||
@@ -529,7 +528,7 @@ def redo_imports(ctx, library, vendor_dir=None):
|
||||
log("Using vendor dir: %s" % vendor_dir)
|
||||
vendored_libs = detect_vendored_libs(vendor_dir)
|
||||
item = vendor_dir / library
|
||||
library_name = vendor_dir / "{0}.py".format(library)
|
||||
library_name = vendor_dir / f"{library}.py"
|
||||
log("Detected vendored libraries: %s" % ", ".join(vendored_libs))
|
||||
log("Rewriting imports for %s..." % item)
|
||||
if item.is_dir():
|
||||
@@ -581,7 +580,7 @@ def packages_missing_licenses(
|
||||
possible_pkgs.append(LIBRARY_DIRNAMES[pkg])
|
||||
for pkgpath in possible_pkgs:
|
||||
pkgpath = vendor_dir.joinpath(pkgpath)
|
||||
py_path = pkgpath.parent / "{0}.py".format(pkgpath.stem)
|
||||
py_path = pkgpath.parent / f"{pkgpath.stem}.py"
|
||||
if pkgpath.exists() and pkgpath.is_dir():
|
||||
for license_path in LICENSES:
|
||||
license_path = pkgpath.joinpath(license_path)
|
||||
@@ -591,7 +590,7 @@ def packages_missing_licenses(
|
||||
break
|
||||
elif pkgpath.exists() or py_path.exists():
|
||||
for license_path in LICENSES:
|
||||
license_name = "{0}.{1}".format(pkgpath.stem, license_path)
|
||||
license_name = f"{pkgpath.stem}.{license_path}"
|
||||
license_path = pkgpath.parent / license_name
|
||||
if license_path.exists():
|
||||
match_found = True
|
||||
@@ -635,16 +634,16 @@ def download_licenses(
|
||||
ctx.run("pip install flit") # needed for the next step
|
||||
for req in requirements:
|
||||
if req.startswith("enum34"):
|
||||
exe_cmd = "{0} -d {1} {2}".format(enum_cmd, tmp_dir.as_posix(), req)
|
||||
exe_cmd = f"{enum_cmd} -d {tmp_dir.as_posix()} {req}"
|
||||
else:
|
||||
exe_cmd = "{0} --no-build-isolation -d {1} {2}".format(
|
||||
exe_cmd = "{} --no-build-isolation -d {} {}".format(
|
||||
cmd, tmp_dir.as_posix(), req
|
||||
)
|
||||
try:
|
||||
ctx.run(exe_cmd)
|
||||
except invoke.exceptions.UnexpectedExit as e:
|
||||
if "Disabling PEP 517 processing is invalid" not in e.result.stderr:
|
||||
log("WARNING: Failed to download license for {0}".format(req))
|
||||
log(f"WARNING: Failed to download license for {req}")
|
||||
continue
|
||||
parse_target = (
|
||||
"Disabling PEP 517 processing is invalid: project specifies a build "
|
||||
@@ -655,9 +654,9 @@ def download_licenses(
|
||||
if backend is not None:
|
||||
if "." in backend:
|
||||
backend, _, _ = backend.partition(".")
|
||||
ctx.run("pip install {0}".format(backend))
|
||||
ctx.run(f"pip install {backend}")
|
||||
ctx.run(
|
||||
"{0} --no-build-isolation -d {1} {2}".format(cmd, tmp_dir.as_posix(), req)
|
||||
f"{cmd} --no-build-isolation -d {tmp_dir.as_posix()} {req}"
|
||||
)
|
||||
for sdist in tmp_dir.iterdir():
|
||||
extract_license(vendor_dir, sdist)
|
||||
@@ -667,7 +666,7 @@ def download_licenses(
|
||||
def extract_license(vendor_dir, sdist):
|
||||
if sdist.stem.endswith(".tar"):
|
||||
ext = sdist.suffix[1:]
|
||||
with tarfile.open(sdist, mode="r:{}".format(ext)) as tar:
|
||||
with tarfile.open(sdist, mode=f"r:{ext}") as tar:
|
||||
found = find_and_extract_license(vendor_dir, tar, tar.getmembers())
|
||||
elif sdist.suffix in (".zip", ".whl"):
|
||||
with zipfile.ZipFile(sdist) as zip:
|
||||
@@ -676,7 +675,7 @@ def extract_license(vendor_dir, sdist):
|
||||
raise NotImplementedError("new sdist type!")
|
||||
|
||||
if not found:
|
||||
log("License not found in {}, will download".format(sdist.name))
|
||||
log(f"License not found in {sdist.name}, will download")
|
||||
license_fallback(vendor_dir, sdist.name)
|
||||
|
||||
|
||||
@@ -690,7 +689,7 @@ def find_and_extract_license(vendor_dir, tar, members):
|
||||
if "LICENSE" in name or "COPYING" in name:
|
||||
if "/test" in name:
|
||||
# some testing licenses in hml5lib and distlib
|
||||
log("Ignoring {}".format(name))
|
||||
log(f"Ignoring {name}")
|
||||
continue
|
||||
found = True
|
||||
extract_license_member(vendor_dir, tar, member, name)
|
||||
@@ -701,13 +700,13 @@ def license_fallback(vendor_dir, sdist_name):
|
||||
"""Hardcoded license URLs. Check when updating if those are still needed"""
|
||||
libname = libname_from_dir(sdist_name)
|
||||
if libname not in HARDCODED_LICENSE_URLS:
|
||||
raise ValueError("No hardcoded URL for {} license".format(libname))
|
||||
raise ValueError(f"No hardcoded URL for {libname} license")
|
||||
|
||||
url = HARDCODED_LICENSE_URLS[libname]
|
||||
_, _, name = url.rpartition("/")
|
||||
dest = license_destination(vendor_dir, libname, name)
|
||||
r = requests.get(url, allow_redirects=True)
|
||||
log("Downloading {}".format(url))
|
||||
log(f"Downloading {url}")
|
||||
r.raise_for_status()
|
||||
dest.write_bytes(r.content)
|
||||
|
||||
@@ -738,7 +737,7 @@ def license_destination(vendor_dir, libname, filename):
|
||||
override = vendor_dir / LIBRARY_DIRNAMES[libname]
|
||||
if not override.exists() and override.parent.exists():
|
||||
# for flattened subdeps, specifically backports/weakref.py
|
||||
return (vendor_dir / override.parent) / "{0}.{1}".format(
|
||||
return (vendor_dir / override.parent) / "{}.{}".format(
|
||||
override.name, filename
|
||||
)
|
||||
license_path = Path(LIBRARY_DIRNAMES[libname]) / filename
|
||||
@@ -746,7 +745,7 @@ def license_destination(vendor_dir, libname, filename):
|
||||
return vendor_dir / LICENSE_RENAMES[license_path.as_posix()]
|
||||
return vendor_dir / LIBRARY_DIRNAMES[libname] / filename
|
||||
# fallback to libname.LICENSE (used for nondirs)
|
||||
return vendor_dir / "{}.{}".format(libname, filename)
|
||||
return vendor_dir / f"{libname}.{filename}"
|
||||
|
||||
|
||||
def extract_license_member(vendor_dir, tar, member, name):
|
||||
@@ -754,7 +753,7 @@ def extract_license_member(vendor_dir, tar, member, name):
|
||||
dirname = list(mpath.parents)[-2].name # -1 is .
|
||||
libname = libname_from_dir(dirname)
|
||||
dest = license_destination(vendor_dir, libname, mpath.name)
|
||||
log("Extracting {} into {}".format(name, dest))
|
||||
log(f"Extracting {name} into {dest}")
|
||||
try:
|
||||
fileobj = tar.extractfile(member)
|
||||
dest.write_bytes(fileobj.read())
|
||||
@@ -770,9 +769,9 @@ def generate_patch(ctx, package_path, patch_description, base="HEAD"):
|
||||
"example usage: generate-patch patched/piptools some-description"
|
||||
)
|
||||
if patch_description:
|
||||
patch_fn = "{0}-{1}.patch".format(pkg.parts[1], patch_description)
|
||||
patch_fn = f"{pkg.parts[1]}-{patch_description}.patch"
|
||||
else:
|
||||
patch_fn = "{0}.patch".format(pkg.parts[1])
|
||||
patch_fn = f"{pkg.parts[1]}.patch"
|
||||
command = "git diff {base} -p {root} > {out}".format(
|
||||
base=base,
|
||||
root=Path("pipenv").joinpath(pkg),
|
||||
@@ -826,13 +825,13 @@ def unpin_and_copy_requirements(ctx, requirement_file, name="requirements.txt"):
|
||||
"PIPENV_PYTHON": "3.6",
|
||||
}
|
||||
with ctx.cd(tempdir.name):
|
||||
ctx.run("pipenv install -r {0}".format(target.as_posix()), env=env, hide=True)
|
||||
ctx.run(f"pipenv install -r {target.as_posix()}", env=env, hide=True)
|
||||
result = ctx.run("pipenv lock -r", env=env, hide=True).stdout.strip()
|
||||
ctx.run("pipenv --rm", env=env, hide=True)
|
||||
result = list(sorted([line.strip() for line in result.splitlines()[1:]]))
|
||||
result = list(sorted(line.strip() for line in result.splitlines()[1:]))
|
||||
new_requirements = requirement_file.parent.joinpath(name)
|
||||
requirement_file.rename(
|
||||
requirement_file.parent.joinpath("{}.bak".format(name))
|
||||
requirement_file.parent.joinpath(f"{name}.bak")
|
||||
)
|
||||
new_requirements.write_text("\n".join(result))
|
||||
return result
|
||||
@@ -886,8 +885,8 @@ def install_yaml(ctx):
|
||||
|
||||
@invoke.task
|
||||
def vendor_artifact(ctx, package, version=None):
|
||||
simple = requests.get("https://pypi.org/simple/{0}/".format(package))
|
||||
pkg_str = "{0}-{1}".format(package, version)
|
||||
simple = requests.get(f"https://pypi.org/simple/{package}/")
|
||||
pkg_str = f"{package}-{version}"
|
||||
soup = bs4.BeautifulSoup(simple.content)
|
||||
links = [
|
||||
a.attrs["href"] for a in soup.find_all("a") if a.getText().startswith(pkg_str)
|
||||
@@ -898,6 +897,6 @@ def vendor_artifact(ctx, package, version=None):
|
||||
dest_dir.mkdir()
|
||||
_, _, dest_path = urllib3_parse(link).path.rpartition("/")
|
||||
dest_file = dest_dir / dest_path
|
||||
with io.open(dest_file.as_posix(), "wb") as target_handle:
|
||||
with open(dest_file.as_posix(), "wb") as target_handle:
|
||||
with open_file(link) as fp:
|
||||
shutil.copyfileobj(fp, target_handle)
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
"""Allow safety to be executable through `python -m safety`."""
|
||||
from __future__ import absolute_import
|
||||
|
||||
import os
|
||||
import sys
|
||||
@@ -38,7 +37,7 @@ def insert_before_site_packages(*paths):
|
||||
|
||||
if __name__ == "__main__":
|
||||
insert_before_site_packages(LIBPATH)
|
||||
yaml_lib = 'yaml{0}'.format(sys.version_info[0])
|
||||
yaml_lib = f'yaml{sys.version_info[0]}'
|
||||
locals()[yaml_lib] = __import__(yaml_lib)
|
||||
sys.modules['yaml'] = sys.modules[yaml_lib]
|
||||
from safety.cli import cli
|
||||
|
||||
@@ -55,4 +55,3 @@ universal = 1
|
||||
[egg_info]
|
||||
tag_build =
|
||||
tag_date = 0
|
||||
|
||||
|
||||
+1
-1
@@ -23,7 +23,7 @@ with open(os.path.join(ROOT, 'src', PACKAGE_NAME.replace("-", "_"), '__init__.py
|
||||
VERSION = ast.literal_eval(line[len('__version__ = '):].strip())
|
||||
break
|
||||
if VERSION is None:
|
||||
raise EnvironmentError('failed to read version')
|
||||
raise OSError('failed to read version')
|
||||
|
||||
|
||||
# Put everything in setup.cfg, except those that don't actually work?
|
||||
|
||||
-1
@@ -1,4 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
# Configuration file for the Sphinx documentation builder.
|
||||
#
|
||||
|
||||
Vendored
+1
-1
@@ -16,7 +16,7 @@ with open(os.path.join(ROOT, 'src', PACKAGE_NAME.replace("-", "_"), '__init__.py
|
||||
VERSION = ast.literal_eval(line[len('__version__ = '):].strip())
|
||||
break
|
||||
if VERSION is None:
|
||||
raise EnvironmentError('failed to read version')
|
||||
raise OSError('failed to read version')
|
||||
|
||||
|
||||
# Put everything in setup.cfg, except those that don't actually work?
|
||||
|
||||
+2
-2
@@ -152,14 +152,14 @@ def build_docs(ctx):
|
||||
minor = [str(i) for i in _current_version.release[:2]]
|
||||
docs_folder = (ROOT / 'docs').as_posix()
|
||||
if not docs_folder.endswith('/'):
|
||||
docs_folder = '{0}/'.format(docs_folder)
|
||||
docs_folder = f'{docs_folder}/'
|
||||
args = ["--ext-autodoc", "--ext-viewcode", "-o", docs_folder]
|
||||
args.extend(["-A", "'Dan Ryan <dan@danryan.co>'"])
|
||||
args.extend(["-R", str(_current_version)])
|
||||
args.extend(["-V", ".".join(minor)])
|
||||
args.extend(["-e", "-M", "-F", f"src/{PACKAGE_NAME}"])
|
||||
print("Building docs...")
|
||||
ctx.run("sphinx-apidoc {0}".format(" ".join(args)))
|
||||
ctx.run("sphinx-apidoc {}".format(" ".join(args)))
|
||||
|
||||
|
||||
@invoke.task
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@ with open(os.path.join(ROOT, 'src', PACKAGE_NAME.replace("-", "_"), '__init__.py
|
||||
VERSION = ast.literal_eval(line[len('__version__ = '):].strip())
|
||||
break
|
||||
if VERSION is None:
|
||||
raise EnvironmentError('failed to read version')
|
||||
raise OSError('failed to read version')
|
||||
|
||||
|
||||
# Put everything in setup.cfg, except those that don't actually work?
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
|
||||
import errno
|
||||
import json
|
||||
import logging
|
||||
@@ -49,11 +46,11 @@ def check_internet():
|
||||
try_internet(url)
|
||||
except KeyboardInterrupt:
|
||||
warnings.warn(
|
||||
"Skipped connecting to internet: {0}".format(url), RuntimeWarning
|
||||
f"Skipped connecting to internet: {url}", RuntimeWarning
|
||||
)
|
||||
except Exception:
|
||||
warnings.warn(
|
||||
"Failed connecting to internet: {0}".format(url), RuntimeWarning
|
||||
f"Failed connecting to internet: {url}", RuntimeWarning
|
||||
)
|
||||
else:
|
||||
has_internet = True
|
||||
@@ -223,7 +220,7 @@ WE_HAVE_INTERNET = check_internet()
|
||||
WE_HAVE_GITHUB_SSH_KEYS = False
|
||||
|
||||
|
||||
class _Pipfile(object):
|
||||
class _Pipfile:
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
if self.path.exists():
|
||||
@@ -234,7 +231,7 @@ class _Pipfile(object):
|
||||
self.document["requires"] = self.document.get("requires", tomlkit.table())
|
||||
self.document["packages"] = self.document.get("packages", tomlkit.table())
|
||||
self.document["dev_packages"] = self.document.get("dev_packages", tomlkit.table())
|
||||
super(_Pipfile, self).__init__()
|
||||
super().__init__()
|
||||
|
||||
def install(self, package, value, dev=False):
|
||||
section = "packages" if not dev else "dev_packages"
|
||||
@@ -292,15 +289,15 @@ class _Pipfile(object):
|
||||
fixture_pypi = os.getenv("ARTIFACT_PYPI_URL")
|
||||
if fixture_pypi:
|
||||
if pkg and not filename:
|
||||
url = "{0}/artifacts/{1}".format(fixture_pypi, pkg)
|
||||
url = f"{fixture_pypi}/artifacts/{pkg}"
|
||||
else:
|
||||
url = "{0}/artifacts/{1}/{2}".format(fixture_pypi, pkg, filename)
|
||||
url = f"{fixture_pypi}/artifacts/{pkg}/{filename}"
|
||||
return url
|
||||
if pkg and not filename:
|
||||
return cls.get_fixture_path(file_path).as_uri()
|
||||
|
||||
|
||||
class _PipenvInstance(object):
|
||||
class _PipenvInstance:
|
||||
"""An instance of a Pipenv Project..."""
|
||||
def __init__(
|
||||
self, pypi=None, pipfile=True, chdir=False, path=None, home_dir=None,
|
||||
@@ -351,7 +348,7 @@ class _PipenvInstance(object):
|
||||
self.chdir = chdir
|
||||
|
||||
if self.pypi and "PIPENV_PYPI_URL" not in os.environ:
|
||||
os.environ['PIPENV_PYPI_URL'] = fs_str('{0}'.format(self.pypi))
|
||||
os.environ['PIPENV_PYPI_URL'] = fs_str(f'{self.pypi}')
|
||||
# os.environ['PIPENV_PYPI_URL'] = fs_str('{0}'.format(self.pypi.url))
|
||||
# os.environ['PIPENV_TEST_INDEX'] = fs_str('{0}/simple'.format(self.pypi.url))
|
||||
|
||||
@@ -389,7 +386,7 @@ class _PipenvInstance(object):
|
||||
with TemporaryDirectory(prefix='pipenv-', suffix='-cache') as tempdir:
|
||||
os.environ['PIPENV_CACHE_DIR'] = fs_str(tempdir.name)
|
||||
c = delegator.run(
|
||||
'pipenv {0}'.format(cmd), block=block,
|
||||
f'pipenv {cmd}', block=block,
|
||||
cwd=os.path.abspath(self.path), env=os.environ.copy()
|
||||
)
|
||||
if 'PIPENV_CACHE_DIR' in os.environ:
|
||||
@@ -400,7 +397,7 @@ class _PipenvInstance(object):
|
||||
|
||||
# Pretty output for failing tests.
|
||||
if block:
|
||||
print('$ pipenv {0}'.format(cmd))
|
||||
print(f'$ pipenv {cmd}')
|
||||
print(c.out)
|
||||
print(c.err, file=sys.stderr)
|
||||
if c.return_code != 0:
|
||||
@@ -412,13 +409,13 @@ class _PipenvInstance(object):
|
||||
@property
|
||||
def pipfile(self):
|
||||
p_path = os.sep.join([self.path, 'Pipfile'])
|
||||
with open(p_path, 'r') as f:
|
||||
with open(p_path) as f:
|
||||
return toml.loads(f.read())
|
||||
|
||||
@property
|
||||
def lockfile(self):
|
||||
p_path = self.lockfile_path
|
||||
with open(p_path, 'r') as f:
|
||||
with open(p_path) as f:
|
||||
return json.loads(f.read())
|
||||
|
||||
@property
|
||||
@@ -433,7 +430,7 @@ def _rmtree_func(path, ignore_errors=True, onerror=None):
|
||||
onerror = handle_remove_readonly
|
||||
try:
|
||||
shutil_rmtree(directory, ignore_errors=ignore_errors, onerror=onerror)
|
||||
except (IOError, OSError, FileNotFoundError, PermissionError) as exc:
|
||||
except (OSError, FileNotFoundError, PermissionError) as exc:
|
||||
# Ignore removal failures where the file doesn't exist
|
||||
if exc.errno != errno.ENOENT:
|
||||
raise
|
||||
@@ -459,7 +456,7 @@ def PipenvInstance(pip_src_dir, monkeypatch, pypi):
|
||||
m.setenv("PIPENV_NOSPIN", fs_str("1"))
|
||||
m.setenv("CI", fs_str("1"))
|
||||
m.setenv('PIPENV_DONT_USE_PYENV', fs_str('1'))
|
||||
m.setenv("PIPENV_TEST_INDEX", "{0}/simple".format(pypi.url))
|
||||
m.setenv("PIPENV_TEST_INDEX", f"{pypi.url}/simple")
|
||||
m.setenv("PIPENV_PYPI_INDEX", "simple")
|
||||
m.setenv("ARTIFACT_PYPI_URL", pypi.url)
|
||||
m.setenv("PIPENV_PYPI_URL", pypi.url)
|
||||
@@ -479,7 +476,7 @@ def PipenvInstance_NoPyPI(monkeypatch, pip_src_dir, pypi):
|
||||
m.setenv("PIPENV_NOSPIN", fs_str("1"))
|
||||
m.setenv("CI", fs_str("1"))
|
||||
m.setenv('PIPENV_DONT_USE_PYENV', fs_str('1'))
|
||||
m.setenv("PIPENV_TEST_INDEX", "{0}/simple".format(pypi.url))
|
||||
m.setenv("PIPENV_TEST_INDEX", f"{pypi.url}/simple")
|
||||
m.setenv("ARTIFACT_PYPI_URL", pypi.url)
|
||||
warnings.simplefilter("ignore", category=ResourceWarning)
|
||||
warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<ssl.SSLSocket.*>")
|
||||
@@ -494,7 +491,7 @@ def testsroot():
|
||||
return TESTS_ROOT
|
||||
|
||||
|
||||
class VirtualEnv(object):
|
||||
class VirtualEnv:
|
||||
def __init__(self, name="venv", base_dir=None):
|
||||
if base_dir is None:
|
||||
base_dir = Path(_create_tracked_dir())
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
"""Tests to ensure `pipenv --option` works.
|
||||
"""
|
||||
|
||||
@@ -120,22 +118,22 @@ def test_pipenv_graph_reverse(PipenvInstance):
|
||||
]
|
||||
|
||||
for dep_name, dep_constraint in requests_dependency:
|
||||
pat = r'^[ -]*{}==[\d.]+'.format(dep_name)
|
||||
pat = fr'^[ -]*{dep_name}==[\d.]+'
|
||||
dep_match = re.search(pat, output, flags=re.MULTILINE)
|
||||
assert dep_match is not None, '{} not found in {}'.format(pat, output)
|
||||
assert dep_match is not None, f'{pat} not found in {output}'
|
||||
|
||||
# openpyxl should be indented
|
||||
if dep_name == 'openpyxl':
|
||||
openpyxl_dep = re.search(r'^openpyxl', output, flags=re.MULTILINE)
|
||||
assert openpyxl_dep is None, 'openpyxl should not appear at begining of lines in {}'.format(output)
|
||||
assert openpyxl_dep is None, f'openpyxl should not appear at begining of lines in {output}'
|
||||
|
||||
assert ' - openpyxl==2.5.4 [requires: et-xmlfile]' in output
|
||||
else:
|
||||
dep_match = re.search(r'^[ -]*{}==[\d.]+$'.format(dep_name), output, flags=re.MULTILINE)
|
||||
assert dep_match is not None, '{} not found at beginning of line in {}'.format(dep_name, output)
|
||||
dep_match = re.search(fr'^[ -]*{dep_name}==[\d.]+$', output, flags=re.MULTILINE)
|
||||
assert dep_match is not None, f'{dep_name} not found at beginning of line in {output}'
|
||||
|
||||
dep_requests_match = re.search(r'^ +- tablib==0.13.0 \[requires: {}\]$'.format(dep_constraint), output, flags=re.MULTILINE)
|
||||
assert dep_requests_match is not None, 'constraint {} not found in {}'.format(dep_constraint, output)
|
||||
dep_requests_match = re.search(fr'^ +- tablib==0.13.0 \[requires: {dep_constraint}\]$', output, flags=re.MULTILINE)
|
||||
assert dep_requests_match is not None, f'constraint {dep_constraint} not found in {output}'
|
||||
assert dep_requests_match.start() > dep_match.start()
|
||||
|
||||
|
||||
@@ -164,11 +162,11 @@ def test_pipenv_clean_pip_no_warnings(PipenvInstance):
|
||||
f.write('from setuptools import setup; setup(name="empty")')
|
||||
c = p.pipenv('install -e .')
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv('run pip install -i {} pytz'.format(p.index_url))
|
||||
c = p.pipenv(f'run pip install -i {p.index_url} pytz')
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv('clean')
|
||||
assert c.return_code == 0
|
||||
assert c.out, "{0} -- STDERR: {1}".format(c.out, c.err)
|
||||
assert c.out, f"{c.out} -- STDERR: {c.err}"
|
||||
|
||||
|
||||
@pytest.mark.cli
|
||||
@@ -178,7 +176,7 @@ def test_pipenv_clean_pip_warnings(PipenvInstance):
|
||||
f.write('from setuptools import setup; setup(name="empty")')
|
||||
# create a fake git repo to trigger a pip freeze warning
|
||||
os.mkdir('.git')
|
||||
c = p.pipenv("run pip install -i {} -e .".format(p.index_url))
|
||||
c = p.pipenv(f"run pip install -i {p.index_url} -e .")
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv('clean')
|
||||
assert c.return_code == 0
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import os
|
||||
|
||||
import pytest
|
||||
@@ -55,7 +53,7 @@ def test_mirror_install(PipenvInstance):
|
||||
assert "pypi.org" not in mirror_url
|
||||
# This should sufficiently demonstrate the mirror functionality
|
||||
# since pypi.org is the default when PIPENV_TEST_INDEX is unset.
|
||||
c = p.pipenv("install requests --pypi-mirror {0}".format(mirror_url))
|
||||
c = p.pipenv(f"install requests --pypi-mirror {mirror_url}")
|
||||
assert c.return_code == 0
|
||||
# Ensure the --pypi-mirror parameter hasn't altered the Pipfile or Pipfile.lock sources
|
||||
assert len(p.pipfile["source"]) == 1
|
||||
@@ -91,8 +89,8 @@ def test_complex_lock(PipenvInstance):
|
||||
c = p.pipenv("install apscheduler")
|
||||
assert c.return_code == 0
|
||||
assert "apscheduler" in p.pipfile["packages"]
|
||||
assert "funcsigs" in p.lockfile[u"default"]
|
||||
assert "futures" in p.lockfile[u"default"]
|
||||
assert "funcsigs" in p.lockfile["default"]
|
||||
assert "futures" in p.lockfile["default"]
|
||||
|
||||
|
||||
@flaky
|
||||
@@ -286,7 +284,7 @@ def test_requirements_to_pipfile(PipenvInstance, pypi):
|
||||
|
||||
# Write a requirements file
|
||||
with open("requirements.txt", "w") as f:
|
||||
f.write("-i {}\nrequests[socks]==2.19.1\n".format(pypi.url))
|
||||
f.write(f"-i {pypi.url}\nrequests[socks]==2.19.1\n")
|
||||
|
||||
c = p.pipenv("install")
|
||||
assert c.return_code == 0
|
||||
@@ -430,7 +428,7 @@ def test_system_and_deploy_work(PipenvInstance):
|
||||
c = p.pipenv("--rm")
|
||||
assert c.return_code == 0
|
||||
Path(p.pipfile_path).write_text(
|
||||
u"""
|
||||
"""
|
||||
[packages]
|
||||
tablib = "*"
|
||||
""".strip()
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import os
|
||||
import sys
|
||||
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
@@ -54,8 +52,8 @@ testpipenv = {path = ".", editable = true, extras = ["dev"]}
|
||||
assert "six" in p.lockfile["default"]
|
||||
c = p.pipenv("uninstall --all")
|
||||
assert c.return_code == 0
|
||||
print("Current directory: {0}".format(os.getcwd()), file=sys.stderr)
|
||||
c = p.pipenv("install {0}".format(line))
|
||||
print(f"Current directory: {os.getcwd()}", file=sys.stderr)
|
||||
c = p.pipenv(f"install {line}")
|
||||
assert c.return_code == 0
|
||||
assert "testpipenv" in p.pipfile["packages"]
|
||||
assert p.pipfile["packages"]["testpipenv"]["path"] == "."
|
||||
@@ -67,7 +65,7 @@ testpipenv = {path = ".", editable = true, extras = ["dev"]}
|
||||
@pytest.mark.install
|
||||
@pytest.mark.needs_internet
|
||||
@flaky
|
||||
class TestDirectDependencies(object):
|
||||
class TestDirectDependencies:
|
||||
"""Ensure dependency_links are parsed and installed.
|
||||
|
||||
This is needed for private repo dependencies.
|
||||
@@ -126,7 +124,7 @@ setup(
|
||||
def test_e_dot(PipenvInstance, pip_src_dir):
|
||||
with PipenvInstance() as p:
|
||||
path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
c = p.pipenv("install -e '{0}' --dev".format(path))
|
||||
c = p.pipenv(f"install -e '{path}' --dev")
|
||||
|
||||
assert c.return_code == 0
|
||||
|
||||
@@ -239,7 +237,7 @@ def test_local_package(PipenvInstance, pip_src_dir, testsroot):
|
||||
|
||||
with tarfile.open(copy_to, "r:gz") as tgz:
|
||||
tgz.extractall(path=p.path)
|
||||
c = p.pipenv("install -e {0}".format(package))
|
||||
c = p.pipenv(f"install -e {package}")
|
||||
assert c.return_code == 0
|
||||
assert all(
|
||||
pkg in p.lockfile["default"]
|
||||
@@ -259,7 +257,7 @@ def test_local_zipfiles(PipenvInstance, testsroot):
|
||||
# This tests for a bug when installing a zipfile in the current dir
|
||||
shutil.copy(source_path, os.path.join(p.path, file_name))
|
||||
|
||||
c = p.pipenv("install {}".format(file_name))
|
||||
c = p.pipenv(f"install {file_name}")
|
||||
assert c.return_code == 0
|
||||
key = [k for k in p.pipfile["packages"].keys()][0]
|
||||
dep = p.pipfile["packages"][key]
|
||||
@@ -286,7 +284,7 @@ def test_relative_paths(PipenvInstance, testsroot):
|
||||
mkdir_p(artifact_path)
|
||||
shutil.copy(source_path, os.path.join(artifact_path, file_name))
|
||||
# Test installing a relative path in a subdirectory
|
||||
c = p.pipenv("install {}/{}".format(artifact_dir, file_name))
|
||||
c = p.pipenv(f"install {artifact_dir}/{file_name}")
|
||||
assert c.return_code == 0
|
||||
key = next(k for k in p.pipfile["packages"].keys())
|
||||
dep = p.pipfile["packages"][key]
|
||||
@@ -306,7 +304,7 @@ def test_install_local_file_collision(PipenvInstance):
|
||||
fake_file = os.path.join(p.path, target_package)
|
||||
with open(fake_file, "w") as f:
|
||||
f.write("")
|
||||
c = p.pipenv("install {}".format(target_package))
|
||||
c = p.pipenv(f"install {target_package}")
|
||||
assert c.return_code == 0
|
||||
assert target_package in p.pipfile["packages"]
|
||||
assert p.pipfile["packages"][target_package] == "*"
|
||||
@@ -359,7 +357,7 @@ def test_multiple_editable_packages_should_not_race(PipenvInstance, testsroot):
|
||||
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
for pkg_name in pkgs:
|
||||
source_path = p._pipfile.get_fixture_path("git/{0}/".format(pkg_name)).as_posix()
|
||||
source_path = p._pipfile.get_fixture_path(f"git/{pkg_name}/").as_posix()
|
||||
shutil.copytree(source_path, pkg_name)
|
||||
|
||||
pipfile_string += '"{0}" = {{path = "./{0}", editable = true}}\n'.format(pkg_name)
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
@@ -389,13 +387,13 @@ six = {version = "*", index = "testpypi"}
|
||||
fake-package = "*"
|
||||
""".strip()
|
||||
f.write(contents)
|
||||
c = p.pipenv('install --pypi-mirror {0}'.format(mirror_url))
|
||||
c = p.pipenv(f'install --pypi-mirror {mirror_url}')
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv('lock -r --pypi-mirror {0}'.format(mirror_url))
|
||||
c = p.pipenv(f'lock -r --pypi-mirror {mirror_url}')
|
||||
assert c.return_code == 0
|
||||
assert '-i {0}'.format(mirror_url) in c.out.strip()
|
||||
assert f'-i {mirror_url}' in c.out.strip()
|
||||
assert '--extra-index-url https://test.pypi.org/simple' in c.out.strip()
|
||||
assert '--extra-index-url {}'.format(mirror_url) not in c.out.strip()
|
||||
assert f'--extra-index-url {mirror_url}' not in c.out.strip()
|
||||
|
||||
|
||||
@pytest.mark.lock
|
||||
@@ -650,7 +648,7 @@ requests = "*"
|
||||
@pytest.mark.install
|
||||
def test_lock_no_warnings(PipenvInstance):
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
os.environ["PYTHONWARNINGS"] = str("once")
|
||||
os.environ["PYTHONWARNINGS"] = "once"
|
||||
c = p.pipenv("install six")
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv('run python -c "import warnings; warnings.warn(\\"This is a warning\\", DeprecationWarning); print(\\"hello\\")"')
|
||||
@@ -675,7 +673,7 @@ def test_lock_missing_cache_entries_gets_all_hashes(PipenvInstance, tmpdir):
|
||||
p._pipfile.add("pathlib2", "*")
|
||||
assert "pathlib2" in p.pipfile["packages"]
|
||||
c = p.pipenv("install")
|
||||
assert c.return_code == 0, (c.err, ("\n".join(["{0}: {1}\n".format(k, v) for k, v in os.environ.items()])))
|
||||
assert c.return_code == 0, (c.err, ("\n".join([f"{k}: {v}\n" for k, v in os.environ.items()])))
|
||||
c = p.pipenv("lock --clear")
|
||||
assert c.return_code == 0, c.err
|
||||
assert "pathlib2" in p.lockfile["default"]
|
||||
@@ -692,7 +690,7 @@ def test_vcs_lock_respects_top_level_pins(PipenvInstance):
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
requests_uri = p._pipfile.get_fixture_path("git/requests").as_uri()
|
||||
p._pipfile.add("requests", {
|
||||
"editable": True, "git": "{0}".format(requests_uri),
|
||||
"editable": True, "git": f"{requests_uri}",
|
||||
"ref": "v2.18.4"
|
||||
})
|
||||
p._pipfile.add("urllib3", "==1.21.1")
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
"""Misc. tests that don't fit anywhere.
|
||||
|
||||
XXX: Try our best to reduce tests in this file.
|
||||
@@ -65,7 +63,7 @@ def test_update_locks(PipenvInstance):
|
||||
c = p.pipenv('install jdcal==1.3')
|
||||
assert c.return_code == 0
|
||||
assert p.lockfile['default']['jdcal']['version'] == '==1.3'
|
||||
with open(p.pipfile_path, 'r') as fh:
|
||||
with open(p.pipfile_path) as fh:
|
||||
pipfile_contents = fh.read()
|
||||
assert '==1.3' in pipfile_contents
|
||||
pipfile_contents = pipfile_contents.replace('==1.3', '*')
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding=utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import io
|
||||
import os
|
||||
import tarfile
|
||||
@@ -84,7 +82,7 @@ six = {{version = "*", index = "pypi"}}
|
||||
|
||||
@pytest.mark.install
|
||||
@pytest.mark.project
|
||||
@pytest.mark.parametrize('newlines', [u'\n', u'\r\n'])
|
||||
@pytest.mark.parametrize('newlines', ['\n', '\r\n'])
|
||||
def test_maintain_file_line_endings(PipenvInstance, newlines):
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
# Initial pipfile + lockfile generation
|
||||
@@ -93,15 +91,15 @@ def test_maintain_file_line_endings(PipenvInstance, newlines):
|
||||
|
||||
# Rewrite each file with parameterized newlines
|
||||
for fn in [p.pipfile_path, p.lockfile_path]:
|
||||
with io.open(fn) as f:
|
||||
with open(fn) as f:
|
||||
contents = f.read()
|
||||
written_newlines = f.newlines
|
||||
|
||||
assert written_newlines == u'\n', '{0!r} != {1!r} for {2}'.format(
|
||||
written_newlines, u'\n', fn,
|
||||
assert written_newlines == '\n', '{!r} != {!r} for {}'.format(
|
||||
written_newlines, '\n', fn,
|
||||
)
|
||||
# message because of https://github.com/pytest-dev/pytest/issues/3443
|
||||
with io.open(fn, 'w', newline=newlines) as f:
|
||||
with open(fn, 'w', newline=newlines) as f:
|
||||
f.write(contents)
|
||||
|
||||
# Run pipenv install to programatically rewrite
|
||||
@@ -110,10 +108,10 @@ def test_maintain_file_line_endings(PipenvInstance, newlines):
|
||||
|
||||
# Make sure we kept the right newlines
|
||||
for fn in [p.pipfile_path, p.lockfile_path]:
|
||||
with io.open(fn) as f:
|
||||
with open(fn) as f:
|
||||
f.read() # Consumes the content to detect newlines.
|
||||
actual_newlines = f.newlines
|
||||
assert actual_newlines == newlines, '{0!r} != {1!r} for {2}'.format(
|
||||
assert actual_newlines == newlines, '{!r} != {!r} for {}'.format(
|
||||
actual_newlines, newlines, fn,
|
||||
)
|
||||
# message because of https://github.com/pytest-dev/pytest/issues/3443
|
||||
@@ -161,7 +159,7 @@ def test_include_editable_packages(PipenvInstance, testsroot, pathlib_tmpdir):
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
with tarfile.open(source_path, "r:gz") as tarinfo:
|
||||
tarinfo.extractall(path=str(pathlib_tmpdir))
|
||||
c = p.pipenv('install -e {0}'.format(package.as_posix()))
|
||||
c = p.pipenv(f'install -e {package.as_posix()}')
|
||||
assert c.return_code == 0
|
||||
project = Project()
|
||||
assert "tablib" in [
|
||||
@@ -185,14 +183,14 @@ def test_run_in_virtualenv_with_global_context(PipenvInstance, virtualenv):
|
||||
project.virtualenv_location, virtualenv.as_posix()
|
||||
)
|
||||
c = delegator_run(
|
||||
"pipenv run pip install -i {} click".format(p.index_url),
|
||||
f"pipenv run pip install -i {p.index_url} click",
|
||||
cwd=os.path.abspath(p.path),
|
||||
env=os.environ.copy()
|
||||
)
|
||||
assert c.return_code == 0, (c.out, c.err)
|
||||
assert "Courtesy Notice" in c.err, (c.out, c.err)
|
||||
c = delegator_run(
|
||||
"pipenv install -i {} six".format(p.index_url),
|
||||
f"pipenv install -i {p.index_url} six",
|
||||
cwd=os.path.abspath(p.path), env=os.environ.copy()
|
||||
)
|
||||
assert c.return_code == 0, (c.out, c.err)
|
||||
@@ -243,4 +241,3 @@ pytest = "*"
|
||||
f.write(contents)
|
||||
c = p.pipenv('install --skip-lock')
|
||||
assert c.return_code == 0
|
||||
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import os
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import json
|
||||
import os
|
||||
|
||||
@@ -38,9 +36,9 @@ verify_ssl = true
|
||||
[packages]
|
||||
six = "*"
|
||||
""".strip())
|
||||
c = p.pipenv('lock --pypi-mirror {0}'.format(mirror_url))
|
||||
c = p.pipenv(f'lock --pypi-mirror {mirror_url}')
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv('sync --pypi-mirror {0}'.format(mirror_url))
|
||||
c = p.pipenv(f'sync --pypi-mirror {mirror_url}')
|
||||
assert c.return_code == 0
|
||||
|
||||
|
||||
@@ -112,4 +110,4 @@ requests = "*"
|
||||
|
||||
c = p.pipenv('sync --sequential --verbose')
|
||||
for package in p.lockfile['default']:
|
||||
assert 'Successfully installed {}'.format(package) in c.out
|
||||
assert f'Successfully installed {package}' in c.out
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import os
|
||||
import shutil
|
||||
|
||||
@@ -63,7 +61,7 @@ def test_mirror_uninstall(PipenvInstance):
|
||||
)
|
||||
assert "pypi.org" not in mirror_url
|
||||
|
||||
c = p.pipenv("install Django==1.11.13 --pypi-mirror {0}".format(mirror_url))
|
||||
c = p.pipenv(f"install Django==1.11.13 --pypi-mirror {mirror_url}")
|
||||
assert c.return_code == 0
|
||||
assert "django" in p.pipfile["packages"]
|
||||
assert "django" in p.lockfile["default"]
|
||||
@@ -77,7 +75,7 @@ def test_mirror_uninstall(PipenvInstance):
|
||||
c = p.pipenv("run python -m django --version")
|
||||
assert c.return_code == 0
|
||||
|
||||
c = p.pipenv("uninstall Django --pypi-mirror {0}".format(mirror_url))
|
||||
c = p.pipenv(f"uninstall Django --pypi-mirror {mirror_url}")
|
||||
assert c.return_code == 0
|
||||
assert "django" not in p.pipfile["dev-packages"]
|
||||
assert "django" not in p.lockfile["develop"]
|
||||
@@ -103,7 +101,7 @@ def test_uninstall_all_local_files(PipenvInstance, testsroot):
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
shutil.copy(source_path, os.path.join(p.path, file_name))
|
||||
os.mkdir(os.path.join(p.path, "tablib"))
|
||||
c = p.pipenv("install {}".format(file_name))
|
||||
c = p.pipenv(f"install {file_name}")
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv("uninstall --all")
|
||||
assert c.return_code == 0
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import os
|
||||
|
||||
import pytest
|
||||
@@ -50,7 +48,7 @@ def test_local_path_windows(PipenvInstance):
|
||||
except OSError:
|
||||
whl = whl.absolute()
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
c = p.pipenv('install "{0}"'.format(whl))
|
||||
c = p.pipenv(f'install "{whl}"')
|
||||
assert c.return_code == 0
|
||||
|
||||
|
||||
@@ -66,7 +64,7 @@ def test_local_path_windows_forward_slash(PipenvInstance):
|
||||
except OSError:
|
||||
whl = whl.absolute()
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
c = p.pipenv('install "{0}"'.format(whl.as_posix()))
|
||||
c = p.pipenv(f'install "{whl.as_posix()}"')
|
||||
assert c.return_code == 0
|
||||
|
||||
|
||||
@@ -75,7 +73,7 @@ def test_pipenv_clean_windows(PipenvInstance):
|
||||
with PipenvInstance(chdir=True) as p:
|
||||
c = p.pipenv('install requests')
|
||||
assert c.return_code == 0
|
||||
c = p.pipenv('run pip install -i {} click'.format(p.index_url))
|
||||
c = p.pipenv(f'run pip install -i {p.index_url} click')
|
||||
assert c.return_code == 0
|
||||
|
||||
c = p.pipenv('clean --dry-run')
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from __future__ import absolute_import, print_function
|
||||
import collections
|
||||
import contextlib
|
||||
import io
|
||||
@@ -42,11 +40,11 @@ def get_pypi_package_names():
|
||||
return pypi_packages
|
||||
|
||||
|
||||
class Package(object):
|
||||
class Package:
|
||||
"""Package represents a collection of releases from one or more directories"""
|
||||
|
||||
def __init__(self, name):
|
||||
super(Package, self).__init__()
|
||||
super().__init__()
|
||||
self.name = name
|
||||
self.releases = {}
|
||||
self._package_dirs = set()
|
||||
@@ -58,7 +56,7 @@ class Package(object):
|
||||
with open(os.path.join(path, 'api.json')) as f:
|
||||
return json.load(f)
|
||||
except FileNotFoundError:
|
||||
r = session.get('https://pypi.org/pypi/{0}/json'.format(self.name))
|
||||
r = session.get(f'https://pypi.org/pypi/{self.name}/json')
|
||||
response = r.json()
|
||||
releases = response["releases"]
|
||||
files = {
|
||||
@@ -75,12 +73,12 @@ class Package(object):
|
||||
else:
|
||||
del releases[release]
|
||||
response["releases"] = releases
|
||||
with io.open(os.path.join(path, "api.json"), "w") as fh:
|
||||
with open(os.path.join(path, "api.json"), "w") as fh:
|
||||
json.dump(response, fh, indent=4)
|
||||
return response
|
||||
|
||||
def __repr__(self):
|
||||
return "<Package name={0!r} releases={1!r}".format(self.name, len(self.releases))
|
||||
return f"<Package name={self.name!r} releases={len(self.releases)!r}"
|
||||
|
||||
def add_release(self, path_to_binary):
|
||||
path_to_binary = os.path.abspath(path_to_binary)
|
||||
@@ -100,17 +98,17 @@ class Package(object):
|
||||
self._package_dirs.add(ReleaseTuple(path, requires_python, hash_value))
|
||||
|
||||
|
||||
class Artifact(object):
|
||||
class Artifact:
|
||||
"""Represents an artifact for download"""
|
||||
|
||||
def __init__(self, name):
|
||||
super(Artifact, self).__init__()
|
||||
super().__init__()
|
||||
self.name = name
|
||||
self.files = {}
|
||||
self._artifact_dirs = set()
|
||||
|
||||
def __repr__(self):
|
||||
return "<Artifact name={0!r} files={1!r}".format(self.name, len(self.files))
|
||||
return f"<Artifact name={self.name!r} files={len(self.files)!r}"
|
||||
|
||||
def add_file(self, path):
|
||||
path = os.path.abspath(path)
|
||||
@@ -122,7 +120,7 @@ class Artifact(object):
|
||||
def prepare_fixtures(path):
|
||||
path = os.path.abspath(path)
|
||||
if not (os.path.exists(path) and os.path.isdir(path)):
|
||||
raise ValueError("{} is not a directory!".format(path))
|
||||
raise ValueError(f"{path} is not a directory!")
|
||||
for root, dirs, files in os.walk(path):
|
||||
package_name, _, _ = os.path.relpath(root, start=path).partition(os.path.sep)
|
||||
if package_name not in ARTIFACTS:
|
||||
@@ -144,7 +142,7 @@ def prepare_packages(path):
|
||||
"""Add packages in path to the registry."""
|
||||
path = os.path.abspath(path)
|
||||
if not (os.path.exists(path) and os.path.isdir(path)):
|
||||
raise ValueError("{} is not a directory!".format(path))
|
||||
raise ValueError(f"{path} is not a directory!")
|
||||
for root, dirs, files in os.walk(path):
|
||||
if all([setup_file in list(files) for setup_file in ("setup.py", "setup.cfg")]):
|
||||
continue
|
||||
@@ -185,7 +183,7 @@ def simple_package(package):
|
||||
return render_template('package.html', package=packages[package])
|
||||
else:
|
||||
try:
|
||||
r = requests.get("https://pypi.org/simple/{0}".format(package))
|
||||
r = requests.get(f"https://pypi.org/simple/{package}")
|
||||
r.raise_for_status()
|
||||
except Exception:
|
||||
abort(404)
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
from __future__ import absolute_import
|
||||
import pytest
|
||||
from .app import app as pypi_app
|
||||
from . import serve, certs
|
||||
|
||||
@@ -77,7 +77,7 @@ class SecureWSGIServer(WSGIServer):
|
||||
# Thanks, WSGIRequestHandler!!
|
||||
|
||||
|
||||
class Server(object):
|
||||
class Server:
|
||||
"""
|
||||
HTTP server running a WSGI application in its own thread.
|
||||
"""
|
||||
@@ -119,7 +119,7 @@ class Server(object):
|
||||
|
||||
@property
|
||||
def url(self):
|
||||
return '{0}://{1}:{2}'.format(self.protocol, self.host, self.port)
|
||||
return f'{self.protocol}://{self.host}:{self.port}'
|
||||
|
||||
def join(self, url, allow_fragments=True):
|
||||
return urljoin(self.url, url, allow_fragments=allow_fragments)
|
||||
@@ -130,5 +130,5 @@ class SecureServer(Server):
|
||||
|
||||
def __init__(self, host='127.0.0.1', port=0, application=None, **kwargs):
|
||||
kwargs['server_class'] = SecureWSGIServer
|
||||
super(SecureServer, self).__init__(host, port, application, **kwargs)
|
||||
super().__init__(host, port, application, **kwargs)
|
||||
self.protocol = 'https'
|
||||
|
||||
@@ -24,7 +24,7 @@ class UploadCommand(Command):
|
||||
@staticmethod
|
||||
def status(s):
|
||||
"""Prints things in bold."""
|
||||
print('\033[1m{0}\033[0m'.format(s))
|
||||
print(f'\033[1m{s}\033[0m')
|
||||
|
||||
def initialize_options(self):
|
||||
pass
|
||||
@@ -40,13 +40,13 @@ class UploadCommand(Command):
|
||||
pass
|
||||
|
||||
self.status('Building Source and Wheel (universal) distribution...')
|
||||
os.system('{0} setup.py sdist bdist_wheel --universal'.format(sys.executable))
|
||||
os.system(f'{sys.executable} setup.py sdist bdist_wheel --universal')
|
||||
|
||||
self.status('Uploading the package to PyPI via Twine...')
|
||||
os.system('twine upload dist/*')
|
||||
|
||||
self.status('Pushing git tags...')
|
||||
os.system('git tag v{0}'.format(__version__))
|
||||
os.system(f'git tag v{__version__}')
|
||||
os.system('git push --tags')
|
||||
|
||||
sys.exit()
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import os
|
||||
|
||||
import mock
|
||||
from unittest import mock
|
||||
import pytest
|
||||
|
||||
from pipenv._compat import TemporaryDirectory
|
||||
@@ -29,7 +29,7 @@ def test_load_dot_env_from_environment_variable_location(monkeypatch, capsys):
|
||||
dotenv_path = os.path.join(tempdir.name, 'test.env')
|
||||
key, val = 'SOME_KEY', 'some_value'
|
||||
with open(dotenv_path, 'w') as f:
|
||||
f.write('{}={}'.format(key, val))
|
||||
f.write(f'{key}={val}')
|
||||
|
||||
m.setenv("PIPENV_DOTENV_LOCATION", str(dotenv_path))
|
||||
m.setattr("pipenv.environments.PIPENV_DOTENV_LOCATION", str(dotenv_path))
|
||||
@@ -47,7 +47,7 @@ def test_doesnt_load_dot_env_if_disabled(monkeypatch, capsys):
|
||||
dotenv_path = os.path.join(tempdir.name, 'test.env')
|
||||
key, val = 'SOME_KEY', 'some_value'
|
||||
with open(dotenv_path, 'w') as f:
|
||||
f.write('{}={}'.format(key, val))
|
||||
f.write(f'{key}={val}')
|
||||
|
||||
m.setenv("PIPENV_DOTENV_LOCATION", str(dotenv_path))
|
||||
m.setattr("pipenv.environments.PIPENV_DOTENV_LOCATION", str(dotenv_path))
|
||||
|
||||
@@ -11,12 +11,12 @@ from pipenv.utils import temp_environ
|
||||
list(itertools.product(("ENABLE_SOMETHING",), ("FAKEPREFIX", None), (True, False))),
|
||||
)
|
||||
def test_get_from_env(arg, prefix, use_negation):
|
||||
negated_arg = "NO_{0}".format(arg)
|
||||
negated_arg = f"NO_{arg}"
|
||||
positive_var = arg
|
||||
negative_var = negated_arg
|
||||
if prefix:
|
||||
negative_var = "{0}_{1}".format(prefix, negative_var)
|
||||
positive_var = "{0}_{1}".format(prefix, positive_var)
|
||||
negative_var = f"{prefix}_{negative_var}"
|
||||
positive_var = f"{prefix}_{positive_var}"
|
||||
# set the positive first
|
||||
for var_to_set, opposite_var in ((arg, negated_arg), (negated_arg, arg)):
|
||||
os.environ.pop(var_to_set, None)
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
from __future__ import absolute_import
|
||||
|
||||
import pytest
|
||||
|
||||
from notpip._internal.index.package_finder import PackageFinder
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
import os
|
||||
|
||||
import pytest
|
||||
@@ -130,10 +129,10 @@ def test_convert_deps_to_pip_one_way(deps, expected):
|
||||
assert pipenv.utils.convert_deps_to_pip(deps, r=False) == [expected.lower()]
|
||||
|
||||
|
||||
@pytest.mark.skipif(isinstance(u"", str), reason="don't need to test if unicode is str")
|
||||
@pytest.mark.skipif(isinstance("", str), reason="don't need to test if unicode is str")
|
||||
@pytest.mark.utils
|
||||
def test_convert_deps_to_pip_unicode():
|
||||
deps = {u"django": u"==1.10"}
|
||||
deps = {"django": "==1.10"}
|
||||
deps = pipenv.utils.convert_deps_to_pip(deps, r=False)
|
||||
assert deps[0] == "django==1.10"
|
||||
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# We need to import the patched packages directly from sys.path, so the
|
||||
# identity checks can pass.
|
||||
import pipenv # noqa
|
||||
@@ -82,6 +81,6 @@ def test_token_date(dt, content):
|
||||
|
||||
|
||||
def test_dump_nonascii_string():
|
||||
content = u'name = "Stažené"\n'
|
||||
content = 'name = "Stažené"\n'
|
||||
toml_content = tomlkit.dumps(tomlkit.loads(content))
|
||||
assert toml_content == content
|
||||
|
||||
Reference in New Issue
Block a user