Merge remote-tracking branch 'upstream/main'

quaquel · quaquel · commit 3aa468dceacf · 2026-01-26T10:50:06.000+01:00
diff --git a/mesa/experimental/devs/simulator.py b/mesa/experimental/devs/simulator.py
@@ -57,13 +57,19 @@ def __init__(self, time_unit: type, start_time: int | float):
             time_unit: type of the smulaiton time
             start_time: the starttime of the simulator
         """
-        # should model run in a separate thread,
-        # and we can then interact with start, stop, run_until, and step?
-        self.event_list = EventList()
         self.start_time = start_time
         self.time_unit = time_unit
         self.model: Model | None = None
 
+    @property
+    def event_list(self) -> EventList:
+        """Return the event list from the model."""
+        if self.model is None:
+            raise RuntimeError(
+                "Simulator not set up. Call simulator.setup(model) first."
+            )
+        return self.model._event_list
+
     @property
     def time(self) -> float:
         """Simulator time (deprecated)."""
@@ -92,19 +98,18 @@ def setup(self, model: Model) -> None:
                 f"Model time ({model.time}) does not match simulator start_time ({self.start_time}). "
                 "Has the model already been run?"
             )
-        if not self.event_list.is_empty():
+        if not model._event_list.is_empty():
             raise ValueError("Events already scheduled. Call setup before scheduling.")
 
         self.model = model
         model._simulator = self  # Register simulator with model
 
     def reset(self):
         """Reset the simulator."""
-        self.event_list.clear()
         if self.model is not None:
+            self.event_list.clear()
             self.model._simulator = None
             self.model.time = self.start_time
-            self.model = None
 
     def run_until(self, end_time: int | float) -> None:
         """Run the simulator until the end time.
@@ -121,20 +126,7 @@ def run_until(self, end_time: int | float) -> None:
                 "Simulator not set up. Call simulator.setup(model) first."
             )
 
-        while True:
-            try:
-                event = self.event_list.pop_event()
-            except IndexError:
-                self.model.time = end_time
-                break
-
-            if event.time <= end_time:
-                self.model.time = event.time
-                event.execute()
-            else:
-                self.model.time = end_time
-                self._schedule_event(event)
-                break
+        self.model._advance_time(end_time)
 
     def run_next_event(self):
         """Execute the next event.
@@ -167,14 +159,11 @@ def run_for(self, time_delta: int | float):
             Exception if simulator.setup() has not yet been called
 
         """
-        try:
-            end_time = self.model.time + time_delta
-        except AttributeError as e:
+        if self.model is None:
             raise RuntimeError(
                 "Simulator not set up. Call simulator.setup(model) first."
-            ) from e
-        else:
-            self.run_until(end_time)
+            )
+        self.run_until(self.model.time + time_delta)
 
     def schedule_event_now(
         self,
@@ -290,7 +279,6 @@ def _schedule_event(self, event: SimulationEvent):
                 f"time unit mismatch {event.time} is not of time unit {self.time_unit}"
             )
 
-        # check timeunit of events
         self.event_list.add_event(event)
 
 
@@ -316,7 +304,8 @@ def setup(self, model):
 
         """
         super().setup(model)
-        self.schedule_event_next_tick(self.model.step, priority=Priority.HIGH)
+        # Schedule the first step event
+        model._schedule_step(1)
 
     def check_time_unit(self, time) -> bool:
         """Check whether the time is of the correct unit.
@@ -359,43 +348,6 @@ def schedule_event_next_tick(
             function_kwargs=function_kwargs,
         )
 
-    def run_until(self, end_time: int) -> None:
-        """Run the simulator up to and included the specified end time.
-
-        Args:
-            end_time (float| int): The end_time delta. The simulator is until the specified end time
-
-        Raises:
-            Exception if simulator.setup() has not yet been called
-
-        """
-        if self.model is None:
-            raise RuntimeError(
-                "Simulator not set up. Call simulator.setup(model) first."
-            )
-
-        while True:
-            try:
-                event = self.event_list.pop_event()
-            except IndexError:
-                self.model.time = float(end_time)
-                break
-
-            if event.time <= end_time:
-                self.model.time = float(event.time)
-
-                # Reschedule model.step for next tick if this is a step event
-                if event.fn() == self.model.step:
-                    self.schedule_event_next_tick(
-                        self.model.step, priority=Priority.HIGH
-                    )
-
-                event.execute()
-            else:
-                self.model.time = float(end_time)
-                self._schedule_event(event)
-                break
-
 
 class DEVSimulator(Simulator):
     """A simulator where the unit of time is a float.
@@ -408,6 +360,18 @@ def __init__(self):
         """Initialize a DEVS simulator."""
         super().__init__(float, 0.0)
 
+    def setup(self, model: Model) -> None:
+        """Set up the simulator with the model to simulate.
+
+        Args:
+            model (Model): The model to simulate
+
+        """
+        # For pure DEVS, we don't want automatic step scheduling
+        # Clear any pre-scheduled events
+        model._event_list.clear()
+        super().setup(model)
+
     def check_time_unit(self, time) -> bool:
         """Check whether the time is of the correct unit.
 
