Add more bindings and tests (#444)

* Add more bindings and tests

* Copilot fixes

Author: Grufoony

.github/workflows/pytest.yml

@@ -26,12 +26,12 @@ jobs:
         sudo apt update
         sudo apt install -y cmake build-essential doxygen libtbb-dev
         python -m pip install --upgrade pip
-        pip install pytest pytest-cov
+        pip install pytest pytest-cov pandas polars
     
     - name: Install package
       run: |
         pip install -e .
     
     - name: Run tests with pytest
       run: |
-        pytest test/*py -v --cov=src/dsf --cov-report=term-missing
+        pytest test -v --cov=src/dsf --cov-report=term-missing -o "python_files=Test_*.py test_*.py Bind_*.py"

src/dsf/bindings.cpp

@@ -78,6 +78,45 @@ PYBIND11_MODULE(dsf_cpp, m) {
 
   m.def("get_log_level", &spdlog::get_level, "Get the current global log level");
 
+  // Bind Street class to mobility submodule
+  pybind11::class_<dsf::mobility::Street>(mobility, "Street")
+      .def(
+          "id", &dsf::mobility::Street::id, dsf::g_docstrings.at("dsf::Edge::id").c_str())
+      .def("source",
+           &dsf::mobility::Street::source,
+           dsf::g_docstrings.at("dsf::Edge::source").c_str())
+      .def("target",
+           &dsf::mobility::Street::target,
+           dsf::g_docstrings.at("dsf::Edge::target").c_str())
+      .def("geometry",
+           &dsf::mobility::Street::geometry,
+           dsf::g_docstrings.at("dsf::Edge::geometry").c_str())
+      .def("name",
+           &dsf::mobility::Street::name,
+           dsf::g_docstrings.at("dsf::mobility::Road::name").c_str())
+      .def("length",
+           &dsf::mobility::Street::length,
+           dsf::g_docstrings.at("dsf::mobility::Road::length").c_str())
+      .def("maxSpeed",
+           &dsf::mobility::Street::maxSpeed,
+           dsf::g_docstrings.at("dsf::mobility::Road::maxSpeed").c_str());
+
+  // Bind RoadJunction class to mobility submodule
+  pybind11::class_<dsf::mobility::RoadJunction>(mobility, "RoadJunction")
+      .def("id",
+           &dsf::mobility::RoadJunction::id,
+           dsf::g_docstrings.at("dsf::Node::id").c_str())
+      .def("geometry",
+           &dsf::mobility::RoadJunction::geometry,
+           dsf::g_docstrings.at("dsf::Node::geometry").c_str())
+      .def("capacity",
+           &dsf::mobility::RoadJunction::capacity,
+           dsf::g_docstrings.at("dsf::mobility::RoadJunction::capacity").c_str())
+      .def(
+          "transportCapacity",
+          &dsf::mobility::RoadJunction::transportCapacity,
+          dsf::g_docstrings.at("dsf::mobility::RoadJunction::transportCapacity").c_str());
+
   // Bind Measurement to main module (can be used across different contexts)
   pybind11::class_<dsf::Measurement<double>>(m, "Measurement")
       .def(pybind11::init<double, double, std::size_t>(),
@@ -120,6 +159,21 @@ PYBIND11_MODULE(dsf_cpp, m) {
       .def("nTrafficLights",
            &dsf::mobility::RoadNetwork::nTrafficLights,
            dsf::g_docstrings.at("dsf::mobility::RoadNetwork::nTrafficLights").c_str())
+      // Bind node and edge Network accessors, which return a ref or a cost ref
+      // node should return a RoadJunction and edge should return a Street
+      .def(
+          "node",
+          static_cast<dsf::mobility::RoadJunction& (
+              dsf::mobility::RoadNetwork::*)(dsf::Id)>(&dsf::mobility::RoadNetwork::node),
+          pybind11::arg("nodeId"),
+          pybind11::return_value_policy::reference_internal,
+          dsf::g_docstrings.at("dsf::Network::node").c_str())
+      .def("edge",
+           static_cast<dsf::mobility::Street& (dsf::mobility::RoadNetwork::*)(dsf::Id)>(
+               &dsf::mobility::RoadNetwork::edge),
+           pybind11::arg("edgeId"),
+           pybind11::return_value_policy::reference_internal,
+           dsf::g_docstrings.at("dsf::Network::edge").c_str())
       .def("capacity",
            &dsf::mobility::RoadNetwork::capacity,
            dsf::g_docstrings.at("dsf::mobility::RoadNetwork::capacity").c_str())
@@ -470,7 +524,6 @@ PYBIND11_MODULE(dsf_cpp, m) {
                 self.setSpeedFunction(
                     dsf::SpeedFunction::CUSTOM,
                     [func_ptr](dsf::mobility::Street const& street) -> double {
-                      // No GIL needed — this is pure C
                       return func_ptr(street.maxSpeed(), street.density(true));
                     });
                 break;
@@ -499,9 +552,9 @@ PYBIND11_MODULE(dsf_cpp, m) {
       .def(
           "setInitTime",
           [](dsf::mobility::FirstOrderDynamics& self, pybind11::object datetime_obj) {
-            auto const epoch =
-                pybind11::cast<std::time_t>(datetime_obj.attr("timestamp")());
-            self.setInitTime(epoch);
+            auto const epoch_seconds =
+                pybind11::cast<double>(datetime_obj.attr("timestamp")());
+            self.setInitTime(static_cast<std::time_t>(epoch_seconds));
           },
           pybind11::arg("datetime"),
           dsf::g_docstrings.at("dsf::Dynamics::setInitTime").c_str())

test/bindings/Test_bindings_core.py

@@ -0,0 +1,45 @@
+import dsf
+import dsf_cpp
+import pytest
+
+
+def test_root_module_reexports_cpp_bindings():
+    assert dsf.__version__ == dsf_cpp.__version__
+    assert dsf.mobility is dsf_cpp.mobility
+    assert dsf.mdt is dsf_cpp.mdt
+    assert hasattr(dsf_cpp, "Measurement")
+
+
+def test_log_level_round_trip():
+    original_level = dsf.get_log_level()
+    try:
+        dsf.set_log_level(dsf.LogLevel.DEBUG)
+        assert dsf.get_log_level() == dsf.LogLevel.DEBUG
+
+        dsf.set_log_level(dsf.LogLevel.INFO)
+        assert dsf.get_log_level() == dsf.LogLevel.INFO
+    finally:
+        dsf.set_log_level(original_level)
+
+
+def test_log_to_file_accepts_string_path(tmp_path):
+    dsf.log_to_file(str(tmp_path / "dsf_bindings.log"))
+
+
+def test_measurement_properties_are_mutable():
+    measurement = dsf_cpp.Measurement(12.5, 3.0, 10)
+
+    assert measurement.mean == pytest.approx(12.5)
+    assert measurement.std == pytest.approx(3.0)
+    assert measurement.n == 10
+    assert isinstance(measurement.is_valid, bool)
+
+    measurement.mean = 7.25
+    measurement.std = 1.5
+    measurement.n = 4
+    measurement.is_valid = False
+
+    assert measurement.mean == pytest.approx(7.25)
+    assert measurement.std == pytest.approx(1.5)
+    assert measurement.n == 4
+    assert measurement.is_valid is False

test/bindings/Test_bindings_mdt.py

@@ -0,0 +1,65 @@
+import numpy as np
+import pytest
+
+from dsf import mdt
+
+EXPECTED_COLUMNS = [
+    "uid",
+    "trajectory_id",
+    "lon",
+    "lat",
+    "timestamp_in",
+    "timestamp_out",
+]
+
+
+class InvalidShapeFrame:
+    columns = ["uid", "timestamp", "lat", "lon"]
+
+    def to_numpy(self):
+        return np.array([1.0, 2.0, 3.0], dtype=np.float64)
+
+
+def test_trajectory_collection_from_pandas_to_pandas(trajectory_pandas_df):
+    collection = mdt.TrajectoryCollection(trajectory_pandas_df)
+    collection.filter(0.5, 150.0, 0)
+
+    result = collection.to_pandas()
+
+    assert list(result.columns) == EXPECTED_COLUMNS
+    assert len(result) > 0
+    assert {1, 2}.issubset(set(result["uid"].astype(int).tolist()))
+
+
+def test_trajectory_collection_from_polars_to_polars(trajectory_polars_df):
+    polars = pytest.importorskip("polars")
+
+    collection = mdt.TrajectoryCollection(trajectory_polars_df)
+    collection.filter(0.5, 150.0, 0)
+
+    result = collection.to_polars()
+
+    assert isinstance(result, polars.DataFrame)
+    assert result.columns == EXPECTED_COLUMNS
+    assert result.height > 0
+    assert {1, 2}.issubset(set(result["uid"].cast(polars.Int64).to_list()))
+
+
+def test_trajectory_collection_to_csv_writes_expected_header(
+    trajectory_pandas_df, tmp_path
+):
+    collection = mdt.TrajectoryCollection(trajectory_pandas_df)
+    collection.filter(0.5, 150.0, 0)
+
+    output_file = tmp_path / "trajectory_export.csv"
+    collection.to_csv(str(output_file))
+
+    assert output_file.exists()
+
+    header = output_file.read_text(encoding="utf-8").splitlines()[0]
+    assert header == "uid;trajectory_id;lon;lat;timestamp_in;timestamp_out"
+
+
+def test_trajectory_collection_rejects_non_2d_numpy_input():
+    with pytest.raises(RuntimeError, match="2D numpy array"):
+        mdt.TrajectoryCollection(InvalidShapeFrame())

test/bindings/Test_bindings_mobility.py

@@ -0,0 +1,84 @@
+from datetime import datetime, timezone
+
+import numpy as np
+import pytest
+
+from dsf import mobility
+
+
+def test_road_network_import_counts(loaded_road_network):
+    assert loaded_road_network.nNodes() == 120
+    assert loaded_road_network.nEdges() == 436
+
+
+def test_shortest_path_returns_path_collection(loaded_road_network):
+    path_map = loaded_road_network.shortestPath(0, 119, mobility.PathWeight.LENGTH)
+
+    assert isinstance(path_map, mobility.PathCollection)
+    assert len(path_map) > 0
+    assert 0 in path_map
+    assert 119 not in path_map
+    assert isinstance(path_map[0], list)
+    assert len(path_map[0]) > 0
+
+
+def test_path_collection_dict_protocol_and_explode():
+    path_collection = mobility.PathCollection()
+
+    assert len(path_collection) == 0
+
+    path_collection[0] = [1]
+    path_collection[1] = [2]
+
+    assert 0 in path_collection
+    assert path_collection[0] == [1]
+    assert set(path_collection.keys()) == {0, 1}
+    assert path_collection.items() == {0: [1], 1: [2]}
+
+    all_paths = path_collection.explode(0, 2)
+    assert all_paths == [[0, 1, 2]]
+
+    with pytest.raises(KeyError):
+        _ = path_collection[99]
+
+
+def test_dynamics_set_init_time_accepts_epoch_and_datetime(dynamics):
+    epoch = 1_700_000_000
+    dynamics.setInitTime(epoch)
+    assert dynamics.time() == epoch
+
+    dt = datetime.fromtimestamp(epoch + 3600, tz=timezone.utc)
+    dynamics.setInitTime(dt)
+    assert dynamics.time() == int(dt.timestamp())
+
+
+def test_dynamics_accepts_origin_destination_overloads(dynamics):
+    node_array = np.array([0, 1, 2], dtype=np.uint64)
+
+    dynamics.setDestinationNodes([0, 1, 2])
+    dynamics.setDestinationNodes({0: 0.6, 1: 0.4})
+    dynamics.setDestinationNodes(node_array)
+
+    dynamics.setOriginNodes({0: 1.0, 1: 1.0, 2: 1.0})
+    dynamics.setOriginNodes(node_array)
+
+
+def test_dynamics_smoke_step_with_linear_speed(dynamics):
+    dynamics.setWeightFunction(mobility.PathWeight.LENGTH)
+    dynamics.setSpeedFunction(mobility.SpeedFunction.LINEAR, 0.8)
+    dynamics.setDestinationNodes([0, 1, 2])
+    dynamics.setOriginNodes({3: 1.0, 4: 1.0, 5: 1.0})
+
+    dynamics.updatePaths()
+    dynamics.addAgentsUniformly(1)
+
+    assert dynamics.nAgents() == 1
+
+    previous_step = dynamics.time_step()
+    dynamics.evolve(False)
+    assert dynamics.time_step() == previous_step + 1
+
+
+def test_compute_betweenness_rejects_invalid_weight(loaded_road_network):
+    with pytest.raises(Exception, match="Invalid weight function"):
+        loaded_road_network.computeBetweennessCentralities("invalid")

test/bindings/conftest.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+
+import pytest
+
+from dsf import mobility
+
+TEST_DATA_DIR = Path(__file__).resolve().parents[1] / "data"
+MANHATTAN_EDGES = TEST_DATA_DIR / "manhattan_edges.csv"
+MANHATTAN_NODES = TEST_DATA_DIR / "manhattan_nodes.csv"
+
+
+@pytest.fixture(scope="session")
+def manhattan_edges_path() -> Path:
+    return MANHATTAN_EDGES
+
+
+@pytest.fixture(scope="session")
+def manhattan_nodes_path() -> Path:
+    return MANHATTAN_NODES
+
+
+@pytest.fixture()
+def empty_road_network():
+    return mobility.RoadNetwork()
+
+
+@pytest.fixture()
+def loaded_road_network(manhattan_edges_path: Path, manhattan_nodes_path: Path):
+    network = mobility.RoadNetwork()
+    network.importEdges(str(manhattan_edges_path), ";")
+    network.importNodeProperties(str(manhattan_nodes_path), ";")
+    return network
+
+
+@pytest.fixture()
+def dynamics(loaded_road_network):
+    return mobility.Dynamics(loaded_road_network, seed=69)
+
+
+@pytest.fixture()
+def trajectory_rows():
+    return {
+        "uid": [1, 1, 1, 2, 2, 2],
+        "timestamp": [1000, 1600, 2200, 1000, 1600, 2200],
+        "lat": [44.4949, 44.4950, 44.4951, 45.4064, 45.4065, 45.4066],
+        "lon": [11.3426, 11.3427, 11.3428, 11.8767, 11.8768, 11.8769],
+    }
+
+
+@pytest.fixture()
+def trajectory_pandas_df(trajectory_rows):
+    pandas = pytest.importorskip("pandas")
+    return pandas.DataFrame(trajectory_rows)
+
+
+@pytest.fixture()
+def trajectory_polars_df(trajectory_rows):
+    polars = pytest.importorskip("polars")
+    return polars.DataFrame(trajectory_rows)