Mesa 3.0.0a2__py3-none-any.whl → 3.0.0a4__py3-none-any.whl

mesa/time.py

@@ -69,8 +69,6 @@ class BaseScheduler:
         self.model = model
         self.steps = 0
         self.time: TimeT = 0
-        self._original_step = self.step
-        self.step = self._wrapped_step
 
         if agents is None:
             agents = []
@@ -113,11 +111,6 @@ class BaseScheduler:
         self.steps += 1
         self.time += 1
 
-    def _wrapped_step(self):
-        """Wrapper for the step method to include time and step updating."""
-        self._original_step()
-        self.model._advance_time()
-
     def get_agent_count(self) -> int:
         """Returns the current number of agents in the queue."""
         return len(self._agents)

mesa/visualization/__init__.py

@@ -1,3 +1,14 @@
-from .solara_viz import JupyterViz, Slider, SolaraViz, make_text
+from .components.altair import make_space_altair
+from .components.matplotlib import make_plot_measure, make_space_matplotlib
+from .solara_viz import JupyterViz, SolaraViz, make_text
+from .UserParam import Slider
 
-__all__ = ["JupyterViz", "make_text", "Slider", "SolaraViz"]
+__all__ = [
+    "JupyterViz",
+    "SolaraViz",
+    "make_text",
+    "Slider",
+    "make_space_altair",
+    "make_space_matplotlib",
+    "make_plot_measure",
+]

mesa/visualization/components/altair.py

@@ -5,9 +5,24 @@ import solara
 with contextlib.suppress(ImportError):
     import altair as alt
 
+from mesa.visualization.utils import update_counter
+
+
+def make_space_altair(agent_portrayal=None):
+    if agent_portrayal is None:
+
+        def agent_portrayal(a):
+            return {"id": a.unique_id}
+
+    def MakeSpaceAltair(model):
+        return SpaceAltair(model, agent_portrayal)
+
+    return MakeSpaceAltair
+
 
 @solara.component
 def SpaceAltair(model, agent_portrayal, dependencies: list[any] | None = None):
+    update_counter.get()
     space = getattr(model, "grid", None)
     if space is None:
         # Sometimes the space is defined as model.space instead of model.grid

mesa/visualization/components/matplotlib.py

@@ -6,10 +6,25 @@ from matplotlib.figure import Figure
 from matplotlib.ticker import MaxNLocator
 
 import mesa
+from mesa.experimental.cell_space import VoronoiGrid
+from mesa.visualization.utils import update_counter
+
+
+def make_space_matplotlib(agent_portrayal=None):
+    if agent_portrayal is None:
+
+        def agent_portrayal(a):
+            return {"id": a.unique_id}
+
+    def MakeSpaceMatplotlib(model):
+        return SpaceMatplotlib(model, agent_portrayal)
+
+    return MakeSpaceMatplotlib
 
 
 @solara.component
 def SpaceMatplotlib(model, agent_portrayal, dependencies: list[any] | None = None):
+    update_counter.get()
     space_fig = Figure()
     space_ax = space_fig.subplots()
     space = getattr(model, "grid", None)
