Mesa 3.0.0a3__py3-none-any.whl → 3.0.0a5__py3-none-any.whl

mesa/visualization/solara_viz.py

@@ -1,5 +1,4 @@
-"""
-Mesa visualization module for creating interactive model visualizations.
+"""Mesa visualization module for creating interactive model visualizations.
 
 This module provides components to create browser- and Jupyter notebook-based visualizations of
 Mesa models, allowing users to watch models run step-by-step and interact with model parameters.
@@ -8,7 +7,6 @@ Key features:
     - SolaraViz: Main component for creating visualizations, supporting grid displays and plots
     - ModelController: Handles model execution controls (step, play, pause, reset)
     - UserInputs: Generates UI elements for adjusting model parameters
-    - Card: Renders individual visualization elements (space, measures)
 
 The module uses Solara for rendering in Jupyter notebooks or as standalone web applications.
 It supports various types of visualizations including matplotlib plots, agent grids, and
@@ -23,15 +21,24 @@ Usage:
 See the Visualization Tutorial and example models for more details.
 """
 
-import threading
+from __future__ import annotations
+
+import asyncio
+import copy
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Literal
 
-import reacton.ipywidgets as widgets
+import reacton.core
 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
@@ -39,8 +46,7 @@ from mesa.visualization.UserParam import Slider
 def Card(
     model, measures, agent_portrayal, space_drawer, dependencies, color, layout_type
 ):
-    """
-    Create a card component for visualizing model space or measures.
+    """Create a card component for visualizing model space or measures.
 
     Args:
         model: The Mesa model instance
@@ -86,237 +92,183 @@ 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[reacton.core.Component]
+    | list[Callable[[Model], reacton.core.Component]]
+    | Literal["default"] = "default",
+    play_interval: int = 100,
+    model_params=None,
+    seed: float = 0,
+    name: str | None = None,
 ):
-    """
-    Initialize a component to visualize a model.
+    """Solara visualization component.
+
+    This component provides a visualization interface for a given model using Solara.
+    It supports various visualization components and allows for interactive model
+    stepping and parameter adjustments.
 
     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
+        model (Model | solara.Reactive[Model]): A Model instance or a reactive Model.
+            This is the main model to be visualized. If a non-reactive model is provided,
+            it will be converted to a reactive model.
+        components (list[solara.component] | Literal["default"], optional): List of solara
+            components or functions that return a solara component.
+            These components are used to render different parts of the model visualization.
+            Defaults to "default", which uses the default Altair space visualization.
+        play_interval (int, optional): Interval for playing the model steps in milliseconds.
+            This controls the speed of the model's automatic stepping. Defaults to 100 ms.
+        model_params (dict, optional): Parameters for (re-)instantiating a model.
+            Can include user-adjustable parameters and fixed parameters. Defaults to None.
+        seed (int, optional): Seed for the random number generator. This ensures reproducibility
+            of the model's behavior. Defaults to 0.
+        name (str | None, optional): Name of the visualization. Defaults to the models class name.
+
+    Returns:
+        solara.component: A Solara component that renders the visualization interface for the model.
+
+    Example:
+        >>> model = MyModel()
+        >>> page = SolaraViz(model)
+        >>> page
+
+    Notes:
+        - The `model` argument can be either a direct model instance or a reactive model. If a direct
+          model instance is provided, it will be converted to a reactive model using `solara.use_reactive`.
+        - The `play_interval` argument controls the speed of the model's automatic stepping. A lower
+          value results in faster stepping, while a higher value results in slower stepping.
     """
-    if name is None:
-        name = model_class.__name__
+    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)  # noqa: SH102, RUF100
 
-    # 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)
+        solara.AppBarTitle(name if name else model.value.__class__.__name__)
+
+    with solara.Sidebar(), solara.Column():
+        with solara.Card("Controls"):
+            ModelController(model, play_interval)
+
+        if model_params is not None:
+            with solara.Card("Model Parameters"):
+                ModelCreator(
+                    model,
+                    model_params,
+                    seed=seed,
+                )
+        with solara.Card("Information"):
+            ShowSteps(model.value)
 
-    # render layout and plot
-    def do_reseed():
-        """Update the random seed for the model."""
-        reactive_seed.value = model.random.random()
+    ComponentsView(components, model.value)
 
-    dependencies = [
-        *list(model_parameters.values()),
-        current_step.value,
-        reactive_seed.value,
-    ]
 
-    # if space drawer is disabled, do not include it
-    layout_types = [{"Space": "default"}] if space_drawer else []
+def _wrap_component(
+    component: reacton.core.Component | Callable[[Model], reacton.core.Component],
+) -> reacton.core.Component:
+    """Wrap a component in an auto-updated Solara component if needed."""
+    if isinstance(component, reacton.core.Component):
+        return component
 
