def select_version(versions_str, query, stable=False): if isinstance(query, str): query = query.split(",") query = [x.replace(" ", "") for x in query] stable = True if "-" in str(query): stable = False spec = Spec(*query) return spec.select(versions(versions_str, stable))
def main(): vs = [ "0.2.0", "0.1.6", "0.1.5", "0.1.4", "0.1.3", "0.1.2", "0.1.1", "0.1.0" ] s = Spec('>=0.1.3,<0.2.0') print('versions:', vs) print('rule:', s.specs, '\n') versions = [Version(v) for v in vs] filtered = [str(v) for v in s.filter(versions)] print('filtered:', filtered) print('selected:', s.select(versions))
def _select_pragma_version(pragma_string, version_list): comparator_set_range = pragma_string.replace(" ", "").split('||') comparator_regex = re.compile(r"(([<>]?=?|\^)\d+\.\d+\.\d+)+") version = None for comparator_set in comparator_set_range: spec = Spec(*(i[0] for i in comparator_regex.findall(comparator_set))) selected = spec.select(version_list) if selected and (not version or version < selected): version = selected if version: return str(version)
def find_version_by_spec(self, artifact): path = "/%s/%s" % (artifact.path(False), self.metadata_file_name) content = self._getContent( self.base + path, "Failed to retrieve the maven metadata file: " + path) xml = etree.fromstring(content) original_versions = xml.xpath( "/metadata/versioning/versions/version/text()") versions = [] for version in original_versions: try: versions.append(Version.coerce(version)) except ValueError: # This means that version string is not a valid semantic versioning pass parse_versions_syntax = { # example -> (,1.0] r"^\(,(?P<upper_bound>[0-9.]*)]$": "<={upper_bound}", # example -> 1.0 r"^(?P<version>[0-9.]*)$": "~={version}", # example -> [1.0] r"^\[(?P<version>[0-9.]*)\]$": "=={version}", # example -> [1.2, 1.3] r"^\[(?P<lower_bound>[0-9.]*),\s*(?P<upper_bound>[0-9.]*)\]$": ">={lower_bound},<={upper_bound}", # example -> [1.2, 1.3) r"^\[(?P<lower_bound>[0-9.]*),\s*(?P<upper_bound>[0-9.]+)\)$": ">={lower_bound},<{upper_bound}", # example -> [1.5,) r"^\[(?P<lower_bound>[0-9.]*),\)$": ">={lower_bound}", } for regex, spec_format in parse_versions_syntax.items(): regex_result = match(regex, artifact.version_by_spec) if regex_result: spec = Spec(spec_format.format(**regex_result.groupdict())) selected_version = spec.select(versions) if not selected_version: raise ValueError( "No version found with this spec version: {0}".format( artifact.version_by_spec)) # To deal when repos on maven don't have patch number on first build (e.g. 3.8 instead of 3.8.0) if str(selected_version) not in original_versions: selected_version.patch = None return str(selected_version) raise ValueError("The spec version {0} is not supported! ".format( artifact.version_by_spec))
def best_upgrade(current: Version, candidates: List[Version], track: str = 'MajorVersion'): if track == 'PatchLevel': spec = Spec('>{current},<{next_minor}'.format( current=str(current), next_minor=str(current.next_minor()))) elif track == 'MinorVersion': spec = Spec('>{current},<{next_minor}'.format( current=str(current), next_minor=str(current.next_major()))) elif track == 'MajorVersion': spec = Spec('>{current}'.format(current=str(current))) else: raise ValueError('unsupported "track": {track}'.format(track=track)) return spec.select(candidates)
def _fetch_latest_nextcloud(major: int, curver: Optional[Version]) -> Optional[Nextcloud]: versions = _get_nextcloud_versions() if curver is None: version = Spec(f'^{major}').select(versions.keys()) else: spec = Spec(f'<{curver.next_major()},>{_strip_build(curver)}') version = spec.select(versions.keys()) if version is None: return None url = versions[version] sha_response = download_pbar(url + '.sha256', desc='Fetching checksum for ' + url) sha256: str = sha_response.split(maxsplit=1)[0].decode() ziphash: Sha256 = _hash_zip(url, Sha256(sha256)) nc = Nextcloud(version, url, ziphash) return _update_with_real_version(nc)
def find_ide(version='>0.0.0', hint=None, interactive=True): print 'Searching for SC versions matching %s...' % version versions = find_sc_versions(hint=hint) try: version_spec = Spec(version) except ValueError: version_spec = Spec('==' + version) matches = list() for v in versions: semver = versions[v] if version_spec.match(semver): matches.append(v) if matches: best_match_ver = version_spec.select(map(lambda m: versions[m], matches)) for m in matches: if best_match_ver is versions[m]: best_match = m break if interactive and len(matches) > 1: best_num = -1 for i, match in enumerate(matches): print "[%s] %s (%s)" % (i, match, versions[match]) if match == best_match: best_num = i selection = None while not(selection): selection = raw_input("Which ide do you want to use for this project? [default: %s]: " % best_num) if not(selection): selection = best_num try: selection = int(selection) selected_path = matches[selection] return selected_path except Exception: selection = None pass else: return matches[0]
def iter_component_providers(self, comp, subs=False, vers=False, reqs="*"): """An iterater function to interate providers of a component Takes a conponent name and yeilds providers of the conponent if `subs` is `True` yeilds providers of subtypes too if `vers` is `True` yeilds all version of the provider not just the highest `reqs` is a version requirement for the providers to meet. Defaults to any version yeilds tuples that look like: `(<component_name>, <plugin_name>, <version>)` Examples: >>> for t in iter_component_providers("foo", subs=True): print(t); ("foo", "foo_plugin", "0.1.0") ("foo", "foo_plugin2", "1.0.0") ("foo.a", "foo.a_plugin", "0.1.0") ("foo.a.b", "footastic", "10.0.0") Args: comp (str): component name to use as a base subs (bool): should subtypes be yeilded too? vers (bool): should all version be yeilded not just the highest? reqs (str, list, tuple): version spec string or list there of all items are passed to a `Spec` Raises: TypeError: if `comp` or `reqs` are passed wrong """ if isinstance(reqs, basestring): reqs = (reqs,) if not isinstance(reqs, (list, tuple)): raise TypeError( "Invalid requierment type, must be string, list, or tuple: %r" % (reqs,)) if not isinstance(comp, basestring): raise TypeError( "comp is niether a Component instance nor a string: %r" % (comp,)) spec = Spec(*reqs) if subs: comps = self.component_map.keys() else: comps = (comp,) for com in comps: if com in self.component_map and issubcomponent(com, comp): providers = self.component_map[com] for prov in providers: versions = providers[prov] if vers: for ver in sorted(versions): yield (com, prov, ver) else: yield (com, prov, spec.select(versions))
def pick_version(versions, rule): spec = Spec(rule) vs = [Version(v) for v in versions] return str(spec.select(vs))