differt-core 0.9.1__tar.gz → 0.11.0__tar.gz

{differt_core-0.9.1 → differt_core-0.11.0}/Cargo.lock

@@ -247,7 +247,7 @@ checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
 
 [[package]]
 name = "differt-core"
-version = "0.9.1"
+version = "0.11.0"
 dependencies = [
  "criterion",
  "indexmap",

{differt_core-0.9.1 → differt_core-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differt-core
-Version: 0.9.1
+Version: 0.11.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{differt_core-0.9.1 → differt_core-0.11.0}/differt-core/Cargo.toml

@@ -37,5 +37,5 @@ unexpected_cfgs = {level = "warn", check-cfg = ['cfg(tarpaulin_include)']}
 edition = "2021"
 name = "differt-core"
 rust-version = "1.78.0"
-version = "0.9.1"
+version = "0.11.0"
 readme = "README.md"

{differt_core-0.9.1 → differt_core-0.11.0}/differt-core/benches/benchmarks/graph_iterators.rs

@@ -1,5 +1,5 @@
 use criterion::{Criterion, Throughput, black_box, criterion_group};
-use differt_core::rt::graph::{complete::CompleteGraph, directed::DiGraph};
+use differt_core::geometry::graph::{complete::CompleteGraph, directed::DiGraph};
 
 const NUM_NODES: usize = 1000;
 const DIRECT_PATH: bool = true;

differt_core-0.9.1/differt-core/src/geometry/triangle_mesh.rs → differt_core-0.11.0/differt-core/src/geometry/mesh.rs

@@ -1,4 +1,8 @@
-use std::{fs::File, io::BufReader, path::PathBuf};
+use std::{
+    fs::File,
+    io::BufReader,
+    path::{Path, PathBuf},
+};
 
 use indexmap::IndexMap;
 use numpy::{PyArray1, PyArray2, ndarray::arr2};
@@ -9,10 +13,10 @@ use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
 /// A lower-level mesh made of triangles.
 ///
 /// This class should not be used directly, prefer its higher-level version
-/// :class:`differt.geometry.TriangleMesh` instead.
+/// :class:`differt.geometry.Mesh` instead.
 #[derive(Clone, Debug, Default)]
-#[pyclass]
-pub(crate) struct TriangleMesh {
+#[pyclass(subclass)]
+pub(crate) struct Mesh {
     vertices: Vec<[f32; 3]>,
     triangles: Vec<[usize; 3]>,
     face_colors: Option<Vec<[f32; 3]>>,
@@ -77,7 +81,7 @@ impl ply::PropertyAccess for PlyFace {
     }
 }
 
-impl TriangleMesh {
+impl Mesh {
     pub fn get_material_index(&mut self, material_name: Option<String>) -> isize {
         if let Some(material_name) = material_name {
             return self
@@ -122,7 +126,7 @@ impl TriangleMesh {
 }
 
 #[pymethods]
-impl TriangleMesh {
+impl Mesh {
     /// :class:`Float[np.ndarray, 'num_vertices 3']<jaxtyping.Float>`: The array of triangle vertices.
     #[getter]
     fn vertices<'py>(&self, py: Python<'py>) -> Bound<'py, PyArray2<f32>> {
@@ -184,7 +188,7 @@ impl TriangleMesh {
     /// After calling this method, ``other`` will be empty.
     ///
     /// Args:
-    ///     other(TriangleMesh): The mesh to be appended to ``self``.
+    ///     other(Mesh): The mesh to be appended to ``self``.
     pub(crate) fn append(&mut self, other: &mut Self) {
         match (&self.face_colors, &other.face_colors) {
             (None, None) => {},
@@ -268,27 +272,53 @@ impl TriangleMesh {
     ///
     /// Currently, only vertices and triangles are loaded. Triangle normals
     /// are ignored because they are computed with
-    /// :attr:`differt.geometry.TriangleMesh.normals` using
+    /// :attr:`differt.geometry.Mesh.normals` using
     /// JAX so that they can be differentiated with respect to triangle
     /// vertices.
     ///
     /// Args:
-    ///     file (str): The path to the Wavefront .obj file.
+    ///     file (str | os.PathLike[str]): The path to the Wavefront .obj file.
     ///
     /// Returns:
-    ///     TriangleMesh: The corresponding mesh containing only triangles.
+    ///     Mesh: The corresponding mesh containing only triangles.
     #[classmethod]
-    pub(crate) fn load_obj(_: &Bound<'_, PyType>, filename: &str) -> PyResult<Self> {
-        let input = BufReader::new(File::open(filename)?);
+    #[pyo3(name = "load_obj")]
+    pub(crate) fn py_load_obj(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_obj(&file)
+    }
+
+    /// Load a triangle mesh from a Stanford PLY .ply file.
+    ///
+    /// Currently, only vertices and triangles are loaded. Triangle normals
+    /// are ignored because they are computed with
+    /// :attr:`differt.geometry.Mesh.normals` using
+    /// JAX so that they can be differentiated with respect to triangle
+    /// vertices.
+    ///
+    /// Args:
+    ///     file (str | os.PathLike[str]): The path to the Stanford PLY .ply file.
+    ///
+    /// Returns:
+    ///     Mesh: The corresponding mesh containing only triangles.
+    #[classmethod]
+    #[pyo3(name = "load_ply")]
+    pub(crate) fn py_load_ply(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_ply(&file)
+    }
+}
+
+impl Mesh {
+    pub(crate) fn load_obj(file: &Path) -> PyResult<Self> {
+        let input = BufReader::new(File::open(file)?);
         let mut obj: RawObj = parse_obj(input).map_err(|err| {
             PyValueError::new_err(format!(
-                "An error occurred while reading obj file {filename:#?}: {}",
+                "An error occurred while reading obj file {file:#?}: {}",
                 err
             ))
         })?;
 
         for material_file in obj.material_libraries.iter_mut() {
-            let mut path = PathBuf::from(filename);
+            let mut path = file.to_path_buf();
             path.set_file_name(&material_file);
             if let Some(path_str) = path.to_str() {
                 *material_file = path_str.to_string();
@@ -298,29 +328,15 @@ impl TriangleMesh {
         Ok(obj.into())
     }
 
-    /// Load a triangle mesh from a Stanford PLY .ply file.
-    ///
-    /// Currently, only vertices and triangles are loaded. Triangle normals
-    /// are ignored because they are computed with
-    /// :attr:`differt.geometry.TriangleMesh.normals` using
-    /// JAX so that they can be differentiated with respect to triangle
-    /// vertices.
-    ///
-    /// Args:
-    ///     file (str): The path to the Stanford PLY .ply file.
-    ///
-    /// Returns:
-    ///     TriangleMesh: The corresponding mesh containing only triangles.
-    #[classmethod]
-    pub(crate) fn load_ply(_: &Bound<'_, PyType>, filename: &str) -> PyResult<Self> {
-        let mut input = BufReader::new(File::open(filename)?);
+    pub(crate) fn load_ply(file: &Path) -> PyResult<Self> {
+        let mut input = BufReader::new(File::open(file)?);
 
         let vertex_parser = parser::Parser::<PlyVertex>::new();
         let face_parser = parser::Parser::<PlyFace>::new();
 
         let header = vertex_parser.read_header(&mut input).map_err(|err| {
             PyValueError::new_err(format!(
-                "An error occurred while reading the header of ply file {filename:#?}: {}",
+                "An error occurred while reading the header of ply file {file:#?}: {}",
                 err
             ))
         })?;
@@ -337,7 +353,7 @@ impl TriangleMesh {
                             .map_err(|err| {
                                 PyValueError::new_err(format!(
                                     "An error occurred while reading the vertex elements of ply \
-                                     file {filename:#?}: {}",
+                                     file {file:#?}: {}",
                                     err
                                 ))
                             })?
@@ -352,7 +368,7 @@ impl TriangleMesh {
                             .map_err(|err| {
                                 PyValueError::new_err(format!(
                                     "An error occurred while reading the face elements of PLY \
-                                     file {filename:#?}: {}",
+                                     file {file:#?}: {}",
                                     err
                                 ))
                             })?
@@ -380,7 +396,7 @@ impl TriangleMesh {
     }
 }
 
-impl From<RawObj> for TriangleMesh {
+impl From<RawObj> for Mesh {
     fn from(mut raw_obj: RawObj) -> Self {
         use obj::raw::object::Polygon::*;
 
@@ -503,7 +519,7 @@ impl From<RawObj> for TriangleMesh {
 
 #[cfg(not(tarpaulin_include))]
 #[pymodule(gil_used = false)]
-pub(crate) fn triangle_mesh(m: Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<TriangleMesh>()?;
+pub(crate) fn mesh(m: Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<Mesh>()?;
     Ok(())
 }

differt_core-0.11.0/differt-core/src/geometry/mod.rs

@@ -0,0 +1,16 @@
+use pyo3::{prelude::*, wrap_pymodule};
+
+pub mod graph;
+pub mod mesh;
+pub mod scene;
+pub mod sionna;
+
+#[cfg(not(tarpaulin_include))]
+#[pymodule(gil_used = false)]
+pub(crate) fn geometry(m: Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pymodule!(graph::graph))?;
+    m.add_wrapped(wrap_pymodule!(mesh::mesh))?;
+    m.add_wrapped(wrap_pymodule!(scene::scene))?;
+    m.add_wrapped(wrap_pymodule!(sionna::sionna))?;
+    Ok(())
+}

differt_core-0.11.0/differt-core/src/geometry/scene.rs

@@ -0,0 +1,78 @@
+use std::path::{Path, PathBuf};
+
+use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
+
+use super::sionna::SionnaScene;
+use crate::geometry::mesh::Mesh;
+
+/// A scene that contains one mesh, usually being the results of multiple call to :meth:`Mesh.append<differt_core.geometry.Mesh.append>`.
+///
+/// This class is only useful to provide a fast constructor for scenes
+/// created using the Sionna file format.
+#[derive(Clone)]
+#[pyclass(subclass)]
+struct Scene {
+    /// differt_core.geometry.Mesh: The scene mesh.
+    #[pyo3(get)]
+    mesh: Mesh,
+}
+
+#[pymethods]
+impl Scene {
+    /// Load a scene from a Sionna-compatible XML file.
+    ///
+    /// Args:
+    ///     file (str | os.PathLike[str]): The path to the XML file.
+    ///
+    /// Returns:
+    ///     Scene: The corresponding scene.
+    #[classmethod]
+    #[pyo3(name = "load_xml")]
+    fn py_load_xml(_cls: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_xml(&file)
+    }
+}
+impl Scene {
+    fn load_xml(file: &Path) -> PyResult<Self> {
+        let sionna = SionnaScene::load_xml(&file)?;
+
+        let folder = file.parent().ok_or_else(|| {
+            PyValueError::new_err(format!(
+                "Could not determine parent folder of file: {file:#?}",
+            ))
+        })?;
+
+        let mut mesh = Mesh::default();
+
+        for (_, shape) in sionna.shapes.into_iter() {
+            let mesh_file_path = folder.join(shape.file);
+            let mut other_mesh = match shape.r#type.as_str() {
+                "obj" => Mesh::load_obj(&mesh_file_path)?,
+                "ply" => Mesh::load_ply(&mesh_file_path)?,
+                ty => {
+                    log::warn!("Unsupported shape type {ty}, skipping.");
+                    continue;
+                },
+            };
+
+            let material = sionna.materials.get(&shape.material_id);
+
+            let color = material.map(|mat| mat.color);
+
+            let material_name = material.map(|mat| mat.name.clone());
+
+            other_mesh.set_face_color(color.as_ref());
+            other_mesh.set_face_material(material_name);
+
+            mesh.append(&mut other_mesh);
+        }
+        Ok(Self { mesh })
+    }
+}
+
+#[cfg(not(tarpaulin_include))]
+#[pymodule(gil_used = false)]
+pub(crate) fn scene(m: Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<Scene>()?;
+    Ok(())
+}

{differt_core-0.9.1/src/scene → differt_core-0.11.0/differt-core/src/geometry}/sionna.rs

@@ -1,4 +1,8 @@
-use std::{fs::File, io::BufReader};
+use std::{
+    fs::File,
+    io::BufReader,
+    path::{Path, PathBuf},
+};
 
 use indexmap::IndexMap;
 use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
@@ -8,9 +12,9 @@ use serde::{Deserialize, de};
 ///
 /// Only a subset of the XML file is actually used.
 ///
-/// This class is useless unless converted
-/// to another scene type, like
-/// :class:`TriangleScene<differt.scene.TriangleScene>`.
+/// This scene acts as a bridge between Sionna and DiffeRT,
+/// and is essentially used to quickly load scenes from Sionna
+/// and export them as a :class:`Scene<differt.geometry.Scene>`.
 ///
 /// Warning:
 ///     We are still open to better ways to parse those XML files,
@@ -248,7 +252,7 @@ impl<'de> Deserialize<'de> for Material {
                 let color = match r#type.as_str() {
                     // Copied from Sionna-RT's code, to match their colors:
                     // https://github.com/NVlabs/sionna-rt/blob/main/src/sionna/rt/radio_materials/itu_material.py
-                    // v1.0.0
+                    "vacuum" => [0.8, 0.8, 0.8],
                     "marble" => [0.701, 0.644, 0.485],
                     "concrete" => [0.539, 0.539, 0.539],
                     "wood" => [0.266, 0.109, 0.060],
@@ -263,6 +267,10 @@ impl<'de> Deserialize<'de> for Material {
                     "very_dry_ground" => [0.539, 0.319, 0.223],
                     "medium_dry_ground" => [0.539, 0.181, 0.076],
                     "wet_ground" => [0.539, 0.027, 0.147],
+                    "clear_acrylic" => [0.8, 0.9, 0.95],
+                    "vinyl_tile" => [0.75, 0.75, 0.72],
+                    "carpet_tile" => [0.32, 0.35, 0.42],
+                    "asphalt_concrete" => [0.18, 0.18, 0.18],
                     _ => {
                         log::warn!(
                             "unknown material type: {type:#?}, using default color, i.e., black",
@@ -353,12 +361,19 @@ impl SionnaScene {
     /// Load a Sionna scene from a XML file.
     ///
     /// Args:
-    ///     file (str): The path to the XML file.
+    ///     file (os.PathLike[str] | str): The path to the XML file.
     ///
     /// Returns:
     ///     SionnaScene: The corresponding scene.
     #[classmethod]
-    pub(crate) fn load_xml(_: &Bound<'_, PyType>, file: &str) -> PyResult<Self> {
+    #[pyo3(name = "load_xml")]
+    pub(crate) fn py_load_xml(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_xml(&file)
+    }
+}
+
+impl SionnaScene {
+    pub(crate) fn load_xml(file: &Path) -> PyResult<Self> {
         let input = BufReader::new(File::open(file)?);
         quick_xml::de::from_reader(input).map_err(|err| {
             PyValueError::new_err(format!(
@@ -662,6 +677,76 @@ mod tests {
         assert_eq!(material.color, [0.539, 0.027, 0.147]);
     }
 
+    #[test]
+    fn deserializes_itu_vacuum() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="vacuum">
+                <string name="type" value="vacuum"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_vacuum");
+        assert_eq!(material.color, [0.8, 0.8, 0.8]);
+    }
+
+    #[test]
+    fn deserializes_itu_clear_acrylic() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="acrylic">
+                <string name="type" value="clear_acrylic"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_clear_acrylic");
+        assert_eq!(material.color, [0.8, 0.9, 0.95]);
+    }
+
+    #[test]
+    fn deserializes_itu_vinyl_tile() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="vinyl">
+                <string name="type" value="vinyl_tile"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_vinyl_tile");
+        assert_eq!(material.color, [0.75, 0.75, 0.72]);
+    }
+
+    #[test]
+    fn deserializes_itu_carpet_tile() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="carpet">
+                <string name="type" value="carpet_tile"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_carpet_tile");
+        assert_eq!(material.color, [0.32, 0.35, 0.42]);
+    }
+
+    #[test]
+    fn deserializes_itu_asphalt_concrete() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="asphalt">
+                <string name="type" value="asphalt_concrete"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_asphalt_concrete");
+        assert_eq!(material.color, [0.18, 0.18, 0.18]);
+    }
+
     #[test]
     fn deserializes_itu_unknown_type() {
         let xml = r#"

{differt_core-0.9.1 → differt_core-0.11.0/differt-core}/src/lib.rs

@@ -1,8 +1,6 @@
 use pyo3::{prelude::*, wrap_pymodule};
 
 pub mod geometry;
-pub mod rt;
-pub mod scene;
 
 /// Core of DiffeRT module, implemented in Rust.
 #[cfg(not(tarpaulin_include))]
@@ -20,7 +18,5 @@ fn _differt_core(m: Bound<'_, PyModule>) -> PyResult<()> {
     );
     m.add("__version_info__", version_info)?;
     m.add_wrapped(wrap_pymodule!(geometry::geometry))?;
-    m.add_wrapped(wrap_pymodule!(rt::rt))?;
-    m.add_wrapped(wrap_pymodule!(scene::scene))?;
     Ok(())
 }

differt_core-0.11.0/differt-core/tests/geometry/test_core_mesh.py

@@ -0,0 +1,11 @@
+import pytest
+
+
+def test_triangle_mesh_deprecated() -> None:
+    from differt_core.geometry import (  # ruff:ignore[import-outside-top-level]
+        TriangleMesh,
+    )
+
+    with pytest.warns(DeprecationWarning, match="TriangleMesh is deprecated"):
+        with pytest.raises(TypeError):
+            TriangleMesh()

differt_core-0.11.0/differt-core/tests/geometry/test_core_scene.py

@@ -0,0 +1,11 @@
+import pytest
+
+
+def test_triangle_scene_deprecated() -> None:
+    from differt_core.geometry import (  # ruff:ignore[import-outside-top-level]
+        TriangleScene,
+    )
+
+    with pytest.warns(DeprecationWarning, match="TriangleScene is deprecated"):
+        with pytest.raises(TypeError):
+            TriangleScene()

{differt_core-0.9.1/differt-core/tests/rt → differt_core-0.11.0/differt-core/tests/geometry}/test_graph.py

@@ -1,10 +1,9 @@
-import logging
 import re
 
 import numpy as np
 import pytest
 
-from differt_core.rt._graph import (
+from differt_core.geometry._graph import (
     CompleteGraph,
     DiGraph,
 )
@@ -27,7 +26,7 @@ class TestDiGraph:
             TypeError,
             match="takes 0 positional arguments but 1 was given",
         ):
-            _ = graph.insert_from_and_to_nodes(True)  # noqa: FBT003
+            _ = graph.insert_from_and_to_nodes(True)  # ruff:ignore[boolean-positional-value-in-call]
 
     @pytest.mark.parametrize("fast_mode", [True, False])
     def test_disconnect_nodes(self, fast_mode: bool) -> None:
@@ -154,7 +153,7 @@ class TestDiGraph:
             TypeError,
             match="takes 3 positional arguments but 4 were given",
         ):
-            _ = graph.all_paths(0, 1, 0, True)  # noqa: FBT003
+            _ = graph.all_paths(0, 1, 0, True)  # ruff:ignore[boolean-positional-value-in-call]
 
     @pytest.mark.parametrize(
         ("num_nodes", "depth"),
@@ -197,29 +196,3 @@ class TestDiGraph:
         assert num_paths == num_nodes * (num_nodes - 1) ** (depth - 1)
         array = graph.all_paths_array(from_, to, depth + 2, include_from_and_to=False)
         assert array.shape == (num_paths, depth)
-
-    @pytest.mark.parametrize(
-        ("num_nodes", "depth"),
-        [
-            (10, 100),
-            (50_000, 10),
-        ],
-    )
-    def test_all_paths_count_from_complete_graph_overflow(
-        self,
-        num_nodes: int,
-        depth: int,
-        caplog: pytest.LogCaptureFixture,
-    ) -> None:
-        graph = CompleteGraph(num_nodes)
-        from_, to = num_nodes, num_nodes + 1
-
-        caplog.clear()
-
-        with caplog.at_level(logging.WARNING):
-            _ = graph.all_paths(from_, to, depth + 2, include_from_and_to=False)
-
-            assert (
-                "OverflowError: overflow occurred when computing the total number of paths"
-                in caplog.text
-            )

{differt_core-0.9.1/python/differt_core/_differt_core/rt → differt_core-0.11.0/python/differt_core/_differt_core/geometry}/graph.pyi

@@ -1,4 +1,3 @@
-# pyright: reportMissingTypeArgument=false
 from collections.abc import Iterator, Sized
 
 import numpy as np

differt_core-0.9.1/python/differt_core/_differt_core/geometry/triangle_mesh.pyi → differt_core-0.11.0/python/differt_core/_differt_core/geometry/mesh.pyi

@@ -1,8 +1,9 @@
-# pyright: reportMissingTypeArgument=false
+from os import PathLike
+
 import numpy as np
 from jaxtyping import Float, Int, UInt
 
-class TriangleMesh:
+class Mesh:
     vertices: Float[np.ndarray, "num_vertices 3"]
     triangles: UInt[np.ndarray, "num_triangles 3"]
     face_colors: Float[np.ndarray, "num_triangles 3"] | None
@@ -10,8 +11,8 @@ class TriangleMesh:
     material_names: list[str]
     object_bounds: UInt[np.ndarray, "num_objects 2"] | None
 
-    def append(self, other: TriangleMesh) -> None: ...
+    def append(self, other: Mesh) -> None: ...
     @classmethod
-    def load_obj(cls, file: str) -> TriangleMesh: ...
+    def load_obj(cls, file: str | PathLike[str]) -> Mesh: ...
     @classmethod
-    def load_ply(cls, file: str) -> TriangleMesh: ...
+    def load_ply(cls, file: str | PathLike[str]) -> Mesh: ...

differt_core-0.11.0/python/differt_core/_differt_core/geometry/scene.pyi

@@ -0,0 +1,9 @@
+from os import PathLike
+
+from differt_core.geometry import TriangleMesh
+
+class Scene:
+    mesh: list[TriangleMesh]
+
+    @classmethod
+    def load_xml(cls, file: str | PathLike[str]) -> Scene: ...

{differt_core-0.9.1/python/differt_core/_differt_core/scene → differt_core-0.11.0/python/differt_core/_differt_core/geometry}/sionna.pyi

@@ -1,9 +1,11 @@
+from os import PathLike
+
 class SionnaScene:
     shapes: dict[str, Shape]
     materials: dict[str, Material]
 
     @classmethod
-    def load_xml(cls, file: str) -> SionnaScene: ...
+    def load_xml(cls, file: str | PathLike[str]) -> SionnaScene: ...
 
 class Material:
     name: str

{differt_core-0.9.1/python/differt_core/rt → differt_core-0.11.0/python/differt_core/geometry}/__init__.py

@@ -1,4 +1,4 @@
-"""Ray Tracing utilities used by :mod:`differt.rt`."""
+"""Geometry utilities used by :mod:`differt.geometry`."""
 
 __all__ = (
     "AllPathsFromCompleteGraphChunksIter",
@@ -7,6 +7,13 @@ __all__ = (
     "AllPathsFromDiGraphIter",
     "CompleteGraph",
     "DiGraph",
+    "Material",
+    "Mesh",
+    "Scene",
+    "Shape",
+    "SionnaScene",
+    "TriangleMesh",
+    "TriangleScene",
 )
 
 from ._graph import (
@@ -17,3 +24,6 @@ from ._graph import (
     CompleteGraph,
     DiGraph,
 )
+from ._mesh import Mesh, TriangleMesh
+from ._scene import Scene, TriangleScene
+from ._sionna import Material, Shape, SionnaScene

differt_core-0.11.0/python/differt_core/geometry/_graph.py

@@ -0,0 +1,23 @@
+__all__ = (
+    "AllPathsFromCompleteGraphChunksIter",
+    "AllPathsFromCompleteGraphIter",
+    "AllPathsFromDiGraphChunksIter",
+    "AllPathsFromDiGraphIter",
+    "CompleteGraph",
+    "DiGraph",
+)
+
+from differt_core import _differt_core
+
+AllPathsFromCompleteGraphChunksIter = (
+    _differt_core.geometry.graph.AllPathsFromCompleteGraphChunksIter
+)
+AllPathsFromCompleteGraphIter = (
+    _differt_core.geometry.graph.AllPathsFromCompleteGraphIter
+)
+AllPathsFromDiGraphChunksIter = (
+    _differt_core.geometry.graph.AllPathsFromDiGraphChunksIter
+)
+AllPathsFromDiGraphIter = _differt_core.geometry.graph.AllPathsFromDiGraphIter
+CompleteGraph = _differt_core.geometry.graph.CompleteGraph
+DiGraph = _differt_core.geometry.graph.DiGraph