bentopy 0.2.0a10__cp313-cp313-manylinux_2_34_x86_64.whl

core/config/bent/writer.rs

@@ -0,0 +1,205 @@
+use std::io::{Result, Write};
+use std::path::Path;
+
+use crate::core::config::{
+    Compartment, Config, Constraint, General, Mask, Point, RearrangeMethod, Rule, Segment, Shape,
+    Space,
+};
+
+pub fn write<W: Write>(config: &Config, w: &mut W) -> Result<()> {
+    let Config {
+        general,
+        space,
+        includes,
+        constraints,
+        compartments,
+        segments,
+    } = config;
+
+    // Write a comment header about this file.
+    writeln!(w, "# Bentopy {}", crate::core::version::VERSION)?;
+    writeln!(w)?;
+
+    {
+        // General section.
+        let General {
+            title,
+            seed,
+            bead_radius,
+            max_tries_mult,
+            max_tries_rot_div,
+            rearrange_method,
+        } = general;
+
+        section(w, "general")?;
+        if let Some(val) = title {
+            field(w, "title", format_string(val))?
+        }
+        if let Some(val) = seed {
+            field(w, "seed", val)?
+        }
+        if let Some(val) = bead_radius {
+            // FIXME: This is a bit cursed, I guess. It's just to make sure we don't print ugly
+            // insignificant digits.
+            field(w, "bead-radius", *val as f32)?
+        }
+        if let Some(val) = max_tries_mult {
+            field(w, "max-tries-mult", val)?
+        }
+        if let Some(val) = max_tries_rot_div {
+            field(w, "max-tries-rot-div", val)?
+        }
+        if let Some(val) = rearrange_method {
+            field(w, "rearrange", rm(val))?
+        }
+
+        writeln!(w)?; // Spacing newline.
+    }
+
+    {
+        // Space section.
+        let Space {
+            dimensions,
+            resolution,
+            periodic,
+        } = space;
+
+        section(w, "space")?;
+        if let Some(val) = dimensions {
+            field(w, "dimensions", point(val))?
+        }
+        if let Some(val) = resolution {
+            field(w, "resolution", val)?
+        }
+        if let Some(val) = periodic {
+            field(w, "periodic", val)?
+        }
+
+        writeln!(w)?; // Spacing newline.
+    }
+
+    if !includes.is_empty() {
+        // Includes section.
+        section(w, "includes")?;
+        for include in includes {
+            include_entry(w, include)?;
+        }
+        writeln!(w)?; // Spacing newline.
+    }
+
+    // Compartments section.
+    section(w, "compartments")?;
+    for compartment in compartments {
+        compartment_entry(w, compartment)?;
+    }
+    writeln!(w)?; // Spacing newline.
+
+    if !constraints.is_empty() {
+        // Constraints section.
+        section(w, "constraints")?;
+        for constraint in constraints {
+            constraint_entry(w, constraint)?;
+        }
+        writeln!(w)?; // Spacing newline.
+    }
+
+    // Segments section.
+    section(w, "segments")?;
+    for segment in segments {
+        segment_entry(w, segment)?;
+    }
+
+    Ok(())
+}
+
+fn section<W: Write>(w: &mut W, header: &'static str) -> Result<()> {
+    writeln!(w, "[ {header} ]")
+}
+
+fn field<W: Write, D: std::fmt::Display>(w: &mut W, name: &'static str, value: D) -> Result<()> {
+    writeln!(w, "{name}\t{value}")
+}
+
+// TODO: This could be done with a std::fmt::Display impl on RearrangeMethod.
+fn rm(val: &RearrangeMethod) -> &'static str {
+    match val {
+        RearrangeMethod::Moment => "moment",
+        RearrangeMethod::Volume => "volume",
+        RearrangeMethod::BoundingSphere => "bounding-sphere",
+        RearrangeMethod::None => "none",
+    }
+}
+
+fn point(point: &Point) -> String {
+    let [x, y, z] = point;
+    format!("{x}, {y}, {z}")
+}
+
+fn format_string(s: &str) -> String {
+    format!(r#""{s}""#)
+}
+
+fn format_path(path: &Path) -> String {
+    // TODO: This really makes me think we should mave it to Vec<String>.
+    format_string(path.to_str().expect("TODO"))
+}
+
+fn list<T: std::fmt::Display>(items: &[T]) -> String {
+    items
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+fn include_entry<W: Write>(w: &mut W, include: &Path) -> Result<()> {
+    writeln!(w, "{}", format_path(include))
+}
+
+fn compartment_entry<W: Write>(w: &mut W, compartment: &Compartment) -> Result<()> {
+    let Compartment { id, mask } = compartment;
+    let mask = match mask {
+        Mask::All => "is all".to_string(),
+        Mask::Voxels(path) => format!("from {}", format_path(path)),
+        Mask::Shape(Shape::Sphere { center, radius }) => {
+            format!("as sphere at {center} with radius {radius}")
+        }
+        Mask::Shape(Shape::Cuboid { start, end }) => {
+            format!("as cuboid from {start} to {end}")
+        }
+        Mask::Limits(expr) => format!("where {expr}"),
+        Mask::Within { distance, id } => format!("within {distance} of {id}"),
+        Mask::Combination(expr) => format!("combines {expr}"),
+    };
+    writeln!(w, "{id} {mask}")
+}
+
+fn constraint_entry<W: Write>(w: &mut W, constraint: &Constraint) -> Result<()> {
+    let Constraint { id, rule } = constraint;
+    let rule = match rule {
+        Rule::RotationAxes(axes) => format!("rotates {}", list(&axes.list())),
+    };
+    writeln!(w, "{id} {rule}")
+}
+
+fn segment_entry<W: Write>(w: &mut W, segment: &Segment) -> Result<()> {
+    let Segment {
+        name,
+        tag,
+        quantity,
+        path,
+        compartment_ids,
+        rules,
+    } = segment;
+    let id = match tag {
+        Some(tag) => format!("{name}:{tag}"),
+        None => name.to_string(),
+    };
+    let path = format_path(path);
+    let compartment_ids = list(compartment_ids);
+    let rules = match rules[..] {
+        [] => Default::default(),
+        _ => format!(" satisfies {}", list(rules)),
+    };
+    writeln!(w, "{id} {quantity} from {path} in {compartment_ids}{rules}")
+}

core/config/bent.rs

@@ -0,0 +1,149 @@
+use chumsky::Parser;
+use chumsky::error::Rich;
+use chumsky::input::{BorrowInput, Input};
+use chumsky::span::SimpleSpan;
+
+use lexer::{Spanned, Token};
+
+use crate::core::config::Config;
+
+mod lexer;
+mod parser;
+mod writer;
+
+pub use writer::write;
+
+pub(crate) fn make_input<'src, 'tokens>(
+    eoi: SimpleSpan,
+    toks: &'tokens [Spanned<Token<'src>>],
+) -> impl BorrowInput<'tokens, Token = Token<'src>, Span = SimpleSpan> {
+    toks.map(eoi, |(t, s)| (t, s))
+}
+
+mod report {
+    use super::*;
+
+    use ariadne::{Color, Fmt, Label, Report, ReportKind, Source};
+
+    // Most of this is taken and modified from the mini_ml.rs example in the chumsky github page.
+    // https://github.com/zesterer/chumsky/blob/0.11/examples/mini_ml.rs
+
+    /// Report errors from a parsing step.
+    pub(crate) fn error(path: &str, src: &str, err: &Rich<impl std::fmt::Display>) -> String {
+        let msg = err.reason().to_string();
+        let label = (
+            err.found()
+                .map(|c| c.to_string())
+                .unwrap_or_else(|| "end of input".to_string()),
+            *err.span(),
+        );
+        let extra_labels = err
+            .contexts()
+            .map(|(l, s)| (format!("while parsing this {l}"), *s));
+
+        let cfg = ariadne::Config::new()
+            .with_index_type(ariadne::IndexType::Char)
+            .with_label_attach(ariadne::LabelAttach::Middle);
+        Report::build(ReportKind::Error, (path, label.1.into_range()))
+            .with_config(cfg)
+            .with_message(&msg)
+            .with_label(
+                Label::new((path, label.1.into_range()))
+                    .with_message(label.0)
+                    .with_color(Color::Red),
+            )
+            .with_labels(extra_labels.into_iter().map(|label| {
+                Label::new((path, label.1.into_range()))
+                    .with_message(label.0)
+                    .with_color(Color::Yellow)
+            }))
+            .finish()
+            .eprint((path, Source::from(src)))
+            .unwrap();
+        msg
+    }
+
+    /// Report the result of a parsing step by showing the spans of source code associated with
+    /// each item.
+    pub(crate) fn result<T: std::fmt::Display>(path: &str, src: &str, items: &[Spanned<T>]) {
+        let cfg = ariadne::Config::new()
+            .with_compact(true)
+            .with_index_type(ariadne::IndexType::Char)
+            .with_label_attach(ariadne::LabelAttach::Middle);
+        for (item, span) in items {
+            Report::build(
+                ReportKind::Custom("Result", Color::Green),
+                (path, span.into_range()),
+            )
+            .with_config(cfg)
+            .with_message(format!("found the following item: {item}"))
+            .with_label(
+                Label::new((path, span.into_range()))
+                    .with_message(item.to_string())
+                    .with_color(Color::Green),
+            )
+            .finish()
+            .eprint((path, Source::from(src)))
+            .unwrap();
+        }
+    }
+
+    /// Report placeholders in an input file.
+    pub(crate) fn placeholders<'s>(path: &str, src: &'s str, items: &[Spanned<Token<'s>>]) {
+        let cfg = ariadne::Config::new()
+            .with_compact(true)
+            .with_index_type(ariadne::IndexType::Char)
+            .with_label_attach(ariadne::LabelAttach::Middle);
+        for (item, name, span) in items.iter().filter_map(|(item, span)| match item {
+            Token::Placeholder(name) => Some((item, name, span)),
+            _ => None,
+        }) {
+            Report::build(
+                ReportKind::Custom("Placeholder", Color::Cyan),
+                (path, span.into_range()),
+            )
+            .with_config(cfg)
+            .with_message(format!(
+                "replace {} with a valid value",
+                format!("<{name}>").fg(Color::Cyan)
+            ))
+            .with_label(
+                Label::new((path, span.into_range()))
+                    .with_message(item.to_string())
+                    .with_color(Color::Cyan),
+            )
+            .finish()
+            .eprint((path, Source::from(src)))
+            .unwrap();
+        }
+    }
+}
+
+pub fn parse_config(path: &str, src: &str) -> anyhow::Result<Config> {
+    let tokens = lexer::lexer().parse(src).into_result().map_err(|errs| {
+        // Display a nice report.
+        let summary = report::error(path, src, &errs[0]);
+        // Communicate the error upstream.
+        anyhow::anyhow!("could not lex {path:?}: {summary}")
+    })?;
+
+    if std::env::var("BENTOPY_SHOW_TOKENS").is_ok_and(|v| v.parse::<bool>().unwrap_or_default()) {
+        eprintln!("Printing tokens.");
+        report::result(path, src, &tokens);
+    }
+
+    // Report any placeholders in the stream of tokens.
+    report::placeholders(path, src, &tokens);
+
+    let tokens = make_input((0..src.len()).into(), &tokens);
+    let config = parser::parser()
+        .parse(tokens)
+        .into_result()
+        .map_err(|errs| {
+            // Display a nice report.
+            let summary = report::error(path, src, &errs[0]);
+            // Communicate the error upstream.
+            anyhow::anyhow!("could not parse {path:?}: {summary}")
+        })?;
+    Ok(config)
+}

core/config/compartment_combinations.rs

@@ -0,0 +1,300 @@
+use std::str::FromStr;
+
+use super::CompartmentID as Id;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum Token {
+    Id(Id),
+    Not,       // `!`
+    Union,     // `union(`
+    Intersect, // `intersect(`
+    Close,     // `)`
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Expression {
+    Id(Id),
+    Not(Box<Self>),
+    Union(Vec<Self>),
+    Intersect(Vec<Self>),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ParseExpressionError {
+    UnexpectedEnd,
+    UnexpectedClose,
+    TrailingTokens,
+}
+
+impl std::error::Error for ParseExpressionError {}
+impl std::fmt::Display for ParseExpressionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseExpressionError::UnexpectedEnd => {
+                "encountered the end of the tokens, but expected more"
+            }
+            ParseExpressionError::UnexpectedClose => "encounterd an unexpected closing parenthesis",
+            ParseExpressionError::TrailingTokens => {
+                "some tokens remained after parsing the root expression"
+            }
+        }
+        .fmt(f)
+    }
+}
+
+fn consume_whitespace(input: &str) -> &str {
+    input.trim_start()
+}
+
+/// Tokenize a single ID.
+fn tokenize_id<'s>(mut input: &'s str, tokens: &mut Vec<Token>) -> &'s str {
+    // Either, the end of the token is the end of `input`, whitespace, or a closing parenthesis.
+    let end = input
+        .find(|ch: char| ch.is_whitespace() || ch == ')')
+        .unwrap_or(input.len());
+    let id;
+    (id, input) = input.split_at(end);
+    // Make sure we're not accidentally emitting an empty id. This can happen if we're at the end
+    // of the input string. That is usually wrong, but we'll catch that during the parse.
+    if !id.is_empty() {
+        tokens.push(Token::Id(id.to_string())); // Emit.
+    }
+    input
+}
+
+/// Tokenize the next operation, if there is one.
+fn tokenize_operation<'s>(
+    mut input: &'s str,
+    tokens: &mut Vec<Token>,
+) -> Result<Option<&'s str>, ParseExpressionError> {
+    input = consume_whitespace(input);
+
+    if input.starts_with('!') {
+        tokens.push(Token::Not); // Emit.
+        input = &input[1..];
+
+        // We now expect another expression.
+        return Ok(Some(tokenize_expr(input, tokens)?));
+    }
+
+    if input.starts_with("union(") {
+        tokens.push(Token::Union); // Emit.
+        input = &input[6..];
+
+        // We now expect a list of operands.
+        return Ok(Some(tokenize_operands(input, tokens)?));
+    }
+
+    if input.starts_with("intersect(") {
+        tokens.push(Token::Intersect); // Emit.
+        input = &input[10..];
+
+        // We now expect a list of operands.
+        return Ok(Some(tokenize_operands(input, tokens)?));
+    }
+
+    // Syntax errors.
+    if input.starts_with(')') {
+        return Err(ParseExpressionError::UnexpectedClose);
+    }
+
+    Ok(None)
+}
+
+/// Tokenize the operands of an operation until a [`Token::Close`] is found the same tree level.
+fn tokenize_operands<'s>(
+    mut input: &'s str,
+    tokens: &mut Vec<Token>,
+) -> Result<&'s str, ParseExpressionError> {
+    while !input.is_empty() {
+        // We now expect another expression.
+        input = tokenize_expr(input, tokens)?;
+
+        // If we have reached the end of this body, we are done.
+        input = consume_whitespace(input);
+        if input.starts_with(')') {
+            tokens.push(Token::Close); // Emit.
+            input = &input[1..];
+            break;
+        }
+    }
+
+    Ok(input)
+}
+
+/// Tokenize the next expression.
+fn tokenize_expr<'s>(
+    mut input: &'s str,
+    tokens: &mut Vec<Token>,
+) -> Result<&'s str, ParseExpressionError> {
+    input = consume_whitespace(input);
+    match tokenize_operation(input, tokens)? {
+        Some(tail) => Ok(tail),
+        None => Ok(tokenize_id(input, tokens)),
+    }
+}
+
+/// Tokenize a compartment combinations definition input string.
+fn tokenize(mut input: &str) -> Result<Vec<Token>, ParseExpressionError> {
+    let mut tokens = Vec::new();
+    while !input.is_empty() {
+        input = tokenize_expr(input, &mut tokens)?;
+    }
+    Ok(tokens)
+}
+
+/// Returns a list of operands until the [`Token::Close`] if this level in the tree is encountered.
+fn parse_operands_until_close(
+    tokens: &mut &[Token],
+) -> Result<Vec<Expression>, ParseExpressionError> {
+    let mut operands = Vec::new();
+    while let Some(item) = parse_next_item(tokens)? {
+        operands.push(item);
+    }
+    Ok(operands)
+}
+
+/// Returns the next item or `None` when the [`Token::Close`] for this level in the three is hit.
+fn parse_next_item(tokens: &mut &[Token]) -> Result<Option<Expression>, ParseExpressionError> {
+    let token;
+    (token, *tokens) = tokens
+        .split_first()
+        .ok_or(ParseExpressionError::UnexpectedEnd)?;
+    let expr = match token {
+        Token::Id(id) => Expression::Id(id.to_owned()),
+        Token::Not => Expression::Not(Box::new(
+            parse_next_item(tokens)?.ok_or(ParseExpressionError::UnexpectedClose)?,
+        )),
+        Token::Union => Expression::Union(parse_operands_until_close(tokens)?),
+        Token::Intersect => Expression::Intersect(parse_operands_until_close(tokens)?),
+        Token::Close => return Ok(None),
+    };
+
+    Ok(Some(expr))
+}
+
+fn parse(tokens: &mut &[Token]) -> Result<Expression, ParseExpressionError> {
+    parse_next_item(tokens)?.ok_or(ParseExpressionError::UnexpectedClose)
+}
+
+impl FromStr for Expression {
+    type Err = ParseExpressionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let tokens = tokenize(s)?;
+        let tokens = &mut tokens.as_slice();
+        let expr = parse(tokens)?;
+        if tokens.is_empty() {
+            // No trailing tokens, as desired.
+            Ok(expr)
+        } else {
+            Err(Self::Err::TrailingTokens)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tokens() {
+        let expected = Ok(vec![
+            Token::Union,
+            Token::Id("first".to_string()),
+            Token::Intersect,
+            Token::Id("second".to_string()),
+            Token::Id("third".to_string()),
+            Token::Close,
+            Token::Not,
+            Token::Union,
+            Token::Id("fourth".to_string()),
+            Token::Id("fifth".to_string()),
+            Token::Close,
+            Token::Close,
+        ]);
+
+        let clean = "union(first intersect(second third) !union(fourth fifth))";
+        let extra_spaces =
+            "    union(  first   intersect(  second   third)  !   union(  fourth  fifth  )  )  ";
+        let messy = "     
+   union(      first      
+intersect(  
+
+         second        third)  !        
+        union(   fourth          
+
+fifth          
+
+
+  
+) 
+               )                
+";
+
+        assert_eq!(tokenize(clean), expected);
+        assert_eq!(tokenize(extra_spaces), expected);
+        assert_eq!(tokenize(messy), expected);
+    }
+
+    #[test]
+    fn parsing() {
+        let expected = Expression::Union(vec![
+            Expression::Id("first".to_string()),
+            Expression::Intersect(vec![
+                Expression::Id("second".to_string()),
+                Expression::Id("third".to_string()),
+            ]),
+            Expression::Not(Box::new(Expression::Union(vec![
+                Expression::Id("fourth".to_string()),
+                Expression::Id("fifth".to_string()),
+            ]))),
+        ]);
+
+        let tokens = vec![
+            Token::Union,
+            Token::Id("first".to_string()),
+            Token::Intersect,
+            Token::Id("second".to_string()),
+            Token::Id("third".to_string()),
+            Token::Close,
+            Token::Not,
+            Token::Union,
+            Token::Id("fourth".to_string()),
+            Token::Id("fifth".to_string()),
+            Token::Close,
+            Token::Close,
+        ];
+
+        assert_eq!(parse(&mut tokens.as_slice()), Ok(expected));
+    }
+
+    #[test]
+    fn parse_from_string() {
+        let expected = Expression::Union(vec![
+            Expression::Id("first".to_string()),
+            Expression::Intersect(vec![
+                Expression::Id("second".to_string()),
+                Expression::Id("third".to_string()),
+            ]),
+            Expression::Not(Box::new(Expression::Union(vec![
+                Expression::Id("fourth".to_string()),
+                Expression::Id("fifth".to_string()),
+            ]))),
+        ]);
+
+        let s = "union(first intersect(second third) !union(fourth fifth))";
+
+        assert_eq!(Expression::from_str(s), Ok(expected));
+    }
+
+    #[test]
+    fn parse_not() {
+        let expected = Ok(Expression::Not(Box::new(Expression::Id("a".to_string()))));
+        let unexpected_close = Err(ParseExpressionError::UnexpectedClose);
+
+        assert_eq!(Expression::from_str("!a)"), unexpected_close);
+        assert_eq!(Expression::from_str("!a "), expected);
+        assert_eq!(Expression::from_str("!a"), expected);
+    }
+}