diff --git a/mesa/model.py b/mesa/model.py
@@ -12,12 +12,15 @@
 from collections.abc import Sequence
 
 # mypy
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
+if TYPE_CHECKING:
+    from mesa.experimental.devs import Simulator
+
 from mesa.agent import Agent, AgentSet
-from mesa.experimental.devs import Simulator
+from mesa.experimental.devs.eventlist import EventList, Priority, SimulationEvent
 from mesa.experimental.scenarios import Scenario
 from mesa.mesa_logging import create_module_logger, method_logger
 
@@ -103,6 +106,9 @@ def __init__(
         # Track if a simulator is controlling time
         self._simulator: Simulator | None = None
 
+        # Event list for event-based execution
+        self._event_list: EventList = EventList()
+
         # check if `scenario` is provided
         # and if so, whether rng is the same or not
         if scenario is not None:
@@ -167,18 +173,45 @@ def __init__(
         )  # an agenset with all agents
 
     def _wrapped_step(self, *args: Any, **kwargs: Any) -> None:
-        """Automatically increments time and steps after calling the user's step method."""
-        # Automatically increment time and step counters
-        self.steps += 1
-        # Only auto-increment time if no simulator is controlling it
-        if self._simulator is None:
-            self.time += 1
+        """Advance time by one unit, processing any scheduled events."""
+        # Schedule step event if not already scheduled (first call or no simulator)
+        if self._event_list.is_empty():
+            self._schedule_step(self.time + 1)
+        self._advance_time(self.time + 1)
 
-        _mesa_logger.info(
-            f"calling model.step for step {self.steps} at time {self.time}"
-        )
-        # Call the original user-defined step method
-        self._user_step(*args, **kwargs)
+    def _advance_time(self, until: float) -> None:
+        """Advance time to the given point, processing events along the way.
+
+        Args:
+            until: The time to advance to
+
+        """
+        while True:
+            try:
+                event = self._event_list.pop_event()
+            except IndexError:
+                break
+
+            if event.time <= until:
+                self.time = event.time
+                event.execute()
+            else:
+                self._event_list.add_event(event)
+                break
+
+        self.time = until
+
+    def _schedule_step(self, time: float) -> None:
+        """Schedule a step event at the given time."""
+        event = SimulationEvent(time, self._do_step, priority=Priority.HIGH)
+        self._event_list.add_event(event)
+
+    def _do_step(self) -> None:
+        """Execute one step and schedule the next."""
+        self.steps += 1
+        _mesa_logger.info(f"Step {self.steps} at time {self.time}")
+        self._user_step()
+        self._schedule_step(self.time + 1)
 
     @property
     def agents(self) -> AgentSet[A]:
diff --git a/tests/experimental/test_devs.py b/tests/experimental/test_devs.py
@@ -94,7 +94,7 @@ def test_devs_simulator():
     # simulator reset
     simulator.reset()
     assert len(simulator.event_list) == 0
-    assert simulator.model is None
+    assert simulator.model is model
 
     # run_for without setup
     simulator = DEVSimulator()
@@ -115,10 +115,8 @@ def test_devs_simulator():
 
     # setup with event scheduled
     simulator = DEVSimulator()
-    model = Model()
-    simulator.event_list.add_event(SimulationEvent(1.0, Mock(), Priority.DEFAULT))
-    with pytest.raises(ValueError):
-        simulator.setup(model)
+    with pytest.raises(RuntimeError, match="Simulator not set up"):
+        simulator.event_list.add_event(SimulationEvent(1.0, Mock(), Priority.DEFAULT))
 
 
 def test_abm_simulator():
@@ -417,6 +415,21 @@ def test_eventlist():
     assert len(event_list) == 0
 
 
+def test_simulator_uses_model_event_list():
+    """Test that simulator uses model's internal event list."""
+    model = Model()
+    simulator = DEVSimulator()
+    simulator.setup(model)
+
+    # Simulator's event_list property should return model's event list
+    assert simulator.event_list is model._event_list
+
+    # Events scheduled through simulator appear in model's event list
+    fn = MagicMock()
+    simulator.schedule_event_absolute(fn, 1.0)
+    assert len(model._event_list) == 1
+
+
 @pytest.fixture
 def setup():
     """Create a model with simulator and mock function."""
