| """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 len(raw) == 1: |
| try: |
| count = int(raw[0]) |
| if count <= 0: |
| return [0] |
| return list(range(count)) |
| except ValueError: |
| pass |
|
|
| 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) |
|
|