@@ -20,6 +35,8 @@ def SpaceMatplotlib(model, agent_portrayal, dependencies: list[any] | None = Non
         _draw_network_grid(space, space_ax, agent_portrayal)
     elif isinstance(space, mesa.space.ContinuousSpace):
         _draw_continuous_space(space, space_ax, agent_portrayal)
+    elif isinstance(space, VoronoiGrid):
+        _draw_voronoi(space, space_ax, agent_portrayal)
     else:
         _draw_grid(space, space_ax, agent_portrayal)
     solara.FigureMatplotlib(space_fig, format="png", dependencies=dependencies)
@@ -150,8 +167,66 @@ def _draw_continuous_space(space, space_ax, agent_portrayal):
     _split_and_scatter(portray(space), space_ax)
 
 
+def _draw_voronoi(space, space_ax, agent_portrayal):
+    def portray(g):
+        x = []
+        y = []
+        s = []  # size
+        c = []  # color
+
+        for cell in g.all_cells:
+            for agent in cell.agents:
+                data = agent_portrayal(agent)
+                x.append(cell.coordinate[0])
+                y.append(cell.coordinate[1])
+                if "size" in data:
+                    s.append(data["size"])
+                if "color" in data:
+                    c.append(data["color"])
+        out = {"x": x, "y": y}
+        # This is the default value for the marker size, which auto-scales
+        # according to the grid area.
+        out["s"] = s
+        if len(c) > 0:
+            out["c"] = c
+
+        return out
+
+    x_list = [i[0] for i in space.centroids_coordinates]
+    y_list = [i[1] for i in space.centroids_coordinates]
+    x_max = max(x_list)
+    x_min = min(x_list)
+    y_max = max(y_list)
+    y_min = min(y_list)
+
+    width = x_max - x_min
+    x_padding = width / 20
+    height = y_max - y_min
+    y_padding = height / 20
+    space_ax.set_xlim(x_min - x_padding, x_max + x_padding)
+    space_ax.set_ylim(y_min - y_padding, y_max + y_padding)
+    space_ax.scatter(**portray(space))
+
+    for cell in space.all_cells:
+        polygon = cell.properties["polygon"]
+        space_ax.fill(
+            *zip(*polygon),
+            alpha=min(1, cell.properties[space.cell_coloring_property]),
+            c="red",
+        )  # Plot filled polygon
+        space_ax.plot(*zip(*polygon), color="black")  # Plot polygon edges in red
+
+
+def make_plot_measure(measure: str | dict[str, str] | list[str] | tuple[str]):
+    def MakePlotMeasure(model):
+        return PlotMatplotlib(model, measure)
+
+    return MakePlotMeasure
+
+
 @solara.component
 def PlotMatplotlib(model, measure, dependencies: list[any] | None = None):
+    update_counter.get()
     fig = Figure()
     ax = fig.subplots()
     df = model.datacollector.get_model_vars_dataframe()

mesa/visualization/solara_viz.py

@@ -23,15 +23,20 @@ Usage:
 See the Visualization Tutorial and example models for more details.
 """
 
-import threading
+import copy
+import time
+from typing import TYPE_CHECKING, Literal
 
-import reacton.ipywidgets as widgets
 import solara
 from solara.alias import rv
 
 import mesa.visualization.components.altair as components_altair
 import mesa.visualization.components.matplotlib as components_matplotlib
 from mesa.visualization.UserParam import Slider
+from mesa.visualization.utils import force_update, update_counter
+
+if TYPE_CHECKING:
+    from mesa.model import Model
 
 
 # TODO: Turn this function into a Solara component once the current_step.value
@@ -86,120 +91,56 @@ def Card(
 
 @solara.component
 def SolaraViz(
-    model_class,
-    model_params,
-    measures=None,
-    name=None,
-    agent_portrayal=None,
-    space_drawer="default",
-    play_interval=150,
-    seed=None,
+    model: "Model" | solara.Reactive["Model"],
+    components: list[solara.component] | Literal["default"] = "default",
+    *args,
+    play_interval=100,
+    model_params=None,
+    seed=0,
+    name: str | None = None,
 ):
-    """
-    Initialize a component to visualize a model.
-
-    Args:
-        model_class: Class of the model to instantiate
-        model_params: Parameters for initializing the model
-        measures: List of callables or data attributes to plot
-        name: Name for display
-        agent_portrayal: Options for rendering agents (dictionary);
-            Default drawer supports custom `"size"`, `"color"`, and `"shape"`.
-        space_drawer: Method to render the agent space for
-            the model; default implementation is the `SpaceMatplotlib` component;
-            simulations with no space to visualize should
-            specify `space_drawer=False`
-        play_interval: Play interval (default: 150)
-        seed: The random seed used to initialize the model
-    """
-    if name is None:
-        name = model_class.__name__
+    update_counter.get()
+    if components == "default":
+        components = [components_altair.make_space_altair()]
 
-    current_step = solara.use_reactive(0)
+    # Convert model to reactive
+    if not isinstance(model, solara.Reactive):
+        model = solara.use_reactive(model)
 
-    # 1. Set up model parameters
-    reactive_seed = solara.use_reactive(0)
-    user_params, fixed_params = split_model_params(model_params)
-    model_parameters, set_model_parameters = solara.use_state(
-        {**fixed_params, **{k: v.get("value") for k, v in user_params.items()}}
-    )
+    def connect_to_model():
+        # Patch the step function to force updates
+        original_step = model.value.step
 
-    # 2. Set up Model
-    def make_model():
-        """Create a new model instance with current parameters and seed."""
-        model = model_class.__new__(
-            model_class, **model_parameters, seed=reactive_seed.value
-        )
-        model.__init__(**model_parameters)
-        current_step.value = 0
-        return model
-
-    reset_counter = solara.use_reactive(0)
-    model = solara.use_memo(
-        make_model,
-        dependencies=[
-            *list(model_parameters.values()),
-            reset_counter.value,
-            reactive_seed.value,
-        ],
-    )
+        def step():
+            original_step()
+            force_update()
 
-    def handle_change_model_params(name: str, value: any):
-        """Update model parameters when user input changes."""
-        set_model_parameters({**model_parameters, name: value})
+        model.value.step = step
+        # Add a trigger to model itself
+        model.value.force_update = force_update
+        force_update()
 
-    # 3. Set up UI
+    solara.use_effect(connect_to_model, [model.value])
 
     with solara.AppBar():
-        solara.AppBarTitle(name)
-
-    # render layout and plot
-    def do_reseed():
-        """Update the random seed for the model."""
-        reactive_seed.value = model.random.random()
-
-    dependencies = [current_step.value, reactive_seed.value]
-
-    # if space drawer is disabled, do not include it
-    layout_types = [{"Space": "default"}] if space_drawer else []
-
-    if measures:
-        layout_types += [{"Measure": elem} for elem in range(len(measures))]
-
-    grid_layout_initial = make_initial_grid_layout(layout_types=layout_types)
-    grid_layout, set_grid_layout = solara.use_state(grid_layout_initial)
+        solara.AppBarTitle(name if name else model.value.__class__.__name__)
 
     with solara.Sidebar():
         with solara.Card("Controls", margin=1, elevation=2):
-            solara.InputText(
-                label="Seed",
-                value=reactive_seed,
-                continuous_update=True,
-            )
-            UserInputs(user_params, on_change=handle_change_model_params)
-            ModelController(model, play_interval, current_step, reset_counter)
-            solara.Button(label="Reseed", color="primary", on_click=do_reseed)
+            if model_params is not None:
+                ModelCreator(
+                    model,
+                    model_params,
+                    seed=seed,
+                )
+            ModelController(model, play_interval)
         with solara.Card("Information", margin=1, elevation=2):
-            solara.Markdown(md_text=f"Step - {current_step}")
-
-    items = [
-        Card(
-            model,
-            measures,
-            agent_portrayal,
-            space_drawer,
-            dependencies,
-            color="white",
-            layout_type=layout_types[i],
-        )
-        for i in range(len(layout_types))
-    ]
-    solara.GridDraggable(
-        items=items,
-        grid_layout=grid_layout,
-        resizable=True,
-        draggable=True,
-        on_grid_layout=set_grid_layout,
+            ShowSteps(model.value)
+
+    solara.Column(
+        [
+            *(component(model.value) for component in components),
+        ]
     )
 
 
@@ -207,107 +148,57 @@ JupyterViz = SolaraViz
 
 
 @solara.component
-def ModelController(model, play_interval, current_step, reset_counter):
+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)
-
-    def on_value_play(change):
-        """Handle play/pause state changes."""
-        if previous_step.value > current_step.value and current_step.value == 0:
-            # We add extra checks for current_step.value == 0, just to be sure.
-            # We automatically stop the playing if a model is reset.
-            playing.value = False
-        elif model.running:
+    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 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."""
-        model.step()
-        previous_step.value = current_step.value
-        current_step.value = model._steps
+        model.value.step()
 
     def do_play():
         """Run the model continuously."""
-        model.running = True
-        while model.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.running = False
-        thread.join()
+        playing.value = False
 
     def do_reset():
-        """Reset the model."""
-        reset_counter.value += 1
-
-    def do_set_playing(value):
-        """Set the playing state."""
-        if current_step.value == 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 = current_step.value
-        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,
-        )
+        """Reset the model to its initial state."""
+        playing.value = False
+        model.value = copy.deepcopy(original_model.value)
+
+    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):
@@ -348,6 +239,45 @@ def check_param_is_fixed(param):
         return True
 
 
