Einen Paket-Abhängigkeitsauflöser implementieren

def resolve(requirements, package_index): """ Löst Paketversionen basierend auf anfänglichen Anforderungen und einem Paketindex. requirements: Liste von Anforderungs-Strings wie "A>=1.2.0" oder "B" package_index: dict von Paket -> { version_str: [Abhängigkeits-Anforderungs-Strings] } Gibt zurück: dict, das Paket -> aufgelöste Versions-String abbildet Wird ValueError bei Konflikt mit Erläuterung ausgelöst. """ import copy import re OPS = ["==", "!=", ">=", "<=", ">", "<"] def parse_version(v): # Zerlegt eine semantische Version in ein Tupel von Ganzzahlen (major, minor, patch, ...) parts = tuple(int(p) for p in v.split('.')) return parts def version_cmp_key(v): return parse_version(v) def parse_requirement(req): req = req.strip() # Operator finden, falls vorhanden for op in OPS: if op in req: name, ver = req.split(op, 1) name = name.strip() ver = ver.strip() return name, op, ver # Kein Operator bedeutet beliebige Version name = req return name.strip(), None, None def satisfies_one(ver_str, op, ver_req_str): if op is None: return True left = parse_version(ver_str) right = parse_version(ver_req_str) if op == '==': return left == right if op == '!=': return left != right if op == '>=': return left >= right if op == '<=': return left <= right if op == '>': return left > right if op == '<': return left < right return False def satisfies_all(ver_str, constraints): # constraints: Liste von (op, ver_str), wobei op None sein kann return all(satisfies_one(ver_str, op, vreq) for (op, vreq) in constraints) # Erzeuge anfängliches Constraints-Dict: package -> Liste von (op, ver) constraints = {} def add_constraint(constraints_map, pkg, op, ver): if pkg not in constraints_map: constraints_map[pkg] = [] # Vermeide doppelte identische Einschränkungen if (op, ver) not in constraints_map[pkg]: constraints_map[pkg].append((op, ver)) # Initialisiere aus Top-Level-Anforderungen for req in requirements: name, op, ver = parse_requirement(req) if name not in package_index: raise ValueError(f"Paket '{name}' erforderlich, aber nicht im Paketindex gefunden") add_constraint(constraints, name, op, ver) # Hilfsfunktion, um erlaubte Versionen einer Paket unter seinen Einschränkungen zu berechnen def allowed_versions(pkg, constraints_map): if pkg not in package_index: raise ValueError(f"Paket '{pkg}' nicht im Paketindex gefunden") cons = constraints_map.get(pkg, []) versions = list(package_index[pkg].keys()) # Filtern filtered = [v for v in versions if satisfies_all(v, cons)] # Absteigend nach Version sortieren (neueste zuerst) filtered.sort(key=version_cmp_key, reverse=True) return filtered # Backtracking-Suche def search(resolved, constraints_map): # Wenn jedes Paket mit Einschränkungen aufgelöst ist, sind wir fertig to_resolve = [p for p in constraints_map.keys() if p not in resolved] if not to_resolve: return resolved # Wähle das Paket mit den wenigsten Kandidaten, um Verzweigung zu minimieren candidate_info = [] # list of (pkg, candidates) for pkg in to_resolve: try: cand = allowed_versions(pkg, constraints_map) except ValueError as e: # Paket fehlt raise if not cand: # Konflikt: keine Version erfüllt die Einschränkungen für dieses Paket # Lesbaren Einschränkungs-String erstellen cons = constraints_map.get(pkg, []) cons_str = ", ".join([(op + v) if op else "any" for (op, v) in cons]) raise ValueError(f"Keine Versionen des Pakets '{pkg}' erfüllen die Einschränkungen: {cons_str}") candidate_info.append((pkg, cand)) # Nach Anzahl der Kandidaten aufsteigend sortieren candidate_info.sort(key=lambda x: len(x[1])) pkg, candidates = candidate_info[0] # Versuche jeden Kandidaten (bereits neueste zuerst) for ver in candidates: new_resolved = dict(resolved) new_resolved[pkg] = ver # Clone constraints for next level new_constraints = copy.deepcopy(constraints_map) # When we set pkg=ver, we must ensure existing constraints for pkg are satisfied if not satisfies_all(ver, new_constraints.get(pkg, [])): # Sollte nicht passieren, da Kandidaten gefiltert wurden, aber Prüfung behalten continue # Füge seine Abhängigkeiten zu den Einschränkungen hinzu deps = package_index[pkg].get(ver, []) conflict = False conflict_msg = None for dep_req in deps: dep_name, dep_op, dep_ver = parse_requirement(dep_req) if dep_name not in package_index: conflict = True conflict_msg = f"'{pkg}=={ver}' benötigt fehlendes Paket '{dep_name}'" break add_constraint(new_constraints, dep_name, dep_op, dep_ver) # Wenn dep bereits aufgelöst ist, Konsistenz sicherstellen if dep_name in new_resolved: assigned = new_resolved[dep_name] if not satisfies_all(assigned, new_constraints.get(dep_name, [])): conflict = True conflict_msg = (f"Konflikt: {pkg}=={ver} verlangt {dep_req}, " f"das mit bereits aufgelöstem {dep_name}=={assigned} unvereinbar ist") break if conflict: # nächsten Kandidaten versuchen continue # Außerdem ist es möglich, dass das Hinzufügen dieser Einschränkungen dazu führt, # dass ein anderes noch nicht aufgelöstes Paket keine Kandidaten mehr hat. # Das werden wir erkennen, wenn die Rekursion versucht, allowed_versions zu berechnen und entsprechend eine Ausnahme wirft. try: result = search(new_resolved, new_constraints) return result except ValueError as e: # nächsten Kandidaten versuchen last_err = e continue # Wenn alle Kandidaten fehlschlagen, Konflikt melden. Versuche eine aussagekräftige Meldung zu geben. # Einschränkungsbeschreibung für pkg erstellen cons = constraints_map.get(pkg, []) cons_str = ", ".join([(op + v) if op else "any" for (op, v) in cons]) raise ValueError(f"Kann Paket '{pkg}' mit Einschränkungen nicht auflösen: {cons_str}") # Suche starten resolved = {} result = search(resolved, constraints) return result # Beispielverwendung (auskommentieren, um Schnelltest auszuführen): # if __name__ == '__main__': # index = { # "A": { # "1.0.0": ["B<2.0.0"], # "1.1.0": ["B<3.0.0"], # "1.2.0": ["C==1.0.0"] # }, # "B": { # "1.5.0": [], # "2.5.0": [] # }, # "C": { # "1.0.0": ["B>=2.0.0"], # "1.1.0": [] # } # } # print(resolve(["A>=1.1.0"], index))

