def all_candidates(self,
pkg_name,
extras=None,
build=None) -> Iterable[Candidate]:
pkg_name = normalize_name(pkg_name)
if pkg_name not in self.pkgs:
return []
candidates = []
for ver in self.pkgs[pkg_name].keys():
for p in self.compatible_builds(pkg_name, parse_ver(ver), build):
if 'sha256' not in p:
print(
f"Ignoring conda package {p['name']}:{p['version']} from provider {self.channel} \n"
"since it doesn't provide a sha256 sum.\n")
else:
if self.channel in ('free', 'intel', 'main', 'r'):
url = f"https://repo.anaconda.com/pkgs/{self.channel}/{p['subdir']}/{p['fname']}"
else:
url = f"https://anaconda.org/{self.channel}/{p['name']}/" \
f"{p['version']}/download/{p['subdir']}/{p['fname']}"
candidates.append(
Candidate(p['name'],
parse_ver(p['version']),
selected_extras=tuple(),
build=p['build'],
provider_info=ProviderInfo(
self, url=url, hash=p['sha256'])))
if 'collisions' in p:
print(
f"WARNING: Colliding conda package in channel '{self.channel}' "
f"Ignoring {list(map(itemgetter(0), p['collisions']))} "
f"from {list(map(itemgetter(1), p['collisions']))} "
f"in favor of {p['name']} from '{p['subdir']}'")
return candidates
def deviated_version(self, pkg_name, normalized_version: Version, build):
for raw_ver in self.data[normalize_name(pkg_name)].keys():
if parse_ver(raw_ver) == normalized_version:
return raw_ver
raise Exception(
f"Something went wrong while trying to find the deviated version for {pkg_name}:{normalized_version}"
)
def deviated_version(self, pkg_name, normalized_version: Version, build):
for builds in self.pkgs[pkg_name].values():
for p in builds.values():
if parse_ver(p['version']) == normalized_version:
return p['version']
raise Exception(
f"Cannot find deviated version for {pkg_name}:{normalized_version}"
)
def __init__(self, py_ver: PyVer, platform, system, *args, **kwargs):
self.context = context(py_ver, platform, system)
self.context_wheel = self.context.copy()
self.context_wheel['extra'] = None
self.py_ver = py_ver
self.py_ver_parsed = parse_ver(py_ver.python_full_version())
self.py_ver_digits = py_ver.digits()
self.platform = platform
self.system = system
def _suitable_wheels(self,
pkg_name: str,
ver: Version = None) -> Iterable[WheelRelease]:
wheels = self._all_releases(pkg_name)
if ver is not None:
wheels = filter(lambda w: parse_ver(w.ver) == ver, wheels)
return self._apply_filters([
self._wheel_type_ok,
self._python_requires_ok,
], wheels)
def all_candidates(self, pkg_name, extras, builds) -> Iterable[Candidate]:
if builds:
return []
return [Candidate(
pkg_name,
parse_ver(ver),
ver,
extras,
provider_info=ProviderInfo(self, data=pkg)
) for ver, pkg in self._get_candidates(pkg_name).items()]
def all_candidates(self, pkg_name, extras, builds) -> List[Candidate]:
if builds:
return []
return [Candidate(
w.name,
parse_ver(w.ver),
w.ver,
extras,
provider_info=ProviderInfo(provider=self, wheel_fname=w.fn, data=w)
) for w in self._suitable_wheels(pkg_name)]
def _python_requires_ok(self, wheel: WheelRelease):
if not wheel.requires_python:
return True
ver = parse_ver(str(self.py_ver))
try:
parsed_py_requires = list(
parse_reqs(f"python{wheel.requires_python}"))
return bool(filter_versions([ver], parsed_py_requires[0]))
except RequirementParseError:
print(
f"WARNING: `requires_python` attribute of wheel {wheel.name}:{wheel.ver} could not be parsed"
)
return False
def __init__(self, nixpkgs_json_file, **kwargs):
with open(nixpkgs_json_file) as f:
data = json.load(f)
self.data = {}
self.requirements = {}
for nix_key, nix_data in data.items():
if nix_data is None:
continue
pname = nix_data["pname"]
version = parse_ver(nix_data["version"])
pname_key = pname.replace("_", "-").lower()
if pname_key not in self.data:
self.data[pname_key] = {}
if version not in self.data[pname_key]:
self.data[pname_key][version] = []
self.data[pname_key][version].append(nix_key)
if nix_data["requirements"] is not None:
self.requirements[nix_key] = nix_data["requirements"]
super(NixpkgsIndex, self).__init__(self.data, **kwargs)
def filter_versions(versions: List[Version], req: Requirement):
"""
Reduces a given list of versions to contain only versions
which are allowed according to the given specifiers
"""
assert isinstance(versions, list)
versions = list(versions)
if not req.specs:
return versions
all_versions = []
for specs in req.specs:
for op, ver in specs:
if op == '==':
if str(ver) == "*":
return versions
elif '*' in str(ver):
op = '='
ver = parse_ver(ver)
versions = list(
filter(lambda v: ver_eval(v, f"{op}{ver}"), versions))
all_versions += list(versions)
return all_versions
def _get_candidates(self, name) -> dict:
"""
returns all candidates for the give name which are available for the current python version
"""
key = self.unify_key(name)
candidates = {}
try:
self.data[key]
except KeyError:
return {}
for ver, pyvers in self.data[key].items():
# in case pyvers is a string, it is a reference to another ver which we need to resolve
if isinstance(pyvers, str):
pyvers = self.data[key][pyvers]
# in case pyver is a string, it is a reference to another pyver which we need to resolve
if self.py_ver_digits in pyvers:
pyver = pyvers[self.py_ver_digits]
parsed_ver = parse_ver(ver)
if isinstance(pyver, str):
candidates[parsed_ver] = pyvers[pyver]
else:
candidates[parsed_ver] = pyvers[self.py_ver_digits]
return candidates
