Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📄 README.md poetry-semver ============= This is a carbon-copy of the original, and now archived, poetry-semver package originally located at https://github.com/python-poetry/semver It functionality is still needed, so a drag and drop here was done to ensure portability.	261 B	2026-01-20 12:58
📄 __init__.py import re from .empty_constraint import EmptyConstraint from .patterns import ( BASIC_CONSTRAINT, CARET_CONSTRAINT, TILDE_CONSTRAINT, TILDE_PEP440_CONSTRAINT, X_CONSTRAINT, ) from .version import Version from .version_constraint import VersionConstraint from .version_range import VersionRange from .version_union import VersionUnion __version__ = "0.1.0" def parse_constraint(constraints): # type: (str) -> VersionConstraint if constraints == "": return VersionRange() or_constraints = re.split(r"\s\\|\\|?\s", constraints.strip()) or_groups = [] for constraints in or_constraints: and_constraints = re.split("(?<!^)(?<![=>< ,]) (?<!-)[, ](?!-) (?!,\|$)", constraints) constraint_objects = [] if len(and_constraints) > 1: for constraint in and_constraints: constraint_objects.append(parse_single_constraint(constraint)) else: constraint_objects.append(parse_single_constraint(and_constraints[0])) if len(constraint_objects) == 1: constraint = constraint_objects[0] else: constraint = constraint_objects[0] for next_constraint in constraint_objects[1:]: constraint = constraint.intersect(next_constraint) or_groups.append(constraint) if len(or_groups) == 1: return or_groups[0] else: return VersionUnion.of(or_groups) def parse_single_constraint(constraint): # type: (str) -> VersionConstraint m = re.match(r"(?i)^v?[xX](\.[xX])*$", constraint) if m: return VersionRange() # Tilde range m = TILDE_CONSTRAINT.match(constraint) if m: version = Version.parse(m.group(1)) high = version.stable.next_minor if len(m.group(1).split(".")) == 1: high = version.stable.next_major return VersionRange(version, high, include_min=True, always_include_max_prerelease=True) # PEP 440 Tilde range (~=) m = TILDE_PEP440_CONSTRAINT.match(constraint) if m: precision = 1 if m.group(3): precision += 1 if m.group(4): precision += 1 version = Version.parse(m.group(1)) if precision == 2: low = version high = version.stable.next_major else: low = Version(version.major, version.minor, version.patch) high = version.stable.next_minor return VersionRange(low, high, include_min=True, always_include_max_prerelease=True) # Caret range m = CARET_CONSTRAINT.match(constraint) if m: version = Version.parse(m.group(1)) return VersionRange( version, version.next_breaking, include_min=True, always_include_max_prerelease=True, ) # X Range m = X_CONSTRAINT.match(constraint) if m: op = m.group(1) major = int(m.group(2)) minor = m.group(3) if minor is not None: version = Version(major, int(minor), 0) result = VersionRange( version, version.next_minor, include_min=True, always_include_max_prerelease=True, ) else: if major == 0: result = VersionRange(max=Version(1, 0, 0)) else: version = Version(major, 0, 0) result = VersionRange( version, version.next_major, include_min=True, always_include_max_prerelease=True, ) if op == "!=": result = VersionRange().difference(result) return result # Basic comparator m = BASIC_CONSTRAINT.match(constraint) if m: op = m.group(1) version = m.group(2) if version == "dev": version = "0.0-dev" try: version = Version.parse(version) except ValueError: raise ValueError("Could not parse version constraint: {}".format(constraint)) if op == "<": return VersionRange(max=version) elif op == "<=": return VersionRange(max=version, include_max=True) elif op == ">": return VersionRange(min=version) elif op == ">=": return VersionRange(min=version, include_min=True) elif op == "!=": return VersionUnion(VersionRange(max=version), VersionRange(min=version)) else: return version raise ValueError("Could not parse version constraint: {}".format(constraint))	4.57 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 empty_constraint.py from .version_constraint import VersionConstraint class EmptyConstraint(VersionConstraint): def is_empty(self): return True def is_any(self): return False def allows(self, version): return False def allows_all(self, other): return other.is_empty() def allows_any(self, other): return False def intersect(self, other): return self def union(self, other): return other def difference(self, other): return self def __str__(self): return "<empty>"	562 B	2026-01-20 12:58
📄 exceptions.py class ParseVersionError(ValueError): pass	46 B	2026-01-20 12:58
📄 patterns.py import re MODIFIERS = ( "[._-]?" r"((?!post)(?:beta\|b\|c\|pre\|RC\|alpha\|a\|patch\|pl\|p\|dev)(?:(?:[.-]?\d+))?)?" r"([+-]?([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)))?" ) _COMPLETE_VERSION = r"v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?{}(?:\+[^\s]+)?".format(MODIFIERS) COMPLETE_VERSION = re.compile("(?i)" + _COMPLETE_VERSION) CARET_CONSTRAINT = re.compile(r"(?i)^\^({})$".format(_COMPLETE_VERSION)) TILDE_CONSTRAINT = re.compile("(?i)^~(?!=)({})$".format(_COMPLETE_VERSION)) TILDE_PEP440_CONSTRAINT = re.compile("(?i)^~=({})$".format(_COMPLETE_VERSION)) X_CONSTRAINT = re.compile(r"^(!=\|==)?\sv?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.[xX])+$") BASIC_CONSTRAINT = re.compile(r"(?i)^(<>\|!=\|>=?\|<=?\|==?)?\s*({}\|dev)".format(_COMPLETE_VERSION))	741 B	2026-01-20 12:58
📄 version.py import re from typing import List, Optional, Union from .empty_constraint import EmptyConstraint from .exceptions import ParseVersionError from .patterns import COMPLETE_VERSION from .version_constraint import VersionConstraint from .version_range import VersionRange from .version_union import VersionUnion class Version(VersionRange): """ A parsed semantic version number. """ def __init__( self, major, # type: int minor=None, # type: Optional[int] patch=None, # type: Optional[int] rest=None, # type: Optional[int] pre=None, # type: Optional[str] build=None, # type: Optional[str] text=None, # type: Optional[str] precision=None, # type: Optional[int] ): # type: (...) -> None self._major = int(major) self._precision = None if precision is None: self._precision = 1 if minor is None: minor = 0 else: if self._precision is not None: self._precision += 1 self._minor = int(minor) if patch is None: patch = 0 else: if self._precision is not None: self._precision += 1 if rest is None: rest = 0 else: if self._precision is not None: self._precision += 1 if precision is not None: self._precision = precision self._patch = int(patch) self._rest = int(rest) if text is None: parts = [str(major)] if self._precision >= 2 or minor != 0: parts.append(str(minor)) if self._precision >= 3 or patch != 0: parts.append(str(patch)) if self._precision >= 4 or rest != 0: parts.append(str(rest)) text = ".".join(parts) if pre: text += "-{}".format(pre) if build: text += "+{}".format(build) self._text = text pre = self._normalize_prerelease(pre) self._prerelease = [] if pre is not None: self._prerelease = self._split_parts(pre) build = self._normalize_build(build) self._build = [] if build is not None: if build.startswith(("-", "+")): build = build[1:] self._build = self._split_parts(build) @property def major(self): # type: () -> int return self._major @property def minor(self): # type: () -> int return self._minor @property def patch(self): # type: () -> int return self._patch @property def rest(self): # type: () -> int return self._rest @property def prerelease(self): # type: () -> List[str] return self._prerelease @property def build(self): # type: () -> List[str] return self._build @property def text(self): return self._text @property def precision(self): # type: () -> int return self._precision @property def stable(self): if not self.is_prerelease(): return self return self.next_patch @property def next_major(self): # type: () -> Version if self.is_prerelease() and self.minor == 0 and self.patch == 0: return Version(self.major, self.minor, self.patch) return self._increment_major() @property def next_minor(self): # type: () -> Version if self.is_prerelease() and self.patch == 0: return Version(self.major, self.minor, self.patch) return self._increment_minor() @property def next_patch(self): # type: () -> Version if self.is_prerelease(): return Version(self.major, self.minor, self.patch) return self._increment_patch() @property def next_breaking(self): # type: () -> Version if self.major == 0: if self.minor != 0: return self._increment_minor() if self._precision == 1: return self._increment_major() elif self._precision == 2: return self._increment_minor() return self._increment_patch() return self._increment_major() @property def first_prerelease(self): # type: () -> Version return Version.parse("{}.{}.{}-alpha.0".format(self.major, self.minor, self.patch)) @property def min(self): return self @property def max(self): return self @property def full_max(self): return self @property def include_min(self): return True @property def include_max(self): return True @classmethod def parse(cls, text): # type: (str) -> Version try: match = COMPLETE_VERSION.match(text) except TypeError: match = None if match is None: raise ParseVersionError('Unable to parse "{}".'.format(text)) text = text.rstrip(".") major = int(match.group(1)) minor = int(match.group(2)) if match.group(2) else None patch = int(match.group(3)) if match.group(3) else None rest = int(match.group(4)) if match.group(4) else None pre = match.group(5) build = match.group(6) if build: build = build.lstrip("+") return Version(major, minor, patch, rest, pre, build, text) def is_any(self): return False def is_empty(self): return False def is_prerelease(self): # type: () -> bool return len(self._prerelease) > 0 def allows(self, version): # type: (Version) -> bool return self == version def allows_all(self, other): # type: (VersionConstraint) -> bool return other.is_empty() or other == self def allows_any(self, other): # type: (VersionConstraint) -> bool return other.allows(self) def intersect(self, other): # type: (VersionConstraint) -> VersionConstraint if other.allows(self): return self return EmptyConstraint() def union(self, other): # type: (VersionConstraint) -> VersionConstraint from .version_range import VersionRange if other.allows(self): return other if isinstance(other, VersionRange): if other.min == self: return VersionRange( other.min, other.max, include_min=True, include_max=other.include_max, ) if other.max == self: return VersionRange( other.min, other.max, include_min=other.include_min, include_max=True, ) return VersionUnion.of(self, other) def difference(self, other): # type: (VersionConstraint) -> VersionConstraint if other.allows(self): return EmptyConstraint() return self def equals_without_prerelease(self, other): # type: (Version) -> bool return self.major == other.major and self.minor == other.minor and self.patch == other.patch def _increment_major(self): # type: () -> Version return Version(self.major + 1, 0, 0, precision=self._precision) def _increment_minor(self): # type: () -> Version return Version(self.major, self.minor + 1, 0, precision=self._precision) def _increment_patch(self): # type: () -> Version return Version(self.major, self.minor, self.patch + 1, precision=self._precision) def _normalize_prerelease(self, pre): # type: (str) -> str if not pre: return m = re.match(r"(?i)^(a\|alpha\|b\|beta\|c\|pre\|rc\|dev)[-.]?(\d+)?$", pre) if not m: return modifier = m.group(1) number = m.group(2) if number is None: number = 0 if modifier == "a": modifier = "alpha" elif modifier == "b": modifier = "beta" elif modifier in {"c", "pre"}: modifier = "rc" elif modifier == "dev": modifier = "alpha" return "{}.{}".format(modifier, number) def _normalize_build(self, build): # type: (str) -> str if not build: return if build.startswith("post"): build = build.lstrip("post") if not build: return return build def _split_parts(self, text): # type: (str) -> List[Union[str, int]] parts = text.split(".") for i, part in enumerate(parts): try: parts[i] = int(part) except (TypeError, ValueError): continue return parts def __lt__(self, other): return self._cmp(other) < 0 def __le__(self, other): return self._cmp(other) <= 0 def __gt__(self, other): return self._cmp(other) > 0 def __ge__(self, other): return self._cmp(other) >= 0 def _cmp(self, other): if not isinstance(other, VersionConstraint): return NotImplemented if not isinstance(other, Version): return -other._cmp(self) if self.major != other.major: return self._cmp_parts(self.major, other.major) if self.minor != other.minor: return self._cmp_parts(self.minor, other.minor) if self.patch != other.patch: return self._cmp_parts(self.patch, other.patch) if self.rest != other.rest: return self._cmp_parts(self.rest, other.rest) # Pre-releases always come before no pre-release string. if not self.is_prerelease() and other.is_prerelease(): return 1 if not other.is_prerelease() and self.is_prerelease(): return -1 comparison = self._cmp_lists(self.prerelease, other.prerelease) if comparison != 0: return comparison # Builds always come after no build string. if not self.build and other.build: return -1 if not other.build and self.build: return 1 return self._cmp_lists(self.build, other.build) def _cmp_parts(self, a, b): if a < b: return -1 elif a > b: return 1 return 0 def _cmp_lists(self, a, b): # type: (List, List) -> int for i in range(max(len(a), len(b))): a_part = None if i < len(a): a_part = a[i] b_part = None if i < len(b): b_part = b[i] if a_part == b_part: continue # Missing parts come after present ones. if a_part is None: return -1 if b_part is None: return 1 if isinstance(a_part, int): if isinstance(b_part, int): return self._cmp_parts(a_part, b_part) return -1 else: if isinstance(b_part, int): return 1 return self._cmp_parts(a_part, b_part) return 0 def __eq__(self, other): # type: (Version) -> bool if not isinstance(other, Version): return NotImplemented return ( self._major == other.major and self._minor == other.minor and self._patch == other.patch and self._rest == other.rest and self._prerelease == other.prerelease and self._build == other.build ) def __ne__(self, other): return not self == other def __str__(self): return self._text def __repr__(self): return "<Version {}>".format(str(self)) def __hash__(self): return hash( ( self.major, self.minor, self.patch, ".".join(str(p) for p in self.prerelease), ".".join(str(p) for p in self.build), ) )	11.91 KB	2026-01-20 12:58
📄 version_constraint.py import semver class VersionConstraint: def is_empty(self): # type: () -> bool raise NotImplementedError() def is_any(self): # type: () -> bool raise NotImplementedError() def allows(self, version): # type: (semver.Version) -> bool raise NotImplementedError() def allows_all(self, other): # type: (VersionConstraint) -> bool raise NotImplementedError() def allows_any(self, other): # type: (VersionConstraint) -> bool raise NotImplementedError() def intersect(self, other): # type: (VersionConstraint) -> VersionConstraint raise NotImplementedError() def union(self, other): # type: (VersionConstraint) -> VersionConstraint raise NotImplementedError() def difference(self, other): # type: (VersionConstraint) -> VersionConstraint raise NotImplementedError()	870 B	2026-01-20 12:58
📄 version_range.py from typing import List import semver from .empty_constraint import EmptyConstraint from .version_constraint import VersionConstraint from .version_union import VersionUnion class VersionRange(VersionConstraint): def __init__( self, min=None, max=None, include_min=False, include_max=False, always_include_max_prerelease=False, ): full_max = max if ( always_include_max_prerelease and not include_max and not full_max.is_prerelease() and not full_max.build and (min is None or not min.is_prerelease() or not min.equals_without_prerelease(full_max)) ): full_max = full_max.first_prerelease self._min = min self._max = max self._full_max = full_max self._include_min = include_min self._include_max = include_max @property def min(self): return self._min @property def max(self): return self._max @property def full_max(self): return self._full_max @property def include_min(self): return self._include_min @property def include_max(self): return self._include_max def is_empty(self): return False def is_any(self): return self._min is None and self._max is None def allows(self, other): # type: (semver.Version) -> bool if self._min is not None: if other < self._min: return False if not self._include_min and other == self._min: return False if self._max is not None: if other > self._max: return False if not self._include_max and other == self._max: return False return True def allows_all(self, other): # type: (VersionConstraint) -> bool from .version import Version if other.is_empty(): return True if isinstance(other, Version): return self.allows(other) if isinstance(other, VersionUnion): return all([self.allows_all(constraint) for constraint in other.ranges]) if isinstance(other, VersionRange): return not other.allows_lower(self) and not other.allows_higher(self) raise ValueError("Unknown VersionConstraint type {}.".format(other)) def allows_any(self, other): # type: (VersionConstraint) -> bool from .version import Version if other.is_empty(): return False if isinstance(other, Version): return self.allows(other) if isinstance(other, VersionUnion): return any([self.allows_any(constraint) for constraint in other.ranges]) if isinstance(other, VersionRange): return not other.is_strictly_lower(self) and not other.is_strictly_higher(self) raise ValueError("Unknown VersionConstraint type {}.".format(other)) def intersect(self, other): # type: (VersionConstraint) -> VersionConstraint from .version import Version if other.is_empty(): return other if isinstance(other, VersionUnion): return other.intersect(self) # A range and a Version just yields the version if it's in the range. if isinstance(other, Version): if self.allows(other): return other return EmptyConstraint() if not isinstance(other, VersionRange): raise ValueError("Unknown VersionConstraint type {}.".format(other)) if self.allows_lower(other): if self.is_strictly_lower(other): return EmptyConstraint() intersect_min = other.min intersect_include_min = other.include_min else: if other.is_strictly_lower(self): return EmptyConstraint() intersect_min = self._min intersect_include_min = self._include_min if self.allows_higher(other): intersect_max = other.max intersect_include_max = other.include_max else: intersect_max = self._max intersect_include_max = self._include_max if intersect_min is None and intersect_max is None: return VersionRange() # If the range is just a single version. if intersect_min == intersect_max: # Because we already verified that the lower range isn't strictly # lower, there must be some overlap. assert intersect_include_min and intersect_include_max return intersect_min # If we got here, there is an actual range. return VersionRange(intersect_min, intersect_max, intersect_include_min, intersect_include_max) def union(self, other): # type: (VersionConstraint) -> VersionConstraint from .version import Version if isinstance(other, Version): if self.allows(other): return self if other == self.min: return VersionRange(self.min, self.max, include_min=True, include_max=self.include_max) if other == self.max: return VersionRange(self.min, self.max, include_min=self.include_min, include_max=True) return VersionUnion.of(self, other) if isinstance(other, VersionRange): # If the two ranges don't overlap, we won't be able to create a single # VersionRange for both of them. edges_touch = (self.max == other.min and (self.include_max or other.include_min)) or ( self.min == other.max and (self.include_min or other.include_max) ) if not edges_touch and not self.allows_any(other): return VersionUnion.of(self, other) if self.allows_lower(other): union_min = self.min union_include_min = self.include_min else: union_min = other.min union_include_min = other.include_min if self.allows_higher(other): union_max = self.max union_include_max = self.include_max else: union_max = other.max union_include_max = other.include_max return VersionRange( union_min, union_max, include_min=union_include_min, include_max=union_include_max, ) return VersionUnion.of(self, other) def difference(self, other): # type: (VersionConstraint) -> VersionConstraint from .version import Version if other.is_empty(): return self if isinstance(other, Version): if not self.allows(other): return self if other == self.min: if not self.include_min: return self return VersionRange(self.min, self.max, False, self.include_max) if other == self.max: if not self.include_max: return self return VersionRange(self.min, self.max, self.include_min, False) return VersionUnion.of( VersionRange(self.min, other, self.include_min, False), VersionRange(other, self.max, False, self.include_max), ) elif isinstance(other, VersionRange): if not self.allows_any(other): return self if not self.allows_lower(other): before = None elif self.min == other.min: before = self.min else: before = VersionRange(self.min, other.min, self.include_min, not other.include_min) if not self.allows_higher(other): after = None elif self.max == other.max: after = self.max else: after = VersionRange(other.max, self.max, not other.include_max, self.include_max) if before is None and after is None: return EmptyConstraint() if before is None: return after if after is None: return before return VersionUnion.of(before, after) elif isinstance(other, VersionUnion): ranges = [] # type: List[VersionRange] current = self for range in other.ranges: # Skip any ranges that are strictly lower than [current]. if range.is_strictly_lower(current): continue # If we reach a range strictly higher than [current], no more ranges # will be relevant so we can bail early. if range.is_strictly_higher(current): break difference = current.difference(range) if difference.is_empty(): return EmptyConstraint() elif isinstance(difference, VersionUnion): # If [range] split [current] in half, we only need to continue # checking future ranges against the latter half. ranges.append(difference.ranges[0]) current = difference.ranges[-1] else: current = difference if not ranges: return current return VersionUnion.of((ranges + [current])) raise ValueError("Unknown VersionConstraint type {}.".format(other)) def allows_lower(self, other): # type: (VersionRange) -> bool if self.min is None: return other.min is not None if other.min is None: return False if self.min < other.min: return True if self.min > other.min: return False return self.include_min and not other.include_min def allows_higher(self, other): # type: (VersionRange) -> bool if self.max is None: return other.max is not None if other.max is None: return False if self.max < other.max: return False if self.max > other.max: return True return self.include_max and not other.include_max def is_strictly_lower(self, other): # type: (VersionRange) -> bool if self.max is None or other.min is None: return False if self.full_max < other.min: return True if self.full_max > other.min: return False return not self.include_max or not other.include_min def is_strictly_higher(self, other): # type: (VersionRange) -> bool return other.is_strictly_lower(self) def is_adjacent_to(self, other): # type: (VersionRange) -> bool if self.max != other.min: return False return self.include_max and not other.include_min or not self.include_max and other.include_min def __eq__(self, other): if not isinstance(other, VersionRange): return False return ( self._min == other.min and self._max == other.max and self._include_min == other.include_min and self._include_max == other.include_max ) def __lt__(self, other): return self._cmp(other) < 0 def __le__(self, other): return self._cmp(other) <= 0 def __gt__(self, other): return self._cmp(other) > 0 def __ge__(self, other): return self._cmp(other) >= 0 def _cmp(self, other): # type: (VersionRange) -> int if self.min is None: if other.min is None: return self._compare_max(other) return -1 elif other.min is None: return 1 result = self.min._cmp(other.min) if result != 0: return result if self.include_min != other.include_min: return -1 if self.include_min else 1 return self._compare_max(other) def _compare_max(self, other): # type: (VersionRange) -> int if self.max is None: if other.max is None: return 0 return 1 elif other.max is None: return -1 result = self.max._cmp(other.max) if result != 0: return result if self.include_max != other.include_max: return 1 if self.include_max else -1 return 0 def __str__(self): text = "" if self.min is not None: text += ">=" if self.include_min else ">" text += self.min.text if self.max is not None: if self.min is not None: text += "," text += "{}{}".format("<=" if self.include_max else "<", self.max.text) if self.min is None and self.max is None: return "" return text def __repr__(self): return "<VersionRange ({})>".format(str(self)) def __hash__(self): return hash((self.min, self.max, self.include_min, self.include_max))	12.87 KB	2026-01-20 12:58
📄 version_union.py from typing import List import semver from .empty_constraint import EmptyConstraint from .version_constraint import VersionConstraint class VersionUnion(VersionConstraint): """ A version constraint representing a union of multiple disjoint version ranges. An instance of this will only be created if the version can't be represented as a non-compound value. """ def __init__(self, ranges): self._ranges = list(ranges) @property def ranges(self): return self._ranges @classmethod def of(cls, ranges): from .version_range import VersionRange flattened = [] for constraint in ranges: if constraint.is_empty(): continue if isinstance(constraint, VersionUnion): flattened += constraint.ranges continue flattened.append(constraint) if not flattened: return EmptyConstraint() if any([constraint.is_any() for constraint in flattened]): return VersionRange() # Only allow Versions and VersionRanges here so we can more easily reason # about everything in flattened. _EmptyVersions and VersionUnions are # filtered out above. for constraint in flattened: if isinstance(constraint, VersionRange): continue raise ValueError("Unknown VersionConstraint type {}.".format(constraint)) flattened.sort() merged = [] for constraint in flattened: # Merge this constraint with the previous one, but only if they touch. if not merged or (not merged[-1].allows_any(constraint) and not merged[-1].is_adjacent_to(constraint)): merged.append(constraint) else: merged[-1] = merged[-1].union(constraint) if len(merged) == 1: return merged[0] return VersionUnion(merged) def is_empty(self): return False def is_any(self): return False def allows(self, version): # type: (semver.Version) -> bool return any([constraint.allows(version) for constraint in self._ranges]) def allows_all(self, other): # type: (VersionConstraint) -> bool our_ranges = iter(self._ranges) their_ranges = iter(self._ranges_for(other)) our_current_range = next(our_ranges, None) their_current_range = next(their_ranges, None) while our_current_range and their_current_range: if our_current_range.allows_all(their_current_range): their_current_range = next(their_ranges, None) else: our_current_range = next(our_ranges, None) return their_current_range is None def allows_any(self, other): # type: (VersionConstraint) -> bool our_ranges = iter(self._ranges) their_ranges = iter(self._ranges_for(other)) our_current_range = next(our_ranges, None) their_current_range = next(their_ranges, None) while our_current_range and their_current_range: if our_current_range.allows_any(their_current_range): return True if their_current_range.allows_higher(our_current_range): our_current_range = next(our_ranges, None) else: their_current_range = next(their_ranges, None) return False def intersect(self, other): # type: (VersionConstraint) -> VersionConstraint our_ranges = iter(self._ranges) their_ranges = iter(self._ranges_for(other)) new_ranges = [] our_current_range = next(our_ranges, None) their_current_range = next(their_ranges, None) while our_current_range and their_current_range: intersection = our_current_range.intersect(their_current_range) if not intersection.is_empty(): new_ranges.append(intersection) if their_current_range.allows_higher(our_current_range): our_current_range = next(our_ranges, None) else: their_current_range = next(their_ranges, None) return VersionUnion.of(new_ranges) def union(self, other): # type: (VersionConstraint) -> VersionConstraint return VersionUnion.of(self, other) def difference(self, other): # type: (VersionConstraint) -> VersionConstraint our_ranges = iter(self._ranges) their_ranges = iter(self._ranges_for(other)) new_ranges = [] state = { "current": next(our_ranges, None), "their_range": next(their_ranges, None), } def their_next_range(): state["their_range"] = next(their_ranges, None) if state["their_range"]: return True new_ranges.append(state["current"]) our_current = next(our_ranges, None) while our_current: new_ranges.append(our_current) our_current = next(our_ranges, None) return False def our_next_range(include_current=True): if include_current: new_ranges.append(state["current"]) our_current = next(our_ranges, None) if not our_current: return False state["current"] = our_current return True while True: if state["their_range"] is None: break if state["their_range"].is_strictly_lower(state["current"]): if not their_next_range(): break continue if state["their_range"].is_strictly_higher(state["current"]): if not our_next_range(): break continue difference = state["current"].difference(state["their_range"]) if isinstance(difference, VersionUnion): assert len(difference.ranges) == 2 new_ranges.append(difference.ranges[0]) state["current"] = difference.ranges[-1] if not their_next_range(): break elif difference.is_empty(): if not our_next_range(False): break else: state["current"] = difference if state["current"].allows_higher(state["their_range"]): if not their_next_range(): break else: if not our_next_range(): break if not new_ranges: return EmptyConstraint() if len(new_ranges) == 1: return new_ranges[0] return VersionUnion.of(*new_ranges) def _ranges_for(self, constraint): # type: (VersionConstraint) -> List[semver.VersionRange] from .version_range import VersionRange if constraint.is_empty(): return [] if isinstance(constraint, VersionUnion): return constraint.ranges if isinstance(constraint, VersionRange): return [constraint] raise ValueError("Unknown VersionConstraint type {}".format(constraint)) def _excludes_single_version(self): # type: () -> bool from .version import Version from .version_range import VersionRange return isinstance(VersionRange().difference(self), Version) def __eq__(self, other): if not isinstance(other, VersionUnion): return False return self._ranges == other.ranges def __str__(self): from .version_range import VersionRange if self._excludes_single_version(): return "!={}".format(VersionRange().difference(self)) return " \|\| ".join([str(r) for r in self._ranges]) def __repr__(self): return "<VersionUnion {}>".format(str(self))	7.75 KB	2026-01-20 12:58

Terminal