+@solara.component
+def ModelCreator(model, model_params, seed=1):
+    user_params, fixed_params = split_model_params(model_params)
+
+    reactive_seed = solara.use_reactive(seed)
+
+    model_parameters, set_model_parameters = solara.use_state(
+        {
+            **fixed_params,
+            **{k: v.get("value") for k, v in user_params.items()},
+        }
+    )
+
+    def do_reseed():
+        """Update the random seed for the model."""
+        reactive_seed.value = model.value.random.random()
+
+    def on_change(name, value):
+        set_model_parameters({**model_parameters, name: value})
+
+    def create_model():
+        model.value = model.value.__class__.__new__(
+            model.value.__class__, **model_parameters, seed=reactive_seed.value
+        )
+        model.value.__init__(**model_parameters)
+
+    solara.use_effect(create_model, [model_parameters, reactive_seed.value])
+
+    solara.InputText(
+        label="Seed",
+        value=reactive_seed,
+        continuous_update=True,
+    )
+
+    solara.Button(label="Reseed", color="primary", on_click=do_reseed)
+
+    UserInputs(user_params, on_change=on_change)
+
+
 @solara.component
 def UserInputs(user_params, on_change=None):
     """
@@ -456,3 +386,9 @@ def make_initial_grid_layout(layout_types):
         }
         for i in range(len(layout_types))
     ]
+
+
+@solara.component
+def ShowSteps(model):
+    update_counter.get()
+    return solara.Text(f"Step: {model.steps}")

mesa/visualization/utils.py

@@ -0,0 +1,7 @@
+import solara
+
+update_counter = solara.reactive(0)
+
+
+def force_update():
+    update_counter.value += 1

{mesa-3.0.0a2.dist-info → mesa-3.0.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Mesa
-Version: 3.0.0a2
+Version: 3.0.0a4
 Summary: Agent-based modeling (ABM) in Python
 Project-URL: homepage, https://github.com/projectmesa/mesa
 Project-URL: repository, https://github.com/projectmesa/mesa
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Artificial Life
@@ -42,6 +43,9 @@ Requires-Dist: myst-parser; extra == 'docs'
 Requires-Dist: pydata-sphinx-theme; extra == 'docs'
 Requires-Dist: seaborn; extra == 'docs'
 Requires-Dist: sphinx; extra == 'docs'
+Provides-Extra: examples
+Requires-Dist: pytest>=4.6; extra == 'examples'
+Requires-Dist: scipy; extra == 'examples'
 Description-Content-Type: text/markdown
 
 # Mesa: Agent-based modeling in Python
@@ -98,15 +102,18 @@ Or any other (development) branch on this repo or your own fork:
 pip install -U -e git+https://github.com/YOUR_FORK/mesa@YOUR_BRANCH#egg=mesa
 ```
 
+## Resources
 For resources or help on using Mesa, check out the following:
 
 -   [Intro to Mesa Tutorial](http://mesa.readthedocs.org/en/stable/tutorials/intro_tutorial.html) (An introductory model, the Boltzmann
     Wealth Model, for beginners or those new to Mesa.)
+-   [Visualization Tutorial](https://mesa.readthedocs.io/en/stable/tutorials/visualization_tutorial.html) (An introduction into our Solara visualization)
 -   [Complexity Explorer Tutorial](https://www.complexityexplorer.org/courses/172-agent-based-models-with-python-an-introduction-to-mesa) (An advanced-beginner model,
     SugarScape with Traders, with instructional videos)
 -   [Mesa Examples](https://github.com/projectmesa/mesa-examples/tree/main/examples) (A repository of seminal ABMs using Mesa and
     examples of employing specific Mesa Features)
 -   [Docs](http://mesa.readthedocs.org/) (Mesa's documentation, API and useful snippets)
+    -   [Development version docs](https://mesa.readthedocs.io/en/latest/) (the latest version docs if you're using a pre-release Mesa version)
 -   [Discussions](https://github.com/projectmesa/mesa/discussions) (GitHub threaded discussions about Mesa)
 -   [Matrix Chat](https://matrix.to/#/#project-mesa:matrix.org) (Chat Forum via Matrix to talk about Mesa)
 

mesa-3.0.0a4.dist-info/RECORD

@@ -0,0 +1,44 @@
+mesa/__init__.py,sha256=UIq0dHx3cmtSSVuVFYYLpYS1rzbfn_tcT7vbqo1XLa0,618
+mesa/agent.py,sha256=45KS_Cus2Yu-2g5moA8W6ntLWPKNnj9jUeNZiO4NqoI,22920
+mesa/batchrunner.py,sha256=-n5mtNGWuKkE0kxWVenXw8b4LXe_LVAZ3rNEBcR2l1A,6097
+mesa/datacollection.py,sha256=WUpZoFC2ZdLtKZ0oTwZTqraoP_yNx_yQY9pxO0TR8y0,11442
+mesa/main.py,sha256=7MovfNz88VWNnfXP0kcERB6C3GfkVOh0hb0o32hM9LU,1602
+mesa/model.py,sha256=_z_aPVu3ADJHZZD7YavBG7fdCYaDQqpkVNEcatWMM90,8551
+mesa/space.py,sha256=5St5E26Np_b_fWv-_NEH82ZU0H3C9xHBAschRJtPpng,62698
+mesa/time.py,sha256=53VX0x8zujaq32R6w_aBv1NmLpWO_h5K5BQTaK4mO3Q,14960
+mesa/cookiecutter-mesa/cookiecutter.json,sha256=tBSWli39fOWUXGfiDCTKd92M7uKaBIswXbkOdbUufYY,337
+mesa/cookiecutter-mesa/hooks/post_gen_project.py,sha256=8JoXZKIioRYEWJURC0udj8WS3rg0c4So62sOZSGbrMY,294
+mesa/cookiecutter-mesa/{{cookiecutter.snake}}/README.md,sha256=Yji4lGY-NtQSnW-oBj0_Jhs-XhCfZA8R1mBBM_IllGs,80
+mesa/cookiecutter-mesa/{{cookiecutter.snake}}/app.pytemplate,sha256=36f9k9CH6TK6VrXsPvTFXGUfCKzCLwgYTeK-Gt27GNg,584
+mesa/cookiecutter-mesa/{{cookiecutter.snake}}/setup.pytemplate,sha256=UtRpLM_CkeUZRec-Ef_LiO_x7SKaWN11fOiH9T1UmTw,214
+mesa/cookiecutter-mesa/{{cookiecutter.snake}}/{{cookiecutter.snake}}/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mesa/cookiecutter-mesa/{{cookiecutter.snake}}/{{cookiecutter.snake}}/model.pytemplate,sha256=Aml4Z6E1yj7E7DtHNSUqnKNRUdkxG9WWtJyW8fkxCng,1870
+mesa/experimental/UserParam.py,sha256=WgnY3Q0padtGqUCaezgYzd6cZ7LziuIQnGKP3DBuHZY,1641
+mesa/experimental/__init__.py,sha256=8KfQcTMv9HJEAjmK5A_KdnFYfoY0nHAz97G_JLJVMNM,183
+mesa/experimental/solara_viz.py,sha256=WXQY4b5jLp_ABvhV2df6yerDIijBzns3pXd4hCl5fAA,15253
+mesa/experimental/cell_space/__init__.py,sha256=gXntv_Ie13SIegBumJNaIPcTUmTQLb4LlGd1JxoIn9M,708
+mesa/experimental/cell_space/cell.py,sha256=AUnvVnXWhdgzr0bLKDRDO9c93v22Zkw6W-tWxhEhGdQ,4578
+mesa/experimental/cell_space/cell_agent.py,sha256=Q3SoeK8Af7p4bdcm_E6Hr2uiHCSRsXYvttPUAOo4lRs,1080
+mesa/experimental/cell_space/cell_collection.py,sha256=4FmfDEg9LoFiJ0mF_nC8KUt9fCJ7Q21erjWPeBTQ_lw,2293
+mesa/experimental/cell_space/discrete_space.py,sha256=ta__YojsrrhWL4DgMzUqZpSgbeexKMrA6bxlYPJGfK0,1921
+mesa/experimental/cell_space/grid.py,sha256=gYDExuFBMF3OThUkhbXmolQFKBOqTukcibjfgXicP00,6948
+mesa/experimental/cell_space/network.py,sha256=mAaFHBdd4s9kxUWHbViovLW2-pU2yXH0dtY_vF8sCJg,1179
+mesa/experimental/cell_space/voronoi.py,sha256=swwfV1Hfi7wp3XfM-rb9Lq5H0yAPH9zohZnXzU8SiHM,9997
+mesa/experimental/components/altair.py,sha256=V2CQ-Zr7PeijgWtYBNH3VklGVfrf1ee70XVh0DBBONQ,2366
+mesa/experimental/components/matplotlib.py,sha256=J61gHkXd37XyZiNLGF1NaQPOYqDdh9tpSfbOzMqK3dI,7570
+mesa/experimental/devs/__init__.py,sha256=CWam15vCj-RD_biMyqv4sJfos1fsL823P7MDEGrbwW8,174
+mesa/experimental/devs/eventlist.py,sha256=nyUFNDWnnSPQnrMtj7Qj1PexxKyOwSJuIGBoxtSwVI0,5269
+mesa/experimental/devs/simulator.py,sha256=0SMC7daIOyL2rYfoQOOTaTOYDos0gLeBUbU1Krd42HA,9557
+mesa/experimental/devs/examples/epstein_civil_violence.py,sha256=wCquOwcNYc--DYGM9Vg4YGx1Kh--HRhSVGjGgzT4k-I,9491
+mesa/experimental/devs/examples/wolf_sheep.py,sha256=Hz3sExzjKEzrkFcE2gd7p7a0Ubg-QBGrV-4XQYWgt3c,7501
+mesa/visualization/UserParam.py,sha256=WgnY3Q0padtGqUCaezgYzd6cZ7LziuIQnGKP3DBuHZY,1641
+mesa/visualization/__init__.py,sha256=T_3QNz9BVuyfcbcMK_2RGGfMYhB7J-8XtaVPViXm1OU,372
+mesa/visualization/solara_viz.py,sha256=8eQ-4dTYWuP0fmoaRMV3QqA1DL0tG0wPLmLAiYiiDO0,12188
+mesa/visualization/utils.py,sha256=ade9YVhKx3gEaqDySj4YeSixTOHWGjzIIFDPGXL4uAs,103
+mesa/visualization/components/altair.py,sha256=2VE4yRHrvBNXpDQUPuj0ejsPU0v3BqSzkphjbIcqzoc,2707
+mesa/visualization/components/matplotlib.py,sha256=v-XwsChqWy9ukLe3zi-Q93UBUF20lxTB7lwckX4pB3M,8138
+mesa-3.0.0a4.dist-info/METADATA,sha256=2DMGHgOya24WeUxtyEsBY1rzGlFxVkMZ2bcKFXeCZRw,8339
+mesa-3.0.0a4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+mesa-3.0.0a4.dist-info/entry_points.txt,sha256=IOcQtetGF8l4wHpOs_hGb19Rz-FS__BMXOJR10IBPsA,39
+mesa-3.0.0a4.dist-info/licenses/LICENSE,sha256=OGUgret9fRrm8J3pdsPXETIjf0H8puK_Nmy970ZzT78,572
+mesa-3.0.0a4.dist-info/RECORD,,