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