Implementar um resolvedor de dependências de pacotes

Resposta: def resolve(requirements, package_index): """ Resolver versões de pacotes dadas as dependências iniciais e um índice de pacotes. requirements: lista de strings de requisitos como "A>=1.2.0" ou "B" package_index: dict de pacote -> { version_str: [strings de requisitos de dependência] } Retorna: dict mapeando pacote -> string de versão resolvida Lança ValueError em caso de conflito com explicação. """ import copy import re OPS = ["==", "!=", ">=", "<=", ">", "<"] def parse_version(v): # Analisa versão semântica em tupla de inteiros (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() # Encontrar operador, se 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 # Sem operador significa qualquer versão 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) onde op pode ser None return all(satisfies_one(ver_str, op, vreq) for (op, vreq) in constraints) # Construir dicionário inicial de restrições: pacote -> lista de (op, ver) constraints = {} def add_constraint(constraints_map, pkg, op, ver): if pkg not in constraints_map: constraints_map[pkg] = [] # Evitar restrições idênticas duplicadas if (op, ver) not in constraints_map[pkg]: constraints_map[pkg].append((op, ver)) # Inicializar a partir dos requisitos de topo for req in requirements: name, op, ver = parse_requirement(req) if name not in package_index: raise ValueError(f"Pacote '{name}' requerido, mas não encontrado no índice de pacotes") add_constraint(constraints, name, op, ver) # Helper para computar a lista de versões permitidas para um pacote sob suas restrições def allowed_versions(pkg, constraints_map): if pkg not in package_index: raise ValueError(f"Pacote '{pkg}' não encontrado no índice de pacotes") cons = constraints_map.get(pkg, []) versions = list(package_index[pkg].keys()) # Filtrar filtered = [v for v in versions if satisfies_all(v, cons)] # Ordenar em ordem decrescente por versão (mais recente primeiro) filtered.sort(key=version_cmp_key, reverse=True) return filtered # Busca por backtracking def search(resolved, constraints_map): # Se todo pacote com restrições estiver resolvido, terminamos to_resolve = [p for p in constraints_map.keys() if p not in resolved] if not to_resolve: return resolved # Escolher o pacote com menos candidatos para minimizar branching candidate_info = [] # lista de (pkg, candidatos) for pkg in to_resolve: try: cand = allowed_versions(pkg, constraints_map) except ValueError as e: # Pacote ausente raise if not cand: # Conflito: nenhuma versão satisfaz as restrições para este pacote # Construir string legível de restrições cons = constraints_map.get(pkg, []) cons_str = ", ".join([(op + v) if op else "any" for (op, v) in cons]) raise ValueError(f"Nenhuma versão do pacote '{pkg}' satisfaz as restrições: {cons_str}") candidate_info.append((pkg, cand)) # ordenar por número de candidatos ascendente candidate_info.sort(key=lambda x: len(x[1])) pkg, candidates = candidate_info[0] # Tentar cada candidato (já em ordem do mais recente primeiro) for ver in candidates: new_resolved = dict(resolved) new_resolved[pkg] = ver # Clonar restrições para o próximo nível new_constraints = copy.deepcopy(constraints_map) # Quando definimos pkg=ver, devemos garantir que as restrições existentes para pkg sejam satisfeitas if not satisfies_all(ver, new_constraints.get(pkg, [])): # Não deveria acontecer porque os candidatos foram filtrados, mas manter verificação continue # Adicionar suas dependências às restrições 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}' requer o pacote ausente '{dep_name}'" break add_constraint(new_constraints, dep_name, dep_op, dep_ver) # Se dep já estiver resolvido, garantir consistência 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"Conflito: {pkg}=={ver} requer {dep_req}, " f"o que é incompatível com o já resolvido {dep_name}=={assigned}") break if conflict: # tentar próximo candidato continue # Também é possível que adicionar essas restrições faça com que algum outro pacote não resolvido # não tenha candidatos; detectaremos isso quando a recursão tentar computar allowed_versions e lançar. try: result = search(new_resolved, new_constraints) return result except ValueError as e: # tentar próximo candidato last_err = e continue # Se todos os candidatos falharem, lançar conflito. Tentar fornecer mensagem informativa. # Construir descrição de restrição para pkg cons = constraints_map.get(pkg, []) cons_str = ", ".join([(op + v) if op else "any" for (op, v) in cons]) raise ValueError(f"Impossível resolver o pacote '{pkg}' com restrições: {cons_str}") # Iniciar busca resolved = {} result = search(resolved, constraints) return result # Exemplo de uso (descomente para executar um teste rápido): # 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!")