Merge remote-tracking branch 'upstream/main'

Author: quaquel

mesa/agent.py

@@ -20,7 +20,7 @@
 from random import Random
 
 # mypy
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 if TYPE_CHECKING:
     # We ensure that these are not imported during runtime to prevent cyclic
@@ -348,29 +348,58 @@ def agg(self, attribute: str, func: Callable) -> Any:
         values = self.get(attribute)
         return func(values)
 
-    def get(self, attr_names: str | list[str]) -> list[Any]:
+    def get(
+        self,
+        attr_names: str | list[str],
+        handle_missing: Literal["error", "default"] = "error",
+        default_value: Any = None,
+    ) -> list[Any] | list[list[Any]]:
         """
         Retrieve the specified attribute(s) from each agent in the AgentSet.
 
         Args:
             attr_names (str | list[str]): The name(s) of the attribute(s) to retrieve from each agent.
+            handle_missing (str, optional): How to handle missing attributes. Can be:
+                                            - 'error' (default): raises an AttributeError if attribute is missing.
+                                            - 'default': returns the specified default_value.
+            default_value (Any, optional): The default value to return if 'handle_missing' is set to 'default'
+                                           and the agent does not have the attribute.
 
         Returns:
-            list[Any]: A list with the attribute value for each agent in the set if attr_names is a str
-            list[list[Any]]: A list with a list of attribute values for each agent in the set if attr_names is a list of str
+            list[Any]: A list with the attribute value for each agent if attr_names is a str.
+            list[list[Any]]: A list with a lists of attribute values for each agent if attr_names is a list of str.
 
         Raises:
-            AttributeError if an agent does not have the specified attribute(s)
-
-        """
+            AttributeError: If 'handle_missing' is 'error' and the agent does not have the specified attribute(s).
+            ValueError: If an unknown 'handle_missing' option is provided.
+        """
+        is_single_attr = isinstance(attr_names, str)
+
+        if handle_missing == "error":
+            if is_single_attr:
+                return [getattr(agent, attr_names) for agent in self._agents]
+            else:
+                return [
+                    [getattr(agent, attr) for attr in attr_names]
+                    for agent in self._agents
+                ]
+
+        elif handle_missing == "default":
+            if is_single_attr:
+                return [
+                    getattr(agent, attr_names, default_value) for agent in self._agents
+                ]
+            else:
+                return [
+                    [getattr(agent, attr, default_value) for attr in attr_names]
+                    for agent in self._agents
+                ]
 
-        if isinstance(attr_names, str):
-            return [getattr(agent, attr_names) for agent in self._agents]
         else:
-            return [
-                [getattr(agent, attr_name) for attr_name in attr_names]
-                for agent in self._agents
-            ]
+            raise ValueError(
+                f"Unknown handle_missing option: {handle_missing}, "
+                "should be one of 'error' or 'default'"
+            )
 
     def set(self, attr_name: str, value: Any) -> AgentSet:
         """

mesa/batchrunner.py

@@ -1,4 +1,5 @@
 import itertools
+import multiprocessing
 from collections.abc import Iterable, Mapping
 from functools import partial
 from multiprocessing import Pool
@@ -8,6 +9,8 @@
 
 from mesa.model import Model
 
