The template registry

use std::collections::BTreeMap;

use helixrs::statics::templates::registry;
use helixrs::template;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listing: Vec<(&'static str, &'static str)> = registry::codes()
        .into_iter()
        .map(|(_, _, code)| (code, registry::lookup(code).expect("a listed code").family()))
        .collect();

    // How many templates each family holds, by family.
    let mut counts: BTreeMap<&str, (usize, &str)> = BTreeMap::new();
    for (code, family) in &listing {
        let entry = counts.entry(family).or_insert((0, code));
        entry.0 += 1;
        if *code < entry.1 {
            entry.1 = code;
        }
    }
    println!("| Family | Templates | First code |");
    println!("|---|---|---|");
    for (family, (count, first)) in &counts {
        println!("| {family} | {count} | `{first}` |");
    }
    let total: usize = counts.values().map(|(count, _)| count).sum();
    println!("total {total} templates in {} families", counts.len());

    // A code resolves to a template whose family is the one the listing reports.
    for code in ["USD-SOFR-OIS", "BRL-USD-NDF", "USD-GC-REPO", "CDS-STANDARD"] {
        let family = template(code)?.family();
        println!("{code:<14} {family}");
    }

    // An unknown code is refused, naming the code and the registered ones.
    let Err(refused) = template("USD-NOPE-OIS") else {
        panic!("an unknown code must be refused");
    };
    let unknown = refused.to_string();
    println!("refused, naming the code: {}", if unknown.contains("USD-NOPE-OIS") { "yes" } else { "no" });

    Ok(())
}

from collections import Counter

import helixio as hlx

TABLE = hlx.templates.catalogue().to_dict()

# How many templates each family holds, by family.
counts = Counter(TABLE["family"])
print("| Family | Templates | First code |")
print("|---|---|---|")
for family in sorted(counts):
    first = min(code for code, f in zip(TABLE["code"], TABLE["family"]) if f == family)
    print(f"| {family} | {counts[family]} | `{first}` |")
print(f"total {sum(counts.values())} templates in {len(counts)} families")

# A code resolves to a template whose family is the one the listing reports.
for code in ("USD-SOFR-OIS", "BRL-USD-NDF", "USD-GC-REPO", "CDS-STANDARD"):
    family = hlx.templates.get(code).family()
    print(f"{code:<14} {family}")

# An unknown code is refused, naming the code and the registered ones.
try:
    hlx.templates.get("USD-NOPE-OIS")
except ValueError as refused:
    unknown = str(refused)
    print(f"refused, naming the code: {'yes' if 'USD-NOPE-OIS' in unknown else 'no'}")
else:
    raise AssertionError("an unknown code must be refused")