-    if measures:
-        layout_types += [{"Measure": elem} for elem in range(len(measures))]
+    @solara.component
+    def WrappedComponent(model):
+        update_counter.get()
+        return component(model)
 
-    grid_layout_initial = make_initial_grid_layout(layout_types=layout_types)
-    grid_layout, set_grid_layout = solara.use_state(grid_layout_initial)
+    return WrappedComponent
 
-    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)
-        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,
-    )
+
+@solara.component
+def ComponentsView(
+    components: list[reacton.core.Component]
+    | list[Callable[[Model], reacton.core.Component]],
+    model: Model,
+):
+    """Display a list of components.
+
+    Args:
+        components: List of components to display
+        model: Model instance to pass to each component
+    """
+    wrapped_components = [_wrap_component(component) for component in components]
+
+    with solara.Column():
+        for component in wrapped_components:
+            component(model)
 
 
 JupyterViz = SolaraViz
 
 
 @solara.component
-def ModelController(model, play_interval, current_step, reset_counter):
-    """
-    Create controls for model execution (step, play, pause, reset).
+def ModelController(model: solara.Reactive[Model], play_interval=100):
+    """Create controls for model execution (step, play, pause, reset).
 
     Args:
-        model: The 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
+        model (solara.Reactive[Model]): Reactive model instance
+        play_interval (int, optional): Interval for playing the model steps in milliseconds.
     """
     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])
+
+    async def step():
+        while playing.value:
+            await asyncio.sleep(play_interval / 1000)
             do_step()
-        else:
-            playing.value = False
+
+    solara.lab.use_task(step, dependencies=[playing.value], prefer_threaded=False)
 
     def do_step():
         """Advance the model by one step."""
-        model.step()
-        previous_step.value = current_step.value
-        current_step.value = model.steps
-
-    def do_play():
-        """Run the model continuously."""
-        model.running = True
-        while model.running:
-            do_step()
+        model.value.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()
+    def do_reset():
+        """Reset the model to its initial state."""
+        playing.value = False
+        model.value = copy.deepcopy(original_model.value)
 
-    def do_pause():
-        """Pause the model execution."""
-        if (thread is None) or (not thread.is_alive()):
-            return
-        model.running = False
-        thread.join()
+    def do_play_pause():
+        """Toggle play/pause."""
+        playing.value = not playing.value
 
-    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
-        }
-        """
+    with solara.Row(justify="space-between"):
+        solara.Button(label="Reset", color="primary", on_click=do_reset)
+        solara.Button(
+            label="▶" if not playing.value else "❚❚",
+            color="primary",
+            on_click=do_play_pause,
         )
-        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,
+        solara.Button(
+            label="Step", color="primary", on_click=do_step, disabled=playing.value
         )
-        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)
 
 
 def split_model_params(model_params):
-    """
-    Split model parameters into user-adjustable and fixed parameters.
+    """Split model parameters into user-adjustable and fixed parameters.
 
     Args:
         model_params: Dictionary of all model parameters
@@ -335,8 +287,7 @@ def split_model_params(model_params):
 
 
 def check_param_is_fixed(param):
-    """
-    Check if a parameter is fixed (not user-adjustable).
+    """Check if a parameter is fixed (not user-adjustable).
 
     Args:
         param: Parameter to check
@@ -353,18 +304,84 @@ def check_param_is_fixed(param):
 
 
 @solara.component
-def UserInputs(user_params, on_change=None):
+def ModelCreator(model, model_params, seed=1):
+    """Solara component for creating and managing a model instance with user-defined parameters.
+
+    This component allows users to create a model instance with specified parameters and seed.
+    It provides an interface for adjusting model parameters and reseeding the model's random
+    number generator.
+
+    Args:
+        model (solara.Reactive[Model]): A reactive model instance. This is the main model to be created and managed.
+        model_params (dict): Dictionary of model parameters. This includes both user-adjustable parameters and fixed parameters.
+        seed (int, optional): Initial seed for the random number generator. Defaults to 1.
+
+    Returns:
+        solara.component: A Solara component that renders the model creation and management interface.
+
+    Example:
+        >>> model = solara.reactive(MyModel())
+        >>> model_params = {
+        >>>     "param1": {"type": "slider", "value": 10, "min": 0, "max": 100},
+        >>>     "param2": {"type": "slider", "value": 5, "min": 1, "max": 10},
+        >>> }
+        >>> creator = ModelCreator(model, model_params)
+        >>> creator
+
+    Notes:
+        - The `model_params` argument should be a dictionary where keys are parameter names and values either fixed values
+          or are dictionaries containing parameter details such as type, value, min, and max.
+        - The `seed` argument ensures reproducibility by setting the initial seed for the model's random number generator.
+        - The component provides an interface for adjusting user-defined parameters and reseeding the model.
+
     """
