use std::path::PathBuf;
use clap::Parser;
use gras::engine::config::{LogLevel, RaceConfigBuilder};
fn parse_log_level(raw: &str) -> Result<LogLevel, String> {
LogLevel::parse(raw).ok_or_else(|| {
format!("unknown log level \"{raw}\" — expected one of: none, summ, minimal")
})
}
#[derive(Parser, Debug, Clone, Default)]
pub struct EngineArgs {
#[arg(long, value_name = "N")]
pub pop: Option<usize>,
#[arg(long, value_name = "N")]
pub max_steps: Option<usize>,
#[arg(long, value_name = "U64")]
pub seed: Option<u64>,
#[arg(long, value_name = "N")]
pub elite_count: Option<usize>,
#[arg(long, value_name = "N")]
pub checkpoint_every: Option<usize>,
#[arg(long, value_name = "P")]
pub crossover_prob: Option<f32>,
#[arg(long, value_name = "P")]
pub mutate_prob: Option<f32>,
#[arg(long, value_name = "N")]
pub crossover_rolls: Option<usize>,
#[arg(long, value_name = "N")]
pub mutate_rolls: Option<usize>,
#[arg(long, value_name = "LEVEL", value_parser = parse_log_level)]
pub log_level: Option<LogLevel>,
#[arg(long, value_name = "NAME")]
pub run_name: Option<String>,
#[arg(long, value_name = "DIR")]
pub run_dir: Option<PathBuf>,
#[arg(long)]
pub no_pruner: bool,
#[arg(long, value_name = "N")]
pub pruner_steps: Option<usize>,
#[arg(long, value_name = "MODE")]
pub crossover_gate: Option<String>,
#[arg(long, value_name = "POLICY")]
pub crossover_cull_policy: Option<String>,
#[arg(long, value_name = "POLICY")]
pub mutation_cull_policy: Option<String>,
#[arg(long, value_name = "N")]
pub grace_periods: Option<usize>,
#[arg(long, value_name = "N")]
pub crossover_retries: Option<usize>,
#[arg(long, value_name = "METHOD")]
pub pruner_method: Option<String>,
#[arg(long)]
pub worst_save: bool,
#[arg(long)]
pub no_elite_save: bool,
#[arg(long = "no-freeze-elites", action = clap::ArgAction::SetFalse)]
pub freeze_elites: bool,
#[arg(long, value_name = "N", default_value_t = 10)]
pub holdout_matches: usize,
#[arg(long, value_name = "MODE")]
pub history_flush: Option<String>,
}
#[derive(Parser, Debug, Clone, Default)]
pub struct RlEngineArgs {
#[command(flatten)]
pub engine: EngineArgs,
#[arg(long)]
pub fresh_immigrants: bool,
}
impl std::ops::Deref for RlEngineArgs {
type Target = EngineArgs;
fn deref(&self) -> &EngineArgs {
&self.engine
}
}
#[allow(dead_code)]
impl RlEngineArgs {
pub fn apply(&self, b: RaceConfigBuilder) -> RaceConfigBuilder {
let b = self.engine.apply(b);
if self.fresh_immigrants {
b.set_mutation_catch_up(true)
} else {
b
}
}
pub fn seed_or(&self, default: Option<u64>) -> Option<u64> {
self.engine.seed_or(default)
}
pub fn run_dir_or(&self, default: Option<PathBuf>) -> Option<PathBuf> {
self.engine.run_dir_or(default)
}
pub fn init_logger(&self, default_level: LogLevel) -> bool {
self.engine.init_logger(default_level)
}
}
impl EngineArgs {
pub fn apply(&self, mut b: RaceConfigBuilder) -> RaceConfigBuilder {
if let Some(pop) = self.pop {
b = b.set_run_pop_size(pop);
}
if let Some(steps) = self.max_steps {
b = b.set_stop_max_steps(steps);
}
if let Some(k) = self.elite_count {
b = b.set_elite_count(k);
}
if let Some(n) = self.checkpoint_every {
b = b.set_run_checkpoint_every(n);
}
if let Some(p) = self.crossover_prob {
b = b.set_crossover_prob(p);
}
if let Some(p) = self.mutate_prob {
b = b.set_mutate_prob(p);
}
if let Some(n) = self.crossover_rolls {
b = b.set_crossover_rolls(n);
}
if let Some(n) = self.mutate_rolls {
b = b.set_mutate_rolls(n);
}
if let Some(level) = self.log_level {
b = b.set_run_log_level(level);
}
if let Some(name) = &self.run_name {
b = b.set_run_name(name.clone());
}
if self.no_pruner {
b = b.set_pruner_enabled(false);
}
if let Some(steps) = self.pruner_steps {
b = b.set_pruner_steps(steps);
}
b = b.set_elite_freeze(self.freeze_elites);
if let Some(mode) = &self.crossover_gate {
b = b.set_crossover_gate(match mode.trim().to_ascii_lowercase().as_str() {
"hard" => gras::engine::config::CrossoverGate::Hard,
"soft" => gras::engine::config::CrossoverGate::Soft,
other => {
eprintln!("--crossover-gate {other}: expected `hard` or `soft`");
std::process::exit(2);
}
});
}
if let Some(policy) = &self.crossover_cull_policy {
b = b.set_crossover_cull_policy(match policy.trim().to_ascii_lowercase().as_str() {
"worst" => gras::engine::config::CrossCullPolicy::Worst,
"random" => gras::engine::config::CrossCullPolicy::Random,
other => {
eprintln!("--crossover-cull-policy {other}: expected `worst` or `random`");
std::process::exit(2);
}
});
}
if let Some(policy) = &self.mutation_cull_policy {
b = b.set_mutation_cull_policy(match policy.trim().to_ascii_lowercase().as_str() {
"inverse" | "inverse-fitness" => {
gras::engine::config::MutationCullPolicy::InverseFitness
}
"worst" => gras::engine::config::MutationCullPolicy::Worst,
"random" => gras::engine::config::MutationCullPolicy::Random,
other => {
eprintln!(
"--mutation-cull-policy {other}: expected `inverse`, `worst`, or `random`"
);
std::process::exit(2);
}
});
}
if let Some(n) = self.crossover_retries {
b = b.set_crossover_retries(n);
}
if let Some(method) = &self.pruner_method {
b = b.set_pruner_method(match method.trim().to_ascii_lowercase().as_str() {
"hard" => gras::engine::config::PopPrunerMethod::Hard,
other => {
eprintln!("--pruner-method {other}: expected `hard`");
std::process::exit(2);
}
});
}
if self.worst_save {
b = b
.set_worst_save_topology(true)
.set_worst_save_safetensors(true);
}
if self.no_elite_save {
b = b
.set_elite_save_topology(false)
.set_elite_save_safetensors(false);
}
b
}
pub fn seed_or(&self, default: Option<u64>) -> Option<u64> {
self.seed.or(default)
}
pub fn run_dir_or(&self, default: Option<PathBuf>) -> Option<PathBuf> {
self.run_dir.clone().or(default)
}
pub fn init_logger(&self, default_level: LogLevel) -> bool {
gras::engine::logging::init(default_level, self.log_level.map(LogLevel::env_filter))
}
}