"""File I/O utilities for solution generation.""" import os import re from pathlib import Path from typing import Dict, List, Tuple def load_env_file(env_path: Path) -> None: """Load simple KEY=VALUE pairs from a .env file into os.environ.""" if not env_path.is_file(): return for raw_line in env_path.read_text(encoding="utf-8").splitlines(): line = raw_line.strip() if not line or line.startswith("#"): continue if line.lower().startswith("export "): line = line[len("export "):].strip() if "=" not in line: continue key, value = line.split("=", 1) key = key.strip() value = value.strip().strip('"').strip("'") if key: os.environ[key] = value def load_solution_targets(path: Path) -> List[Tuple[str, str]]: """Load solution:problem pairs from a solutions file.""" if not path.is_file(): raise FileNotFoundError(f"Solutions file not found: {path}") targets: List[Tuple[str, str]] = [] seen: set[str] = set() for raw_line in path.read_text(encoding="utf-8").splitlines(): line = raw_line.strip() if not line or line.startswith("#"): continue if ":" not in line: raise ValueError(f"Invalid solutions file line (expected solution:problem): {line}") solution, problem = line.split(":", 1) solution = solution.strip() problem = problem.strip() if not solution or not problem: continue key = f"{solution}:{problem}" if key in seen: continue seen.add(key) targets.append((solution, problem)) if not targets: raise ValueError(f"No valid entries found in {path}") return targets def read_models_file(path: Path) -> List[str]: """Read model names from a newline-delimited file.""" models: List[str] = [] seen: set[str] = set() if not path.is_file(): return models for raw_line in path.read_text(encoding="utf-8").splitlines(): line = raw_line.strip() if not line or line.startswith("#"): continue if line not in seen: models.append(line) seen.add(line) return models def read_variant_indices_file(path: Path) -> List[int]: """Read variant indices from file. Format: - One integer per line (e.g., 0, 1, 2, 3, 4). 0 means no suffix. - Blank lines and lines starting with '#' are ignored. Backward compatibility: - If the file contains a single integer N, treat as variants [0..N-1]. """ if not path.is_file(): return [0] raw: List[str] = [] for raw_line in path.read_text(encoding="utf-8").splitlines(): line = raw_line.strip() if not line or line.startswith("#"): continue raw.append(line) if not raw: return [0] # If single integer -> expand to range if len(raw) == 1: try: count = int(raw[0]) if count <= 0: return [0] return list(range(count)) except ValueError: pass # fall through to per-line parsing seen: set[int] = set() indices: List[int] = [] for entry in raw: try: idx = int(entry) except ValueError as exc: raise ValueError(f"Invalid variant index in {path}: '{entry}'") from exc if idx < 0: raise ValueError(f"Variant indices must be >= 0, got {idx}") if idx not in seen: seen.add(idx) indices.append(idx) if not indices: return [0] return indices def read_readme(problem_path: Path) -> str: """Read the README file from a problem directory.""" for name in ["readme", "README.md", "README", "readme.md"]: readme = problem_path / name if readme.exists(): return readme.read_text(encoding='utf-8') raise FileNotFoundError(f"No README in {problem_path}") def load_docker_config(config_path: Path) -> Dict[str, Tuple[str, bool, bool]]: """ Load docker image configuration from docker_images.txt. Returns: Dict mapping problem_name -> (image, gpu_enabled, dind_enabled) """ if not config_path.exists(): return {} config = {} for line in config_path.read_text().splitlines(): line = line.strip() if not line or line.startswith("#"): continue if "=" not in line: continue problem_name, rest = line.split("=", 1) parts = rest.split(",") image = parts[0].strip() if parts else "" gpu_enabled = False dind_enabled = False for part in parts[1:]: part = part.strip().lower() if part in ("gpu", "true", "1"): gpu_enabled = True elif part in ("dind", "docker"): dind_enabled = True config[problem_name.strip()] = (image, gpu_enabled, dind_enabled) return config def write_problems_from_pairs(pairs_path: Path, target_path: Path) -> None: """Extract problem paths from a pairs file and write to a problems file.""" if not pairs_path.is_file(): return problems: List[str] = [] seen: set[str] = set() for raw_line in pairs_path.read_text(encoding="utf-8").splitlines(): stripped = raw_line.strip() if not stripped or stripped.startswith("#"): continue if ":" not in stripped: continue _, problem = stripped.split(":", 1) problem_clean = problem.strip() if not problem_clean: continue if not problem_clean.startswith("research/") and not problem_clean.startswith("./research/"): problem_clean = f"research/{problem_clean.lstrip('./')}" if problem_clean not in seen: seen.add(problem_clean) problems.append(problem_clean) if not problems: return target_path.write_text("\n".join(problems) + "\n", encoding="utf-8") def sanitize_model_suffix(model: str) -> str: """Sanitize model name for use as a filename suffix.""" return re.sub(r"[^a-zA-Z0-9]+", "_", model).strip("_") or "model" def get_problem_name(problem_path: Path) -> str: """ Extract the problem name from the problem path. Returns just the problem identifier without any model prefix. Examples: - research/vdb_pareto/balanced -> vdb_pareto_balanced - research/cant_be_late_multi/high_availability -> cant_be_late_multi_high_availability """ if problem_path.is_absolute(): try: problem_path = problem_path.relative_to(problem_path.anchor) except ValueError: pass parts = [p for p in problem_path.parts if p and p != "problems"] if not parts: raise ValueError(f"Unable to derive problem name from '{problem_path}'") return "_".join(parts)