import re from functools import cmp_to_key def parse_requirement(req_str): """ Parse a requirement string like 'A>=1.2.0', 'B', 'C==1.0.0' Returns (name, operator, version) where operator and version may be None. """ req_str = req_str.strip() match = re.match(r'^([A-Za-z0-9_\-\.]+)\s*(==|!=|>=|<=|>|<)\s*([0-9][A-Za-z0-9\.\-]*)$', req_str) if match: return match.group(1), match.group(2), match.group(3) # No specifier match2 = re.match(r'^([A-Za-z0-9_\-\.]+)$', req_str) if match2: return match2.group(1), None, None raise ValueError(f"Cannot parse requirement: {req_str!r}") def parse_version(version_str): """Parse a version string into a tuple of integers for comparison.""" parts = [] for part in version_str.split('.'): try: parts.append(int(part)) except ValueError: parts.append(part) return tuple(parts) def version_satisfies(version_str, operator, constraint_version_str): """Check if version_str satisfies the constraint operator+constraint_version_str.""" if operator is None: return True v = parse_version(version_str) c = parse_version(constraint_version_str) if operator == '==': return v == c elif operator == '!=': return v != c elif operator == '>=': return v >= c elif operator == '<=': return v <= c elif operator == '>': return v > c elif operator == '<': return v < c return False def get_sorted_versions(package_name, package_index): """Return versions of a package sorted from latest to oldest.""" if package_name not in package_index: return [] versions = list(package_index[package_name].keys()) versions.sort(key=lambda v: parse_version(v), reverse=True) return versions def resolve(requirements, package_index): """ Resolve package dependencies. Args: requirements: List of requirement strings (e.g., ["A>=1.2.0", "B"]) package_index: Dict mapping package names to dicts of version->dependencies Returns: Dict mapping package names to resolved version strings. Raises: ValueError: If no valid resolution exists. """ # We'll use a backtracking approach. # State: a dict of {package_name: resolved_version} # We maintain a queue of requirements to process. def backtrack(resolved, pending_requirements, visited_states=None): """ resolved: dict of {pkg_name: version_str} - already resolved packages pending_requirements: list of (name, operator, version) tuples to satisfy Returns resolved dict or raises ValueError. """ if visited_states is None: visited_states = set() # Deduplicate and check pending requirements if not pending_requirements: return resolved # Take the first pending requirement name, op, ver = pending_requirements[0] rest = pending_requirements[1:] # Check if already resolved if name in resolved: # Verify the resolved version satisfies this constraint if version_satisfies(resolved[name], op, ver): return backtrack(resolved, rest, visited_states) else: # Conflict with already resolved version raise ValueError( f"Conflict: {name}=={resolved[name]} does not satisfy {name}{op or ''}{ver or ''}" ) # Package not yet resolved - try versions from latest to oldest if name not in package_index: raise ValueError(f"Package {name!r} not found in package index") sorted_versions = get_sorted_versions(name, package_index) # Filter versions that satisfy the current constraint candidate_versions = [ v for v in sorted_versions if version_satisfies(v, op, ver) ] if not candidate_versions: raise ValueError( f"No version of {name} satisfies constraint {name}{op or ''}{ver or ''}" ) # Also filter against all other pending requirements for the same package # Collect all constraints for this package from pending_requirements same_pkg_constraints = [(n2, o2, v2) for n2, o2, v2 in rest if n2 == name] # Filter candidates against all known constraints for this package filtered_candidates = [] for v in candidate_versions: if all(version_satisfies(v, o2, v2) for n2, o2, v2 in same_pkg_constraints): filtered_candidates.append(v) if not filtered_candidates: raise ValueError( f"No version of {name} satisfies all constraints: " f"{[(name + (o2 or '') + (v2 or '')) for _, o2, v2 in same_pkg_constraints + [(name, op, ver)]]}" ) # Remove same-package constraints from rest since we'll handle them now rest_without_same = [(n2, o2, v2) for n2, o2, v2 in rest if n2 != name] last_error = None for candidate in filtered_candidates: # Try this candidate version new_resolved = dict(resolved) new_resolved[name] = candidate # Get dependencies of this version deps = package_index[name][candidate] new_pending = [] for dep_str in deps: dep_name, dep_op, dep_ver = parse_requirement(dep_str) new_pending.append((dep_name, dep_op, dep_ver)) # Add remaining requirements new_pending.extend(rest_without_same) try: result = backtrack(new_resolved, new_pending, visited_states) return result except ValueError as e: last_error = e continue if last_error: raise ValueError( f"Could not resolve {name}: tried all candidates. Last error: {last_error}" ) raise ValueError(f"Could not resolve {name}: no candidates available") # Parse initial requirements parsed_reqs = [] for req_str in requirements: name, op, ver = parse_requirement(req_str) parsed_reqs.append((name, op, ver)) return backtrack({}, parsed_reqs) # Example usage and testing if __name__ == '__main__': package_index = { "A": { "1.0.0": ["B<2.0.0"], "1.1.0": ["B<3.0.0"], "1.2.0": ["C==1.0.0"] }, "B": { "1.5.0": [], "2.5.0": [] }, "C": { "1.0.0": ["B>=2.0.0"], "1.1.0": [] } } # Test 1: A>=1.1.0 should resolve to A=1.2.0, C=1.0.0, B=2.5.0 result = resolve(["A>=1.1.0"], package_index) print("Test 1:", result) assert result == {'A': '1.2.0', 'C': '1.0.0', 'B': '2.5.0'}, f"Expected A=1.2.0, C=1.0.0, B=2.5.0, got {result}" # Test 2: A==1.1.0 should resolve to A=1.1.0, B=2.5.0 (latest B < 3.0.0) result2 = resolve(["A==1.1.0"], package_index) print("Test 2:", result2) assert result2 == {'A': '1.1.0', 'B': '2.5.0'}, f"Expected A=1.1.0, B=2.5.0, got {result2}" # Test 3: Conflict - A==1.2.0 needs C==1.0.0 which needs B>=2.0.0, but also B<2.0.0 try: result3 = resolve(["A==1.2.0", "B<2.0.0"], package_index) print("Test 3 (should have failed):", result3) except ValueError as e: print("Test 3 (expected conflict):", e) print("All tests passed!")