+multiprocessing.set_start_method("spawn", force=True)
+
 
 def batch_run(
     model_cls: type[Model],

mesa/space.py

@@ -459,15 +459,21 @@ def move_agent_to_one_of(
             elif selection == "closest":
                 current_pos = agent.pos
                 # Find the closest position without sorting all positions
-                closest_pos = None
+                # TODO: See if this method can be optimized further
+                closest_pos = []
                 min_distance = float("inf")
                 agent.random.shuffle(pos)
                 for p in pos:
                     distance = self._distance_squared(p, current_pos)
                     if distance < min_distance:
                         min_distance = distance
-                        closest_pos = p
-                chosen_pos = closest_pos
+                        closest_pos.clear()
+                        closest_pos.append(p)
+                    elif distance == min_distance:
+                        closest_pos.append(p)
+
+                chosen_pos = agent.random.choice(closest_pos)
+
             else:
                 raise ValueError(
                     f"Invalid selection method {selection}. Choose 'random' or 'closest'."

mesa/visualization/solara_viz.py

@@ -24,10 +24,9 @@
 """
 
 import copy
-import threading
+import time
 from typing import TYPE_CHECKING, Literal
 
-import reacton.ipywidgets as widgets
 import solara
 from solara.alias import rv
 
@@ -95,7 +94,7 @@ def SolaraViz(
     model: "Model" | solara.Reactive["Model"],
     components: list[solara.component] | Literal["default"] = "default",
     *args,
-    play_interval=150,
+    play_interval=100,
     model_params=None,
     seed=0,
     name: str | None = None,
@@ -149,115 +148,57 @@ def step():
 
 
 @solara.component
-def ModelController(model: solara.Reactive["Model"], play_interval):
+def ModelController(model: solara.Reactive["Model"], play_interval=100):
     """
     Create controls for model execution (step, play, pause, reset).
 
     Args:
-        model: The model being visualized
+        model: The reactive model being visualized
         play_interval: Interval between steps during play
-        current_step: Reactive value for the current step
-        reset_counter: Counter to trigger model reset
     """
+    if not isinstance(model, solara.Reactive):
+        model = solara.use_reactive(model)
+
     playing = solara.use_reactive(False)
-    thread = solara.use_reactive(None)
-    # We track the previous step to detect if user resets the model via
-    # clicking the reset button or changing the parameters. If previous_step >
-    # current_step, it means a model reset happens while the simulation is
-    # still playing.
-    previous_step = solara.use_reactive(0)
     original_model = solara.use_reactive(None)
 
     def save_initial_model():
         """Save the initial model for comparison."""
         original_model.set(copy.deepcopy(model.value))
+        playing.value = False
+        force_update()
 
     solara.use_effect(save_initial_model, [model.value])
 
-    def on_value_play(change):
-        """Handle play/pause state changes."""
-        if previous_step.value > model.value.steps and model.value.steps == 0:
-            # We add extra checks for model.value.steps == 0, just to be sure.
-            # We automatically stop the playing if a model is reset.
-            playing.value = False
-        elif model.value.running:
+    def step():
+        while playing.value:
+            time.sleep(play_interval / 1000)
             do_step()
-        else:
-            playing.value = False
+
+    solara.use_thread(step, [playing.value])
 
     def do_step():
         """Advance the model by one step."""
-        previous_step.value = model.value.steps
         model.value.step()
 
     def do_play():
         """Run the model continuously."""
-        model.value.running = True
-        while model.value.running:
-            do_step()
-
-    def threaded_do_play():
-        """Start a new thread for continuous model execution."""
-        if thread is not None and thread.is_alive():
-            return
-        thread.value = threading.Thread(target=do_play)
-        thread.start()
+        playing.value = True
 
     def do_pause():
         """Pause the model execution."""
-        if (thread is None) or (not thread.is_alive()):
-            return
-        model.value.running = False
-        thread.join()
+        playing.value = False
 
     def do_reset():
-        """Reset the model"""
+        """Reset the model to its initial state."""
+        playing.value = False
         model.value = copy.deepcopy(original_model.value)
-        previous_step.value = 0
-        force_update()
-
-    def do_set_playing(value):
-        """Set the playing state."""
-        if model.value.steps == 0:
-            # This means the model has been recreated, and the step resets to
-            # 0. We want to avoid triggering the playing.value = False in the
-            # on_value_play function.
-            previous_step.value = model.value.steps
-        playing.set(value)
 
-    with solara.Row():
-        solara.Button(label="Step", color="primary", on_click=do_step)
-        # This style is necessary so that the play widget has almost the same
-        # height as typical Solara buttons.
-        solara.Style(
-            """
-        .widget-play {
-            height: 35px;
-        }
-        .widget-play button {
-            color: white;
-            background-color: #1976D2;  // Solara blue color
-        }
-        """
-        )
-        widgets.Play(
-            value=0,
-            interval=play_interval,
-            repeat=True,
-            show_repeat=False,
-            on_value=on_value_play,
-            playing=playing.value,
-            on_playing=do_set_playing,
-        )
+    with solara.Row(justify="space-between"):
         solara.Button(label="Reset", color="primary", on_click=do_reset)
-        # threaded_do_play is not used for now because it
-        # doesn't work in Google colab. We use
-        # ipywidgets.Play until it is fixed. The threading
-        # version is definite a much better implementation,
-        # if it works.
-        # solara.Button(label="▶", color="primary", on_click=viz.threaded_do_play)
-        # solara.Button(label="⏸︎", color="primary", on_click=viz.do_pause)
-        # solara.Button(label="Reset", color="primary", on_click=do_reset)
+        solara.Button(label="Step", color="primary", on_click=do_step)
+        solara.Button(label="▶", color="primary", on_click=do_play)
+        solara.Button(label="⏸︎", color="primary", on_click=do_pause)
 
 
 def split_model_params(model_params):

pyproject.toml

@@ -28,6 +28,7 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "License :: OSI Approved :: Apache Software License",
   "Operating System :: OS Independent",
   "Development Status :: 3 - Alpha",

tests/test_agent.py

@@ -276,6 +276,51 @@ def remove_function(agent):
     assert len(agentset) == 0
 
 
+def test_agentset_get():
+    model = Model()
+    _ = [TestAgent(i, model) for i in range(10)]
+
+    agentset = model.agents
+
+    agentset.set("a", 5)
+    agentset.set("b", 6)
+
+    # Case 1: Normal retrieval of existing attributes
+    values = agentset.get(["a", "b"])
+    assert all((a == 5) & (b == 6) for a, b in values)
+
+    # Case 2: Raise AttributeError when attribute doesn't exist
+    with pytest.raises(AttributeError):
+        agentset.get("unknown_attribute")
+
+    # Case 3: Use default value when attribute is missing
+    results = agentset.get(
+        "unknown_attribute", handle_missing="default", default_value=True
+    )
+    assert all(results) is True
+
+    # Case 4: Retrieve mixed attributes with default value for missing ones
+    values = agentset.get(
+        ["a", "unknown_attribute"], handle_missing="default", default_value=True
+    )
+    assert all((a == 5) & (unknown is True) for a, unknown in values)
+
+    # Case 5: Invalid handle_missing value raises ValueError
+    with pytest.raises(ValueError):
+        agentset.get("unknown_attribute", handle_missing="some nonsense value")
+
+    # Case 6: Retrieve multiple attributes with mixed existence and 'default' handling
+    values = agentset.get(
+        ["a", "b", "unknown_attribute"], handle_missing="default", default_value=0
+    )
+    assert all((a == 5) & (b == 6) & (unknown == 0) for a, b, unknown in values)
+
+    # Case 7: 'default' handling when one attribute is completely missing from some agents
+    agentset.select(at_most=0.5).set("c", 8)  # Only some agents have attribute 'c'
+    values = agentset.get(["a", "c"], handle_missing="default", default_value=-1)
+    assert all((a == 5) & (c in [8, -1]) for a, c in values)
+
+
 def test_agentset_agg():
     model = Model()
     agents = [TestAgent(model) for i in range(10)]

tests/test_space.py

@@ -509,6 +509,23 @@ def test_move_agent_closest_selection(self):
         self.space.move_agent_to_one_of(agent, possible_positions, selection="closest")
         assert agent.pos == (6, 6)
 
+    def test_move_agent_closest_selection_multiple(self):
+        random_locations = []
+        agent = self.agents[0]
+        agent.pos = (5, 5)
+        repetititions = 10
+
+        for _ in range(repetititions):
+            possible_positions = [(4, 4), (6, 6), (10, 10), (20, 20)]
+            self.space.move_agent_to_one_of(
+                agent, possible_positions, selection="closest"
+            )
+            random_locations.append(agent.pos)
+            assert agent.pos in possible_positions
+            self.space.move_agent_to_one_of(agent, [(5, 5)], selection="closest")
+        non_random_locations = [random_locations[0]] * repetititions
+        assert random_locations != non_random_locations
+
     def test_move_agent_invalid_selection(self):
         agent = self.agents[0]
         possible_positions = [(10, 10), (20, 20), (30, 30)]