-    Initialize user inputs for configurable model parameters.
+    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__(**model_parameters)
+        model.value._seed = reactive_seed.value
+
+    solara.use_effect(create_model, [model_parameters, reactive_seed.value])
+
+    with solara.Row(justify="space-between"):
+        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):
+    """Initialize user inputs for configurable model parameters.
+
     Currently supports :class:`solara.SliderInt`, :class:`solara.SliderFloat`,
     :class:`solara.Select`, and :class:`solara.Checkbox`.
 
     Args:
-        user_params: Dictionary with options for the input, including label,
-        min and max values, and other fields specific to the input type.
+        user_params: Dictionary with options for the input, including label, min and max values, and other fields specific to the input type.
         on_change: Function to be called with (name, value) when the value of an input changes.
     """
-
     for name, options in user_params.items():
 
         def change_handler(value, name=name):
@@ -422,26 +439,8 @@ def UserInputs(user_params, on_change=None):
             raise ValueError(f"{input_type} is not a supported input type")
 
 
-def make_text(renderer):
-    """
-    Create a function that renders text using Markdown.
-
-    Args:
-        renderer: Function that takes a model and returns a string
-
-    Returns:
-        function: A function that renders the text as Markdown
-    """
-
-    def function(model):
-        solara.Markdown(renderer(model))
-
-    return function
-
-
 def make_initial_grid_layout(layout_types):
-    """
-    Create an initial grid layout for visualization components.
+    """Create an initial grid layout for visualization components.
 
     Args:
         layout_types: List of layout types (Space or Measure)
@@ -460,3 +459,10 @@ def make_initial_grid_layout(layout_types):
         }
         for i in range(len(layout_types))
     ]
+
+
+@solara.component
+def ShowSteps(model):
+    """Display the current step of the model."""
+    update_counter.get()
+    return solara.Text(f"Step: {model.steps}")

mesa/visualization/utils.py

@@ -0,0 +1,9 @@
+"""Solara related utils."""
+
+import solara
+
+update_counter = solara.reactive(0)
+
+
+def force_update():  # noqa: D103
+    update_counter.value += 1

