Implementar un resolvedor de dependencias de paquetes

def resolve(requirements, package_index): """ Resuelve las versiones de los paquetes dadas las dependencias iniciales y un índice de paquetes. requirements: lista de cadenas de requisitos como "A>=1.2.0" o "B" package_index: diccionario de paquete -> { version_str: [cadenas de requisitos de dependencia] } Devuelve: diccionario que mapea paquete -> cadena de versión resuelta Lanza ValueError en caso de conflicto con explicación. """ import copy import re OPS = ["==", "!=", ">=", "<=", ">", "<"] def parse_version(v): # Analiza la versión semántica en una tupla de enteros (mayor, menor, parche, ...) 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() # Busca el operador si está presente for op in OPS: if op in req: name, ver = req.split(op, 1) name = name.strip() ver = ver.strip() return name, op, ver # Sin operador significa cualquier versión 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: lista de (op, ver_str) donde op puede ser None return all(satisfies_one(ver_str, op, vreq) for (op, vreq) in constraints) # Construye el diccionario de restricciones inicial: paquete -> lista de (op, ver) constraints = {} def add_constraint(constraints_map, pkg, op, ver): if pkg not in constraints_map: constraints_map[pkg] = [] # Evita restricciones idénticas duplicadas if (op, ver) not in constraints_map[pkg]: constraints_map[pkg].append((op, ver)) # Inicializa desde los requisitos de nivel superior for req in requirements: name, op, ver = parse_requirement(req) if name not in package_index: raise ValueError(f"Paquete '{name}' requerido pero no encontrado en el índice de paquetes") add_constraint(constraints, name, op, ver) # Ayudante para calcular la lista de versiones permitidas para un paquete bajo sus restricciones def allowed_versions(pkg, constraints_map): if pkg not in package_index: raise ValueError(f"Paquete '{pkg}' no encontrado en el índice de paquetes") cons = constraints_map.get(pkg, []) versions = list(package_index[pkg].keys()) # Filtra filtered = [v for v in versions if satisfies_all(v, cons)] # Ordena descendente por versión (la más reciente primero) filtered.sort(key=version_cmp_key, reverse=True) return filtered # Búsqueda con retroceso (backtracking) def search(resolved, constraints_map): # Si cada paquete con restricciones está resuelto, hemos terminado to_resolve = [p for p in constraints_map.keys() if p not in resolved] if not to_resolve: return resolved # Elige el paquete con menos candidatos para minimizar la ramificación candidate_info = [] # lista de (paquete, candidatos) for pkg in to_resolve: try: cand = allowed_versions(pkg, constraints_map) except ValueError as e: # Paquete faltante raise if not cand: # Conflicto: ninguna versión satisface las restricciones para este paquete # Construye una cadena de restricción legible cons = constraints_map.get(pkg, []) cons_str = ", ".join([(op + v) if op else "any" for (op, v) in cons]) raise ValueError(f"Ninguna versión del paquete '{pkg}' satisface las restricciones: {cons_str}") candidate_info.append((pkg, cand)) # ordena por número de candidatos ascendente candidate_info.sort(key=lambda x: len(x[1])) pkg, candidates = candidate_info[0] # Prueba cada candidato (ya el más reciente primero) for ver in candidates: new_resolved = dict(resolved) new_resolved[pkg] = ver # Clona las restricciones para el siguiente nivel new_constraints = copy.deepcopy(constraints_map) # Al establecer pkg=ver, debemos asegurarnos de que las restricciones existentes para pkg se satisfagan if not satisfies_all(ver, new_constraints.get(pkg, [])): # No debería suceder ya que los candidatos fueron filtrados, pero mantenemos la comprobación continue # Agrega sus dependencias a las restricciones 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

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!")