def update_data(data_ext, data_rep, pkg):
"""Update the entry point data with current install state.
This update is IN PLACE for both data_ext and data_rep.
Uses 'pkg' as the main key for associating the data
with the relevant package.
"""
eps_ext = ilmd.entry_points().get("flake8.extension", {})
eps_rep = ilmd.entry_points().get("flake8.report", {})
try:
version = canonicalize_version(ilmd.version(pkg))
summary = ilmd.metadata(pkg).get("Summary")
except ilmd.PackageNotFoundError:
version = canonicalize_version("0.0")
summary = "[no summary]"
for data, eps in zip((data_ext, data_rep), (eps_ext, eps_rep)):
data.update(
{
pkg: {
"version": version,
"summary": summary,
"eps": {
ep.name: {
"module": (val := ep.value.partition(":"))[0],
"callable": val[2],
}
for ep in eps
},
}
}
)
def find_wheel_dirs(namelist: List[str], project: str, version: str) \
-> Tuple[str, Optional[str]]:
"""
Given a list ``namelist`` of files in a wheel for a project ``project`` and
version ``version``, find & return the name of the wheel's ``.dist-info``
directory and (if it has one) its ``.data`` directory.
:raises WheelValidationError: if there is no unique ``.dist-info``
directory in the input
:raises WheelValidationError: if the name & version of the ``.dist-info``
directory are not normalization-equivalent to ``project`` & ``version``
:raises WheelValidationError: if there is more than one ``.data`` directory
in the input
:raises WheelValidationError: if the name & version of the ``.data``
directory are not normalization-equivalent to ``project`` & ``version``
"""
canon_project = canonicalize_name(project)
canon_version = canonicalize_version(version.replace('_', '-'))
dist_info_dirs = set()
data_dirs = set()
for n in namelist:
basename = n.rstrip('/').split('/')[0]
if is_dist_info_dir(basename):
dist_info_dirs.add(basename)
if is_data_dir(basename):
data_dirs.add(basename)
if len(dist_info_dirs) > 1:
raise WheelValidationError(
'Wheel contains multiple .dist-info directories')
elif len(dist_info_dirs) == 1:
dist_info_dir = next(iter(dist_info_dirs))
diname, _, diversion = dist_info_dir[:-len(".dist-info")].partition(
'-')
if (canonicalize_name(diname) != canon_project or canonicalize_version(
diversion.replace('_', '-')) != canon_version):
raise WheelValidationError(
f"Project & version of wheel's .dist-info directory do not"
f" match wheel name: {dist_info_dir!r}")
else:
raise WheelValidationError('No .dist-info directory in wheel')
data_dir: Optional[str]
if len(data_dirs) > 1:
raise WheelValidationError('Wheel contains multiple .data directories')
elif len(data_dirs) == 1:
data_dir = next(iter(data_dirs))
daname, _, daversion = data_dir[:-len(".data")].partition('-')
if (canonicalize_name(daname) != canon_project or canonicalize_version(
daversion.replace('_', '-')) != canon_version):
raise WheelValidationError(
f"Project & version of wheel's .data directory do not match"
f" wheel name: {data_dir!r}")
else:
data_dir = None
return (dist_info_dir, data_dir)
def main(input, output, major, minor, patch, pre, local, canonicalize):
config = configparser.RawConfigParser()
config.read([".bump", "setup.cfg"])
major = major or config.getboolean("bump", "major", fallback=False)
minor = minor or config.getboolean("bump", "minor", fallback=False)
patch = patch or config.getboolean("bump", "patch", fallback=True)
input = input or click.File("rb")(config.get(
"bump", "input", fallback="setup.py"))
output = output or click.File("wb")(input.name)
canonicalize = canonicalize or config.get(
"bump", "canonicalize", fallback=False)
contents = input.read().decode("utf-8")
try:
version_string = find_version(contents)
except NoVersionFound:
click.echo("No version found in ./{}.".format(input.name))
sys.exit(1)
version = SemVer.parse(version_string)
version.bump(major, minor, patch, pre, local)
version_string = str(version)
if canonicalize:
version_string = canonicalize_version(version_string)
new = pattern.sub("\g<1>{}\g<3>".format(version_string), contents)
output.write(new.encode())
click.echo(version_string)
def main(input, output, major, minor, patch, pre, local, canonicalize):
config = configparser.RawConfigParser()
config.read(['.bump', 'setup.cfg'])
major = major or config.getboolean('bump', 'major', fallback=False)
minor = minor or config.getboolean('bump', 'minor', fallback=False)
patch = patch or config.getboolean('bump', 'patch', fallback=True)
input = (input or click.File('rb')(config.get(
'bump', 'input', fallback='setup.py')))
output = output or click.File('wb')(input.name)
canonicalize = (canonicalize
or config.get('bump', 'canonicalize', fallback=False))
contents = input.read().decode('utf-8')
try:
version_string = find_version(contents)
except NoVersionFound:
click.echo('No version found in ./{}.'.format(input.name))
sys.exit(1)
version = SemVer.parse(version_string)
version.bump(major, minor, patch, pre, local)
version_string = str(version)
if canonicalize:
version_string = canonicalize_version(version_string)
new = pattern.sub('\g<1>{}\g<3>'.format(version_string), contents)
output.write(new.encode())
click.echo(version_string)
def __init__(self, req_string, parent=None, index_url=None, env=None, extra_index_url=None):
log = self.log = logger.bind(dist=req_string)
log.info("init johnnydist", parent=parent and str(parent.req))
self.parent = parent
self.index_url = index_url
self.env = env
self.extra_index_url = extra_index_url
self._recursed = False
if req_string.endswith(".whl") and os.path.isfile(req_string):
whl = distlib.wheel.Wheel(req_string)
self.name = canonicalize_name(whl.name)
self.specifier = "==" + canonicalize_version(whl.version)
self.req = pkg_resources.Requirement.parse(self.name + self.specifier)
self.import_names = _discover_import_names(req_string)
self.metadata = _extract_metadata(req_string)
else:
self.req = pkg_resources.Requirement.parse(req_string)
self.name = canonicalize_name(self.req.name)
self.specifier = str(self.req.specifier)
log.debug("fetching best wheel")
self.import_names, self.metadata = _get_info(
dist_name=req_string,
index_url=index_url,
env=env,
extra_index_url=extra_index_url,
)
self.extras_requested = sorted(self.req.extras)
if parent is None:
if env:
log.debug("root node target env", **dict(env))
self.required_by = []
else:
self.required_by = [str(parent.req)]
def get_pkg_pypi_version(pkg):
req = rq.get(f"https://pypi.org/pypi/{pkg}/json")
print(f"Retrieving '{pkg}' version...", end="")
ver = canonicalize_version(req.json()["info"]["version"])
print("OK.")
return ver
def upgrade():
connection = op.get_bind()
version_query = sa.select([releases.c.version]).distinct()
for release in connection.execute(version_query):
connection.execute(releases.update().where(
sa.and_(
releases.c.version == release.version,
releases.c.canonical_version.is_(None),
)).values(canonical_version=canonicalize_version(release.version)))
op.alter_column("releases", "canonical_version", nullable=False)
def _get_pypi_version(special_version, release_dict):
"""
Loop over the pypi release dictionary looking for an equivalent version string. Return the alternative version
if found, otherwise return None.
:param special_version: The version string that failed to match against the Pypi versions.
:param release_dict: Pypi's releases dictionary for a given module.
:return: The matching version string or None if it not matched.
"""
for release in release_dict:
pypi_version = canonicalize_version(release)
if special_version == pypi_version or special_version == release:
return release
return None
def find_dist_info_dir(
namelist: List[str], project: str, version: str
) -> Tuple[str, Optional[str]]:
"""
Given a list ``namelist`` of files in a wheel for a project ``project`` and
version ``version``, find & return the name of the wheel's ``.dist-info``
directory.
:raises DistInfoError: if there is no unique ``.dist-info`` directory in
the input
:raises DistInfoError: if the name & version of the ``.dist-info``
directory are not normalization-equivalent to ``project`` & ``version``
"""
canon_project = canonicalize_name(project)
canon_version = canonicalize_version(version.replace("_", "-"))
dist_info_dirs = set()
for n in namelist:
basename = n.rstrip("/").split("/")[0]
if is_dist_info_dir(basename):
dist_info_dirs.add(basename)
if len(dist_info_dirs) > 1:
raise DistInfoError("Wheel contains multiple .dist-info directories")
elif len(dist_info_dirs) == 1:
dist_info_dir = next(iter(dist_info_dirs))
diname, _, diversion = dist_info_dir[: -len(".dist-info")].partition("-")
if (
canonicalize_name(diname) != canon_project
or canonicalize_version(diversion.replace("_", "-")) != canon_version
):
raise DistInfoError(
f"Project & version of wheel's .dist-info directory do not"
f" match wheel name: {dist_info_dir!r}"
)
return dist_info_dir
else:
raise DistInfoError("No .dist-info directory in wheel")
def upgrade():
connection = op.get_bind()
version_query = sa.select([releases.c.version]).distinct()
for release in connection.execute(version_query):
connection.execute(
releases.update()
.where(
sa.and_(
releases.c.version == release.version,
releases.c.canonical_version.is_(None),
)
)
.values(canonical_version=canonicalize_version(release.version))
)
op.alter_column("releases", "canonical_version", nullable=False)
def __init__(self, req_string, parent=None, index_url=None, env=None, extra_index_url=None):
self.dist_path = None
if req_string.endswith(".whl") and os.path.isfile(req_string):
self.dist_path = req_string
whl = WheelFile(req_string)
whl_name_info = whl.parsed_filename.groupdict()
self.name = canonicalize_name(whl_name_info["name"])
self.specifier = "==" + canonicalize_version(whl_name_info["ver"])
self.req = pkg_resources.Requirement.parse(self.name + self.specifier)
else:
self.req = pkg_resources.Requirement.parse(req_string)
self.name = canonicalize_name(self.req.name)
self.specifier = str(self.req.specifier)
self.extras_requested = sorted(self.req.extras)
log = self.log = logger.bind(dist=str(self.req))
log.info("init johnnydist", parent=parent and str(parent.req))
if parent is not None:
self.index_url = parent.index_url
self.extra_index_url = parent.extra_index_url
self.required_by = [str(parent.req)]
self.env = parent.env
self.env_data = parent.env_data
else:
self.index_url = index_url
self.extra_index_url = extra_index_url
self.required_by = []
self.env = env
if self.env is None:
self.env_data = default_environment()
else:
self.env_data = dict(self.env)
log.debug("target env", **self.env_data)
if self.dist_path is None:
log.debug("fetching best wheel")
with wimpy.working_directory(self.tmp()):
data = pipper.get(
req_string,
index_url=self.index_url,
env=self.env,
extra_index_url=self.extra_index_url,
)
self.dist_path = data["path"]
self.parent = parent
self._recursed = False
def test_canonicalize_version(version, expected):
assert canonicalize_version(version) == expected
def __init__(self,
req_string,
parent=None,
index_url=None,
env=None,
extra_index_url=None):
self.dist_path = None
if req_string.endswith(".whl") and os.path.isfile(req_string):
self.dist_path = req_string
whl = WheelFile(req_string)
whl_name_info = whl.parsed_filename.groupdict()
self.name = canonicalize_name(whl_name_info["name"])
self.specifier = "==" + canonicalize_version(whl_name_info["ver"])
self.req = pkg_resources.Requirement.parse(self.name +
self.specifier)
else:
self.req = pkg_resources.Requirement.parse(req_string)
self.name = canonicalize_name(self.req.name)
self.specifier = str(self.req.specifier)
self.extras_requested = sorted(self.req.extras)
log = self.log = logger.bind(dist=str(self.req))
log.info("init johnnydist", parent=parent and str(parent.req))
if parent is not None:
self.index_url = parent.index_url
self.extra_index_url = parent.extra_index_url
self.required_by = [str(parent.req)]
self.env = parent.env
self.env_data = parent.env_data
else:
self.index_url = index_url
self.extra_index_url = extra_index_url
self.required_by = []
self.env = env
if self.env is None:
self.env_data = default_environment()
else:
self.env_data = dict(self.env)
log.debug("target env", **self.env_data)
if self.dist_path is None:
log.debug("fetching best wheel")
tmpdir = tempfile.mkdtemp()
log.debug("created scratch", tmpdir=tmpdir)
try:
with wimpy.working_directory(tmpdir):
data = pipper.get(
req_string,
index_url=self.index_url,
env=self.env,
extra_index_url=self.extra_index_url,
tmpdir=tmpdir,
)
self.dist_path = data["path"]
# triggers retrieval of any info we need from downloaded dist
self.import_names
self.metadata
finally:
log.debug("removing scratch", tmpdir=tmpdir)
shutil.rmtree(tmpdir)
self.parent = parent
self._recursed = False
def get_or_default_pkg_version(pkg):
try:
return get_pkg_pypi_version(pkg)
except Exception:
print("Not found, using dummy v0.0")
return canonicalize_version("0.0")
pass
except Exception as e:
sys.exit(e)
if backend is not None:
try:
for requirement in backend.get_requires_for_build_wheel():
add_requirement(requirement)
except Exception as e:
sys.exit(e)
for requirement in requirements:
name = canonicalize_name(requirement.name)
together = []
for specifier in requirement.specifier:
version = canonicalize_version(specifier.version)
if specifier.operator == "!=":
together.append(
f"(python3dist({name}) < {version} or python3dist({name}) >= {version}.0)"
)
else:
together.append(
f"python3dist({name}) {specifier.operator} {version}")
if len(together) == 0:
rpm_requirements.add(f"python3dist({name})")
if len(together) == 1:
rpm_requirements.add(together[0])
elif len(together) > 1:
rpm_requirements.add(f"({' and '.join(together)})")
# Will need pip to build and install the wheel
is_installed = False
# Query the Web for the needed version
request = ".".join(version.base_version.split(".")[0:1])
url = "https://chromedriver.storage.googleapis.com/LATEST_RELEASE_{}".format(
request
)
response = requests.get(url)
if response.status_code != 200:
raise RuntimeError(
"Error getting chrome driver version {}".format(response.status_code)
)
needed_version = parse_version(response.text)
if is_installed and (
canonicalize_version(str(needed_version))
== canonicalize_version(str(current_version))
):
print("The version currently installed is correct.")
else:
# Remove the current version
subprocess.check_call(
[sys.executable, "-m", "pip", "uninstall", "-y", "chromedriver-binary"]
)
is_installed = False
if not is_installed:
# Remove the current version
subprocess.check_call(
[
sys.executable,
def test_canonicalize_version(version, expected):
assert canonicalize_version(version) == expected
def test_canonicalize_version_no_strip_trailing_zero(version):
assert canonicalize_version(version, strip_trailing_zero=False) == version
def canonicalize_package_version(version: str) -> str:
"""Return the normalized form of the version."""
return str(canonicalize_version(version))