{mesa-3.0.0a3.dist-info → mesa-3.0.0a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Mesa
-Version: 3.0.0a3
+Version: 3.0.0a5
 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

mesa-3.0.0a5.dist-info/RECORD

@@ -0,0 +1,44 @@
+mesa/__init__.py,sha256=rKO9SY4p-VL83PFsk5hAbDCbhhUO8azgxc9buDoFCX4,618
+mesa/agent.py,sha256=-KwohXkdrj6CZMn7paf3Jv_7fCfDPhsJasRNm-jgTTY,25043
+mesa/batchrunner.py,sha256=YUYyCy8XBxbUj83BczXmxA6tsT6ttimIeqiD3-wkYL4,6103
+mesa/datacollection.py,sha256=xyb07aBpd-HSDh5bk-XcVqGiDu5bfaLlxj5eDlGIwqY,16138
+mesa/main.py,sha256=_KgeVGbi0znzezjjoM09vhGdyaqcuDEwb9M7vH2c_O4,1668
+mesa/model.py,sha256=vUS64fuZI26b3TYX0BTK90S8lxPdmFI1tgxatNEYUI8,7981
+mesa/space.py,sha256=1sVl78o5lYP6aEg32QIb9-tcv3V3UeFdC7A_h_8CgO8,62838
+mesa/time.py,sha256=kGXHDjnRn-Ixwgxt3fijEvLRybWQe0g9pE5ZpW4Kaaw,14983
+mesa/cookiecutter-mesa/cookiecutter.json,sha256=tBSWli39fOWUXGfiDCTKd92M7uKaBIswXbkOdbUufYY,337
+mesa/cookiecutter-mesa/hooks/post_gen_project.py,sha256=UKz12l6mKc7fILK0MvV5djsTKwkmD4DlH8LYjFO8ehI,316
+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=WgJccMfsAlD_mA3zTBPJVHadF3FtO8xgi8SPKORzyMs,22
+mesa/cookiecutter-mesa/{{cookiecutter.snake}}/{{cookiecutter.snake}}/model.pytemplate,sha256=Aml4Z6E1yj7E7DtHNSUqnKNRUdkxG9WWtJyW8fkxCng,1870
+mesa/experimental/UserParam.py,sha256=f32nmFjroe76HpxU75ZCEOqFW2nAsDfmqIf8kQ1zt-E,2086
+mesa/experimental/__init__.py,sha256=1hxkjcZvdJhhQx4iLlTTUAPs_SqRyN-us4qR8U6JKkw,209
+mesa/experimental/solara_viz.py,sha256=uWrNQAX3oEWSftmyjNorN839dBCUp86hnhpL704dyGQ,15212
+mesa/experimental/cell_space/__init__.py,sha256=Nz1EkgzhvrTcfOJI1M_WkHsIgPkU8QIOCNJl7jLlYpw,908
+mesa/experimental/cell_space/cell.py,sha256=L1XMxq1mIaouviiPSgurj4uda0dAx7zMWnam6_aK79s,5907
+mesa/experimental/cell_space/cell_agent.py,sha256=06R_7djVlD2S-kS86ugxiaeualWaTrSUmF82t3UBi44,1169
+mesa/experimental/cell_space/cell_collection.py,sha256=ZcyuPEevCZEXW7jFnX6StjBMw4UBDQvUspZRcFi2dFg,3426
+mesa/experimental/cell_space/discrete_space.py,sha256=q5MRPzMYzZb3hQW90L0PmVFJepXhjbZK_9hT4y6OLdY,2293
+mesa/experimental/cell_space/grid.py,sha256=WT9AtQCgPzV8VonX0oSPRXgZNXoOR_mVgEAEOp5I4YA,7319
+mesa/experimental/cell_space/network.py,sha256=hzhxGipRyM1PWOQFlPz--tc3pA_RRBT8Xq4pXHx5sD8,1252
+mesa/experimental/cell_space/voronoi.py,sha256=lSY8zQhELvOy0RfDyZIek09UMwY9_20UY9SPqFWsNoM,10014
+mesa/experimental/components/altair.py,sha256=49OHgrm1JncfrKqDfw_5ifPtsbMKdgVYCacL9SMwucc,2624
+mesa/experimental/components/matplotlib.py,sha256=j477UBk_7yW5vzT3rjhnuTixpA7PedDNghoK9TLgHVY,8043
+mesa/experimental/devs/__init__.py,sha256=EByaC66ikUIu9G9p1geLm6ESEMWZOPTO9r9627S83j0,211
+mesa/experimental/devs/eventlist.py,sha256=Trvc5S-NG5B792uuk_cY8Q_5Rw99zioUYDQXcXWVuCo,5972
+mesa/experimental/devs/simulator.py,sha256=wvqkLIDgbJNaem9nwMacyEYRp0W3ai5Oxptw3-QmbSw,10595
+mesa/experimental/devs/examples/epstein_civil_violence.py,sha256=E8YSV3O5ihKsntGtnltHM-4IyS8eg2DSRUqmIiw_1iU,10916
+mesa/experimental/devs/examples/wolf_sheep.py,sha256=aj5kiEWy-ezQXOomc5mgEdkup1yRYQknQm65ajPWBxs,8051
+mesa/visualization/UserParam.py,sha256=Dl2WOwLYLf0pfLpabCZtIdFRyKZrK6Qtc3utZx5GPYg,2139
+mesa/visualization/__init__.py,sha256=sa8lqeLcDtte19SMzFiKP6K4CrVLxAPwrhDu_AsDWTs,395
+mesa/visualization/solara_viz.py,sha256=vVyAqp3aov8EKmYAvDELEdb5Fonr5JxLws6YZZ02GIk,16459
+mesa/visualization/utils.py,sha256=lJHgRKF5BHLf72Tw3YpwyiWuRoIimaTKQ7xBCw_Rx3A,146
+mesa/visualization/components/altair.py,sha256=E-iblqpWhx72qrjkNz4Ie9c66Hh1OFpLVjuDIg9m2sA,2804
+mesa/visualization/components/matplotlib.py,sha256=wGPxZAS6c3HZgyrkoFKA6z5CqaTr2YVB6sDZtywTt_I,8277
+mesa-3.0.0a5.dist-info/METADATA,sha256=EqwMNNaGiRZhmZVkg032KxexPwvNlEYGmzF9jQ5N05s,8339
+mesa-3.0.0a5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+mesa-3.0.0a5.dist-info/entry_points.txt,sha256=IOcQtetGF8l4wHpOs_hGb19Rz-FS__BMXOJR10IBPsA,39
+mesa-3.0.0a5.dist-info/licenses/LICENSE,sha256=OGUgret9fRrm8J3pdsPXETIjf0H8puK_Nmy970ZzT78,572
+mesa-3.0.0a5.dist-info/RECORD,,