openodd-py 0.2.2__tar.gz → 0.3.0__tar.gz

{openodd_py-0.2.2 → openodd_py-0.3.0}/Cargo.lock

@@ -263,7 +263,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "openodd"
-version = "0.2.2"
+version = "0.3.0"
 dependencies = [
  "flate2",
  "fs2",

{openodd_py-0.2.2 → openodd_py-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "openodd"
-version = "0.2.2"
+version = "0.3.0"
 edition = "2021"
 rust-version = "1.82"
 description = "ASAM OpenODD 1.0: read, evaluate, version and sample Operational Design Domains"

{openodd_py-0.2.2 → openodd_py-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openodd-py
-Version: 0.2.2
+Version: 0.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
@@ -44,6 +44,26 @@ odd.revision   # sha256 of the files it was read from
 odd.archive()  # those files as a deterministic .tar.gz
 ```
 
+### Coverage
+
+A coverage document records, besides each item's buckets, how a run spent its
+time across the ODD's buckets: `OddCells` adds up steps, seconds and metres per
+*cell* -- one bucket of each attribute, as its cover item buckets it -- so a
+consumer can slice runs by any attributes without the per-step values:
+
+```python
+cells = openodd.OddCells(odd)
+cells.add(values, seconds=dt, meters=ds)   # every step: each attribute's value
+cells.to_dict()
+# {"attributes": ["speed", "rain"], "rows": [[["[30, 60]", "heavy"], 812, 40.6, 588.2], ...]}
+```
+
+A missing value is `<missing>`, a number outside the buckets `<below>` / `<above>`.
+Each item's definition (`describe()`) names the measure its coverage is read from
+(`amount`: `hits`, `counted.seconds`, ...) and, for an ODD attribute's item, the
+attribute (`attribute`). `openodd.__version__` is the installed version, for
+coverage files to say what wrote them.
+
 ## Development
 
 ```bash

{openodd_py-0.2.2 → openodd_py-0.3.0}/README.md

@@ -29,6 +29,26 @@ odd.revision   # sha256 of the files it was read from
 odd.archive()  # those files as a deterministic .tar.gz
 ```
 
+### Coverage
+
+A coverage document records, besides each item's buckets, how a run spent its
+time across the ODD's buckets: `OddCells` adds up steps, seconds and metres per
+*cell* -- one bucket of each attribute, as its cover item buckets it -- so a
+consumer can slice runs by any attributes without the per-step values:
+
+```python
+cells = openodd.OddCells(odd)
+cells.add(values, seconds=dt, meters=ds)   # every step: each attribute's value
+cells.to_dict()
+# {"attributes": ["speed", "rain"], "rows": [[["[30, 60]", "heavy"], 812, 40.6, 588.2], ...]}
+```
+
+A missing value is `<missing>`, a number outside the buckets `<below>` / `<above>`.
+Each item's definition (`describe()`) names the measure its coverage is read from
+(`amount`: `hits`, `counted.seconds`, ...) and, for an ODD attribute's item, the
+attribute (`attribute`). `openodd.__version__` is the installed version, for
+coverage files to say what wrote them.
+
 ## Development
 
 ```bash

{openodd_py-0.2.2 → openodd_py-0.3.0}/python/openodd/__init__.py

@@ -16,7 +16,10 @@ What measures the attributes -- a simulator, a recorded log -- is the
 application's :class:`Backend`.
 """
 
+from importlib import metadata as _metadata
+
 from ._core import GitSourceError, OpenOddError, UnitError, Units, convert, normalize_unit
+from .cells import MISSING, OddCells
 from .backend import Backend, Probe, default_backend, import_callable, set_default_backend
 from .items import (
     ABOVE_RANGE,
@@ -65,7 +68,15 @@ from .model import (
     read_probe,
 )
 
+try:
+    __version__: str = _metadata.version("openodd-py")
+except _metadata.PackageNotFoundError:  # a source tree, not installed
+    __version__ = "0+unknown"
+
 __all__ = [
+    "MISSING",
+    "OddCells",
+    "__version__",
     "COVERAGE_SCHEMA",
     "CoverageReport",
     "MergedEntry",

{openodd_py-0.2.2 → openodd_py-0.3.0}/python/openodd/_core.pyi

@@ -47,8 +47,19 @@ class Units:
     def convert(self, value: float, from_unit: str, to_unit: str) -> float: ...
     def check_type(self, unit: str, unit_type: str) -> None: ...
 
+class Cells:
+    def __init__(self, odd: Any) -> None: ...
+    @property
+    def attributes(self) -> list[str]: ...
+    @property
+    def ticks(self) -> int: ...
+    def cell_of(self, values: list[Any]) -> list[str]: ...
+    def add(self, values: list[Any], seconds: float = 0.0, meters: float = 0.0) -> None: ...
+    def to_json(self) -> str: ...
+
 UNDECIDED: Any
 CACHE_ENV: str
+MISSING: str
 
 def convert(value: float, from_unit: str, to_unit: str) -> float: ...
 def normalize_unit(unit: str) -> str: ...

openodd_py-0.3.0/python/openodd/cells.py

@@ -0,0 +1,76 @@
+"""Cells: how long a run spent in each combination of the ODD's buckets.
+
+Every step, each attribute with buckets puts its value in one (its cover
+item's ``bucket_of``); the labels together are the step's *cell*.
+:class:`OddCells` adds up steps, seconds and metres per cell, so a consumer can
+slice a run by any attributes afterwards -- a matrix of two of them inside a
+third's bucket -- without keeping every step's values, and without bucketing
+them again by rules of its own::
+
+    cells = OddCells(odd)
+    for step in run:                       # every attribute's value, in order
+        cells.add(step.values, seconds=step.dt, meters=step.ds)
+    cells.to_dict()
+    # {"attributes": ["scenery.speed_limit", "environment.rain"],
+    #  "rows": [[["[50, 60)", "none"], 812, 40.6, 588.2], ...]}
+
+A missing value is :data:`MISSING`; a number outside the buckets
+``<below>``/``<above>``; a category none of the values names keeps its own
+label. Attributes without buckets are left out of the cell.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any, Union
+
+from . import _core
+from .model import to_core
+
+if TYPE_CHECKING:
+    from .model import OddDefinition
+
+__all__ = ["MISSING", "OddCells"]
+
+#: The label of a step whose value was missing.
+MISSING: str = _core.MISSING
+
+
+class OddCells:
+    """Steps, seconds and metres per cell of *odd*'s attributes."""
+
+    def __init__(self, odd: "OddDefinition") -> None:
+        self._names = [a.name for a in odd.attributes]
+        self._core = _core.Cells(odd._core)
+
+    @property
+    def attributes(self) -> list[str]:
+        """The attributes with buckets: what a cell's labels are of, in order."""
+        return list(self._core.attributes)
+
+    @property
+    def ticks(self) -> int:
+        """Steps counted so far."""
+        return int(self._core.ticks)
+
+    def _values(self, values: Union[Sequence[Any], Mapping[str, Any]]) -> list[Any]:
+        if isinstance(values, Mapping):
+            return [to_core(values.get(name)) for name in self._names]
+        return [to_core(v) for v in values]
+
+    def cell_of(self, values: Union[Sequence[Any], Mapping[str, Any]]) -> list[str]:
+        """The cell of one step: *values* by attribute name, or one per
+        attribute of the ODD in its order."""
+        return list(self._core.cell_of(self._values(values)))
+
+    def add(self, values: Union[Sequence[Any], Mapping[str, Any]], seconds: float = 0.0,
+            meters: float = 0.0) -> None:
+        """Count one step that took *seconds* and covered *meters*."""
+        self._core.add(self._values(values), float(seconds), float(meters))
+
+    def to_dict(self) -> dict[str, Any]:
+        """``{"attributes": [...], "rows": [[[label, ...], ticks, seconds, meters], ...]}``,
+        most steps first (ties by labels); seconds and metres to 3 decimals."""
+        out: dict[str, Any] = json.loads(self._core.to_json())
+        return out

{openodd_py-0.2.2 → openodd_py-0.3.0}/python/openodd/items.py

@@ -119,6 +119,8 @@ class CoverItem:
     group: CoverGroup = CoverGroup.SCENARIO
     cover_by: str = "hits"
     min_stay: Optional[float] = None
+    #: The ODD attribute the item buckets, when it is one's.
+    attribute: Optional[str] = None
 
     #: Bucket edges of a numeric item, ascending; empty for a categorical one.
     edges: list[float] = field(init=False, default_factory=list)
@@ -173,6 +175,7 @@ class CoverItem:
         self.group = group
         self.cover_by = bucketing.cover_by
         self.min_stay = bucketing.min_stay
+        self.attribute = bucketing.attribute
         self._bucketing = bucketing
         return self
 
@@ -181,6 +184,12 @@ class CoverItem:
         """Whether the buckets are ranges rather than values."""
         return bool(self.edges)
 
+    @property
+    def amount(self) -> str:
+        """The measure a bucket's coverage is read from: ``cover_by``, or with
+        a ``min_stay`` the stays long enough to count (``counted.<cover_by>``)."""
+        return f"counted.{self.cover_by}" if self.min_stay is not None else self.cover_by
+
     def bucket_of(self, value: Any) -> str:
         """The label of the bucket *value* falls in.
 
@@ -208,6 +217,8 @@ class CoverItem:
             "target": self.target,
             "cover_by": self.cover_by,
             "min_stay": self.min_stay,
+            "amount": self.amount,
+            **({"attribute": self.attribute} if self.attribute is not None else {}),
         }
 
 
@@ -267,4 +278,5 @@ class CrossItem:
             "target": self.target,
             "cover_by": self.cover_by,
             "min_stay": self.min_stay,
+            "amount": f"counted.{self.cover_by}" if self.min_stay is not None else self.cover_by,
         }

openodd_py-0.3.0/src/cells.rs

@@ -0,0 +1,209 @@
+//! Cells: how long a run spent in each combination of the ODD's buckets.
+//!
+//! Every step, each attribute with buckets (a cover item) puts its value in a
+//! bucket; the tuple of those labels is the step's *cell*. A [`CellCounter`]
+//! adds up the steps, seconds and metres per cell, so a consumer can slice the
+//! run by any attributes afterwards without the per-step values -- and buckets
+//! them exactly as the cover items do, with no second copy of the rules.
+//!
+//! A missing value is [`MISSING`]; a numeric value below or above every bucket
+//! is [`BELOW_RANGE`] / [`ABOVE_RANGE`]; a categorical value that is none of
+//! the values keeps its own label (as [`CoverItem::bucket_of`] does).
+
+use indexmap::IndexMap;
+use serde_json::{json, Value as Json};
+
+use crate::error::{Error, Result};
+use crate::items::CoverItem;
+use crate::model::Odd;
+use crate::value::Value;
+
+/// The label of a step whose value was missing (or could not be bucketed).
+pub const MISSING: &str = "<missing>";
+
+/// Steps, seconds and metres per cell of an ODD's attributes.
+#[derive(Debug, Clone)]
+pub struct CellCounter {
+    /// The attributes with buckets, in the ODD's order: the cell's labels.
+    pub attributes: Vec<String>,
+    /// For each of the ODD's attributes (all of them, in order), its item.
+    items: Vec<Option<CoverItem>>,
+    cells: IndexMap<Vec<String>, (u64, f64, f64)>,
+}
+
+fn round3(x: f64) -> f64 {
+    (x * 1000.0).round() / 1000.0
+}
+
+impl CellCounter {
+    pub fn new(odd: &Odd) -> Self {
+        let items: Vec<Option<CoverItem>> = odd.attributes.iter().map(|a| a.item.clone()).collect();
+        let attributes = odd
+            .attributes
+            .iter()
+            .filter(|a| a.item.is_some())
+            .map(|a| a.name.clone())
+            .collect();
+        CellCounter {
+            attributes,
+            items,
+            cells: IndexMap::new(),
+        }
+    }
+
+    /// The cell of one step: `values` has one value per attribute of the ODD
+    /// (every attribute, in the ODD's order, as samples are recorded).
+    pub fn cell_of(&self, values: &[Value]) -> Result<Vec<String>> {
+        if values.len() != self.items.len() {
+            return Err(Error::value(format!(
+                "cells: {} values for {} attributes",
+                values.len(),
+                self.items.len()
+            )));
+        }
+        Ok(self
+            .items
+            .iter()
+            .zip(values)
+            .filter_map(|(item, value)| item.as_ref().map(|item| (item, value)))
+            .map(|(item, value)| match value {
+                Value::Missing | Value::Open => MISSING.to_string(),
+                v => item.bucket_of(v).unwrap_or_else(|_| MISSING.to_string()),
+            })
+            .collect())
+    }
+
+    /// Count one step that took `seconds` and covered `meters`.
+    pub fn add(&mut self, values: &[Value], seconds: f64, meters: f64) -> Result<()> {
+        let cell = self.cell_of(values)?;
+        let entry = self.cells.entry(cell).or_insert((0, 0.0, 0.0));
+        entry.0 += 1;
+        entry.1 += seconds.max(0.0);
+        entry.2 += meters.max(0.0);
+        Ok(())
+    }
+
+    /// Steps counted so far.
+    pub fn ticks(&self) -> u64 {
+        self.cells.values().map(|c| c.0).sum()
+    }
+
+    /// The cells: labels, steps, seconds, metres; most steps first, then by labels.
+    pub fn rows(&self) -> Vec<(Vec<String>, u64, f64, f64)> {
+        let mut rows: Vec<_> = self
+            .cells
+            .iter()
+            .map(|(k, (t, s, m))| (k.clone(), *t, round3(*s), round3(*m)))
+            .collect();
+        rows.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+        rows
+    }
+
+    /// `{"attributes": [...], "rows": [[[label, ...], ticks, seconds, meters], ...]}`.
+    pub fn to_json(&self) -> Json {
+        json!({
+            "attributes": self.attributes,
+            "rows": self.rows().into_iter()
+                .map(|(labels, t, s, m)| json!([labels, t, s, m]))
+                .collect::<Vec<_>>(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::items::{Buckets, Criteria};
+    use crate::model::{Attribute, Probe};
+
+    fn odd() -> Odd {
+        let mut speed =
+            Attribute::new("speed", Probe::Missing, "km/h", "", Criteria::default()).unwrap();
+        speed
+            .set_buckets(Buckets::Edges(vec![0.0, 30.0, 60.0]))
+            .unwrap();
+        let mut rain = Attribute::new("rain", Probe::Missing, "", "", Criteria::default()).unwrap();
+        rain.set_buckets(Buckets::Values(vec![
+            Value::Str("none".into()),
+            Value::Str("heavy".into()),
+        ]))
+        .unwrap();
+        let free = Attribute::new("free", Probe::Missing, "", "", Criteria::default()).unwrap();
+        Odd::new("t", vec![speed, free, rain], vec![], None, "").unwrap()
+    }
+
+    #[test]
+    fn buckets_like_the_items() {
+        let c = CellCounter::new(&odd());
+        assert_eq!(c.attributes, vec!["speed", "rain"]);
+        let cell = |v: Vec<Value>| c.cell_of(&v).unwrap();
+        assert_eq!(
+            cell(vec![
+                Value::Float(30.0),
+                Value::Int(3),
+                Value::Str("none".into())
+            ]),
+            vec!["[30, 60]", "none"]
+        );
+        assert_eq!(
+            cell(vec![
+                Value::Float(-1.0),
+                Value::Missing,
+                Value::Str("fog".into())
+            ]),
+            vec!["<below>", "fog"]
+        );
+        assert_eq!(
+            cell(vec![Value::Float(61.0), Value::Missing, Value::Missing]),
+            vec!["<above>", MISSING]
+        );
+        assert_eq!(
+            cell(vec![Value::Str("x".into()), Value::Missing, Value::Open]),
+            vec![MISSING, MISSING]
+        );
+        assert!(c.cell_of(&[Value::Missing]).is_err());
+    }
+
+    #[test]
+    fn counts_and_orders() {
+        let mut c = CellCounter::new(&odd());
+        let a = vec![
+            Value::Float(10.0),
+            Value::Missing,
+            Value::Str("none".into()),
+        ];
+        let b = vec![
+            Value::Float(40.0),
+            Value::Missing,
+            Value::Str("heavy".into()),
+        ];
+        let z = vec![
+            Value::Float(5.0),
+            Value::Missing,
+            Value::Str("heavy".into()),
+        ];
+        c.add(&a, 0.05, 0.1).unwrap();
+        c.add(&b, 0.05, 0.1).unwrap();
+        c.add(&b, 0.0333333, 0.2).unwrap();
+        c.add(&z, 0.05, -1.0).unwrap();
+        assert_eq!(c.ticks(), 4);
+        let rows = c.rows();
+        assert_eq!(
+            rows[0],
+            (
+                vec!["[30, 60]".to_string(), "heavy".to_string()],
+                2,
+                0.083,
+                0.3
+            )
+        );
+        // ties by labels: "[0, 30)" < ... ("heavy" < "none")
+        assert_eq!(rows[1].0, vec!["[0, 30)", "heavy"]);
+        assert_eq!(rows[1].3, 0.0); // negative displacement is not distance
+        assert_eq!(rows[2].0, vec!["[0, 30)", "none"]);
+        assert_eq!(
+            c.to_json()["rows"][0],
+            json!([["[30, 60]", "heavy"], 2, 0.083, 0.3])
+        );
+    }
+}

{openodd_py-0.2.2 → openodd_py-0.3.0}/src/items.rs

@@ -65,6 +65,16 @@ impl Default for Criteria {
 }
 
 impl Criteria {
+    /// The measure a bucket's coverage is read from: `cover_by`, or with a
+    /// `min_stay` the stays long enough to count (`counted.<cover_by>`).
+    pub fn amount(&self) -> String {
+        if self.min_stay.is_some() {
+            format!("counted.{}", self.cover_by)
+        } else {
+            self.cover_by.clone()
+        }
+    }
+
     /// Refuse a criterion that cannot be met or measured on `event`.
     pub fn check(&self, what: &str, event: &str) -> Result<()> {
         if !COVER_MEASURES.contains(&self.cover_by.as_str()) {
@@ -133,6 +143,8 @@ pub struct CoverItem {
     pub edges: Vec<f64>,
     /// Bucket labels, in order.
     pub labels: Vec<String>,
+    /// The ODD attribute the item buckets, when it is one's (`odd.<name>`).
+    pub attribute: Option<String>,
 }
 
 fn duplicates(names: &[String]) -> Vec<String> {
@@ -170,6 +182,7 @@ impl CoverItem {
             values: Vec::new(),
             edges: Vec::new(),
             labels: Vec::new(),
+            attribute: None,
         };
         let name = item.name.clone();
         match buckets {
@@ -267,8 +280,11 @@ impl CoverItem {
     }
 
     /// The item's definition, as written to a coverage file.
+    ///
+    /// `amount` names the measure a bucket's coverage is read from (see
+    /// [`Criteria::amount`]); `attribute` is there for an ODD attribute's item.
     pub fn describe(&self) -> Json {
-        json!({
+        let mut out = json!({
             "name": self.name,
             "group": self.group.as_str(),
             "text": self.text,
@@ -279,7 +295,12 @@ impl CoverItem {
             "target": number_json(self.criteria.target),
             "cover_by": self.criteria.cover_by,
             "min_stay": self.criteria.min_stay,
-        })
+            "amount": self.criteria.amount(),
+        });
+        if let Some(attribute) = &self.attribute {
+            out["attribute"] = json!(attribute);
+        }
+        out
     }
 }
 

{openodd_py-0.2.2 → openodd_py-0.3.0}/src/lib.rs

@@ -10,6 +10,7 @@
 // `!(x > 0.0)` is meant: it is true for NaN, which must be refused too.
 #![allow(clippy::neg_cmp_op_on_partial_ord)]
 
+pub mod cells;
 pub mod error;
 pub mod items;
 pub mod loader;

{openodd_py-0.2.2 → openodd_py-0.3.0}/src/model.rs

@@ -492,6 +492,7 @@ impl Attribute {
         )?;
         item.unit = self.unit.clone();
         item.text = self.text.clone();
+        item.attribute = Some(self.name.clone());
         self.item = Some(item);
         Ok(())
     }

{openodd_py-0.2.2 → openodd_py-0.3.0}/src/python.rs

@@ -251,6 +251,16 @@ impl Bucketing {
     fn group(&self) -> &'static str {
         self.inner.group.as_str()
     }
+    /// The ODD attribute the item buckets, when it is one's.
+    #[getter]
+    fn attribute(&self) -> Option<String> {
+        self.inner.attribute.clone()
+    }
+    /// The measure a bucket's coverage is read from.
+    #[getter]
+    fn amount(&self) -> String {
+        self.inner.criteria.amount()
+    }
 
     /// The label of the bucket `value` falls in.
     fn bucket_of(&self, value: &Bound<'_, PyAny>) -> PyResult<String> {
@@ -258,6 +268,51 @@ impl Bucketing {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Cells
+// ---------------------------------------------------------------------------
+
+/// Steps, seconds and metres per combination of an ODD's buckets.
+#[pyclass(module = "openodd._core")]
+struct Cells {
+    inner: crate::cells::CellCounter,
+}
+
+#[pymethods]
+impl Cells {
+    #[new]
+    fn new(odd: &Odd) -> Self {
+        Cells {
+            inner: crate::cells::CellCounter::new(&odd.inner),
+        }
+    }
+    /// The attributes with buckets: the labels of a cell, in order.
+    #[getter]
+    fn attributes(&self) -> Vec<String> {
+        self.inner.attributes.clone()
+    }
+    /// Steps counted so far.
+    #[getter]
+    fn ticks(&self) -> u64 {
+        self.inner.ticks()
+    }
+    /// The cell of one step (one value per attribute of the ODD, in order).
+    fn cell_of(&self, values: Vec<Bound<'_, PyAny>>) -> PyResult<Vec<String>> {
+        let values = values.iter().map(to_value).collect::<PyResult<Vec<_>>>()?;
+        self.inner.cell_of(&values).map_err(err)
+    }
+    /// Count one step that took `seconds` and covered `meters`.
+    #[pyo3(signature = (values, seconds=0.0, meters=0.0))]
+    fn add(&mut self, values: Vec<Bound<'_, PyAny>>, seconds: f64, meters: f64) -> PyResult<()> {
+        let values = values.iter().map(to_value).collect::<PyResult<Vec<_>>>()?;
+        self.inner.add(&values, seconds, meters).map_err(err)
+    }
+    /// `{"attributes": [...], "rows": [[[label, ...], ticks, seconds, meters], ...]}`.
+    fn to_json(&self) -> String {
+        self.inner.to_json().to_string()
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Conditions, attributes, modules
 // ---------------------------------------------------------------------------
@@ -1537,6 +1592,8 @@ fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add("CACHE_ENV", crate::sources::CACHE_ENV)?;
     m.add_class::<Undecided>()?;
     m.add_class::<Bucketing>()?;
+    m.add_class::<Cells>()?;
+    m.add("MISSING", crate::cells::MISSING)?;
     m.add_class::<Condition>()?;
     m.add_class::<Attribute>()?;
     m.add_class::<Module>()?;

{openodd_py-0.2.2 → openodd_py-0.3.0}/tests/differential/run.py

@@ -18,6 +18,9 @@ from typing import Any
 sys.path.insert(0, str(Path(__file__).parent))
 from cases import all_cases, contexts  # noqa: E402
 
+#: Keys of an item's definition the reference does not write.
+NEWER_KEYS = ("amount", "attribute")
+
 
 def plain(x: Any) -> Any:
     if isinstance(x, float):
@@ -60,7 +63,9 @@ def run(impl: str, case: dict[str, Any]) -> dict[str, Any]:
             for a in odd.attributes
         ],
         "modules": [m.describe() for m in odd.modules],
-        "situations": [m.item.describe() for m in odd.situations()],
+        # amount / attribute came after the reference: compare what both write.
+        "situations": [{k: v for k, v in m.item.describe().items() if k not in NEWER_KEYS}
+                       for m in odd.situations()],
         "unmeasured": odd.unmeasured(),
     }
     verdicts = []

openodd_py-0.3.0/tests/test_cells.py

@@ -0,0 +1,83 @@
+"""Cells: steps per combination of an ODD's buckets, bucketed as the items are."""
+
+from __future__ import annotations
+
+import enum
+
+import pytest
+
+import openodd
+from openodd import (
+    ABOVE_RANGE,
+    BELOW_RANGE,
+    MISSING,
+    CoverItem,
+    OddAttribute,
+    OddCells,
+    OddDefinition,
+    OddModule,
+    SamplingEvent,
+)
+
+
+class Rain(enum.Enum):
+    NONE = "none"
+    HEAVY = "heavy"
+
+
+def _odd() -> OddDefinition:
+    speed = OddAttribute("speed", lambda c: c["speed"], unit="km/h", buckets=[0, 30, 60],
+                         cover_by="seconds", min_stay=2)
+    free = OddAttribute("free", lambda c: c["free"])  # no buckets: not in a cell
+    rain = OddAttribute("rain", lambda c: c["rain"], values=list(Rain))
+    root = OddModule("root", include_and=[speed.less_than(60)])
+    return OddDefinition("cells", [speed, free, rain], [root])
+
+
+def test_a_cell_is_the_items_buckets():
+    odd = _odd()
+    cells = OddCells(odd)
+    assert cells.attributes == ["speed", "rain"]
+    speed, rain = (a.item for a in odd.attributes if a.item is not None)
+    for value in (0, 29.9, 30, 60):
+        assert cells.cell_of([value, 1, Rain.NONE])[0] == speed.bucket_of(value)
+    assert cells.cell_of([-1, None, Rain.HEAVY]) == [BELOW_RANGE, rain.bucket_of(Rain.HEAVY)]
+    assert cells.cell_of([61, None, None]) == [ABOVE_RANGE, MISSING]
+    assert cells.cell_of([None, None, "fog"]) == [MISSING, "fog"]
+    assert cells.cell_of({"speed": 10, "rain": Rain.NONE}) == ["[0, 30)", "NONE"]
+    with pytest.raises(ValueError):
+        cells.cell_of([1, 2])
+
+
+def test_cells_count_steps_seconds_and_metres():
+    cells = OddCells(_odd())
+    for _ in range(2):
+        cells.add([40, None, Rain.HEAVY], seconds=0.0333333, meters=0.5)
+    cells.add([10, None, Rain.NONE], seconds=0.05, meters=0.25)
+    cells.add([10, None, Rain.HEAVY], seconds=0.05)
+    assert cells.ticks == 4
+    assert cells.to_dict() == {
+        "attributes": ["speed", "rain"],
+        "rows": [
+            [["[30, 60]", "HEAVY"], 2, 0.067, 1.0],
+            [["[0, 30)", "HEAVY"], 1, 0.05, 0.0],  # ties by labels
+            [["[0, 30)", "NONE"], 1, 0.05, 0.25],
+        ],
+    }
+
+
+def test_items_say_their_attribute_and_amount():
+    odd = _odd()
+    speed = next(a.item for a in odd.attributes if a.name == "speed")
+    described = speed.describe()
+    assert described["attribute"] == "speed" and described["amount"] == "counted.seconds"
+    rain = next(a.item for a in odd.attributes if a.name == "rain").describe()
+    assert rain["attribute"] == "rain" and rain["amount"] == "hits"
+    plain = CoverItem("gap", lambda c: c, buckets=[0, 1], event=SamplingEvent.TICK,
+                      cover_by="meters")
+    assert plain.describe()["amount"] == "meters" and "attribute" not in plain.describe()
+    assert [i.describe()["attribute"] for i in odd.cover_items()] == ["speed", "rain"]
+
+
+def test_the_version_is_the_distributions():
+    assert openodd.__version__ and openodd.__version__[0].isdigit()