Mesa 3.1.0.dev0__py3-none-any.whl → 3.1.1__py3-none-any.whl

mesa/experimental/UserParam.py

@@ -1,67 +0,0 @@
-"""helper classes."""
-
-
-class UserParam:  # noqa: D101
-    _ERROR_MESSAGE = "Missing or malformed inputs for '{}' Option '{}'"
-
-    def maybe_raise_error(self, param_type, valid):  # noqa: D102
-        if valid:
-            return
-        msg = self._ERROR_MESSAGE.format(param_type, self.label)
-        raise ValueError(msg)
-
-
-class Slider(UserParam):
-    """A number-based slider input with settable increment.
-
-    Example:
-    slider_option = Slider("My Slider", value=123, min=10, max=200, step=0.1)
-
-    Args:
-        label: The displayed label in the UI
-        value: The initial value of the slider
-        min: The minimum possible value of the slider
-        max: The maximum possible value of the slider
-        step: The step between min and max for a range of possible values
-        dtype: either int or float
-    """
-
-    def __init__(
-        self,
-        label="",
-        value=None,
-        min=None,
-        max=None,
-        step=1,
-        dtype=None,
-    ):
-        """Slider class.
-
-        Args:
-            label: The displayed label in the UI
-            value: The initial value of the slider
-            min: The minimum possible value of the slider
-            max: The maximum possible value of the slider
-            step: The step between min and max for a range of possible values
-            dtype: either int or float
-        """
-        self.label = label
-        self.value = value
-        self.min = min
-        self.max = max
-        self.step = step
-
-        # Validate option type to make sure values are supplied properly
-        valid = not (self.value is None or self.min is None or self.max is None)
-        self.maybe_raise_error("slider", valid)
-
-        if dtype is None:
-            self.is_float_slider = self._check_values_are_float(value, min, max, step)
-        else:
-            self.is_float_slider = dtype is float
-
-    def _check_values_are_float(self, value, min, max, step):
-        return any(isinstance(n, float) for n in (value, min, max, step))
-
-    def get(self, attr):  # noqa: D102
-        return getattr(self, attr)

mesa/experimental/components/altair.py

@@ -1,81 +0,0 @@
-"""Altair components."""
-
-import contextlib
-
-import solara
-
-with contextlib.suppress(ImportError):
-    import altair as alt
-
-
-@solara.component
-def SpaceAltair(model, agent_portrayal, dependencies: list[any] | None = None):
-    """A component that renders a Space using Altair.
-
-    Args:
-        model: a model instance
-        agent_portrayal: agent portray specification
-        dependencies: optional list of dependencies (currently not used)
-
-    """
-    space = getattr(model, "grid", None)
-    if space is None:
-        # Sometimes the space is defined as model.space instead of model.grid
-        space = model.space
-    chart = _draw_grid(space, agent_portrayal)
-    solara.FigureAltair(chart)
-
-
-def _draw_grid(space, agent_portrayal):
-    def portray(g):
-        all_agent_data = []
-        for content, (x, y) in g.coord_iter():
-            if not content:
-                continue
-            if not hasattr(content, "__iter__"):
-                # Is a single grid
-                content = [content]  # noqa: PLW2901
-            for agent in content:
-                # use all data from agent portrayal, and add x,y coordinates
-                agent_data = agent_portrayal(agent)
-                agent_data["x"] = x
-                agent_data["y"] = y
-                all_agent_data.append(agent_data)
-        return all_agent_data
-
-    all_agent_data = portray(space)
-    invalid_tooltips = ["color", "size", "x", "y"]
-
-    encoding_dict = {
-        # no x-axis label
-        "x": alt.X("x", axis=None, type="ordinal"),
-        # no y-axis label
-        "y": alt.Y("y", axis=None, type="ordinal"),
-        "tooltip": [
-            alt.Tooltip(key, type=alt.utils.infer_vegalite_type([value]))
-            for key, value in all_agent_data[0].items()
-            if key not in invalid_tooltips
-        ],
-    }
-    has_color = "color" in all_agent_data[0]
-    if has_color:
-        encoding_dict["color"] = alt.Color("color", type="nominal")
-    has_size = "size" in all_agent_data[0]
-    if has_size:
-        encoding_dict["size"] = alt.Size("size", type="quantitative")
-
-    chart = (
-        alt.Chart(
-            alt.Data(values=all_agent_data), encoding=alt.Encoding(**encoding_dict)
-        )
-        .mark_point(filled=True)
-        .properties(width=280, height=280)
-        # .configure_view(strokeOpacity=0)  # hide grid/chart lines
-    )
-    # This is the default value for the marker size, which auto-scales
-    # according to the grid area.
-    if not has_size:
-        length = min(space.width, space.height)
-        chart = chart.mark_point(size=30000 / length**2, filled=True)
-
-    return chart

mesa/experimental/components/matplotlib.py

@@ -1,242 +0,0 @@
-"""Support for using matplotlib to draw spaces."""
-
-from collections import defaultdict
-
-import networkx as nx
-import solara
-from matplotlib.figure import Figure
-from matplotlib.ticker import MaxNLocator
-
-import mesa
-from mesa.experimental.cell_space import VoronoiGrid
-
-
-@solara.component
-def SpaceMatplotlib(model, agent_portrayal, dependencies: list[any] | None = None):
-    """A component for rendering a space using Matplotlib.
-
-    Args:
-        model: a model instance
-        agent_portrayal: a specification of how to portray an agent.
-        dependencies: list of dependencies.
-
-    """
-    space_fig = Figure()
-    space_ax = space_fig.subplots()
-    space = getattr(model, "grid", None)
-    if space is None:
-        # Sometimes the space is defined as model.space instead of model.grid
-        space = model.space
-    if isinstance(space, mesa.space.NetworkGrid):
-        _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)
-
-
-# matplotlib scatter does not allow for multiple shapes in one call
-def _split_and_scatter(portray_data, space_ax):
-    grouped_data = defaultdict(lambda: {"x": [], "y": [], "s": [], "c": []})
-
-    # Extract data from the dictionary
-    x = portray_data["x"]
-    y = portray_data["y"]
-    s = portray_data["s"]
-    c = portray_data["c"]
-    m = portray_data["m"]
-
-    if not (len(x) == len(y) == len(s) == len(c) == len(m)):
-        raise ValueError(
-            "Length mismatch in portrayal data lists: "
-            f"x: {len(x)}, y: {len(y)}, size: {len(s)}, "
-            f"color: {len(c)}, marker: {len(m)}"
-        )
-
-    # Group the data by marker
-    for i in range(len(x)):
-        marker = m[i]
-        grouped_data[marker]["x"].append(x[i])
-        grouped_data[marker]["y"].append(y[i])
-        grouped_data[marker]["s"].append(s[i])
-        grouped_data[marker]["c"].append(c[i])
-
-    # Plot each group with the same marker
-    for marker, data in grouped_data.items():
-        space_ax.scatter(data["x"], data["y"], s=data["s"], c=data["c"], marker=marker)
-
-
-def _draw_grid(space, space_ax, agent_portrayal):
-    def portray(g):
-        x = []
-        y = []
-        s = []  # size
-        c = []  # color
-        m = []  # shape
-        for i in range(g.width):
-            for j in range(g.height):
-                content = g._grid[i][j]
-                if not content:
-                    continue
-                if not hasattr(content, "__iter__"):
-                    # Is a single grid
-                    content = [content]
-                for agent in content:
-                    data = agent_portrayal(agent)
-                    x.append(i)
-                    y.append(j)
-
-                    # This is the default value for the marker size, which auto-scales
-                    # according to the grid area.
-                    default_size = (180 / max(g.width, g.height)) ** 2
-                    # establishing a default prevents misalignment if some agents are not given size, color, etc.
-                    size = data.get("size", default_size)
-                    s.append(size)
-                    color = data.get("color", "tab:blue")
-                    c.append(color)
-                    mark = data.get("shape", "o")
-                    m.append(mark)
-        out = {"x": x, "y": y, "s": s, "c": c, "m": m}
-        return out
-
-    space_ax.set_xlim(-1, space.width)
-    space_ax.set_ylim(-1, space.height)
-    _split_and_scatter(portray(space), space_ax)
-
-
-def _draw_network_grid(space, space_ax, agent_portrayal):
-    graph = space.G
-    pos = nx.spring_layout(graph, seed=0)
-    nx.draw(
-        graph,
-        ax=space_ax,
-        pos=pos,
-        **agent_portrayal(graph),
-    )
-
-
-def _draw_continuous_space(space, space_ax, agent_portrayal):
-    def portray(space):
-        x = []
-        y = []
-        s = []  # size
-        c = []  # color
-        m = []  # shape
-        for agent in space._agent_to_index:
-            data = agent_portrayal(agent)
-            _x, _y = agent.pos
-            x.append(_x)
-            y.append(_y)
-
-            # This is matplotlib's default marker size
-            default_size = 20
-            # establishing a default prevents misalignment if some agents are not given size, color, etc.
-            size = data.get("size", default_size)
-            s.append(size)
-            color = data.get("color", "tab:blue")
-            c.append(color)
-            mark = data.get("shape", "o")
-            m.append(mark)
-        out = {"x": x, "y": y, "s": s, "c": c, "m": m}
-        return out
-
-    # Determine border style based on space.torus
-    border_style = "solid" if not space.torus else (0, (5, 10))
-
-    # Set the border of the plot
-    for spine in space_ax.spines.values():
-        spine.set_linewidth(1.5)
-        spine.set_color("black")
-        spine.set_linestyle(border_style)
-
-    width = space.x_max - space.x_min
-    x_padding = width / 20
-    height = space.y_max - space.y_min
-    y_padding = height / 20
-    space_ax.set_xlim(space.x_min - x_padding, space.x_max + x_padding)
-    space_ax.set_ylim(space.y_min - y_padding, space.y_max + y_padding)
-
-    # Portray and scatter the agents in the space
-    _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
-
-
-@solara.component
-def PlotMatplotlib(model, measure, dependencies: list[any] | None = None):
-    """A solara component for creating a matplotlib figure.
-
-    Args:
-        model: Model instance
-        measure: measure to plot
-        dependencies: list of additional dependencies
-
-    """
-    fig = Figure()
-    ax = fig.subplots()
-    df = model.datacollector.get_model_vars_dataframe()
-    if isinstance(measure, str):
-        ax.plot(df.loc[:, measure])
-        ax.set_ylabel(measure)
-    elif isinstance(measure, dict):
-        for m, color in measure.items():
-            ax.plot(df.loc[:, m], label=m, color=color)
-        fig.legend()
-    elif isinstance(measure, list | tuple):
-        for m in measure:
-            ax.plot(df.loc[:, m], label=m)
-        fig.legend()
-    # Set integer x axis
-    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-    solara.FigureMatplotlib(fig, dependencies=dependencies)

mesa/experimental/devs/examples/epstein_civil_violence.py

@@ -1,305 +0,0 @@
-"""Epstein civil violence example using ABMSimulator."""
-
-import enum
-import math
-
-from mesa import Agent, Model
-from mesa.experimental.devs.simulator import ABMSimulator
-from mesa.space import SingleGrid
-
-
-class EpsteinAgent(Agent):
-    """Epstein Agent."""
-
-    def __init__(self, model, vision, movement):
-        """Initialize the agent.
-
-        Args:
-            model: a model instance
-            vision: size of neighborhood
-            movement: boolean whether agent can move or not
-        """
-        super().__init__(model)
-        self.vision = vision
-        self.movement = movement
-
-
-class AgentState(enum.IntEnum):
-    """Agent states."""
-
-    QUIESCENT = enum.auto()
-    ARRESTED = enum.auto()
-    ACTIVE = enum.auto()
-
-
-class Citizen(EpsteinAgent):
-    """A member of the general population, may or may not be in active rebellion.
-
-    Summary of rule: If grievance - risk > threshold, rebel.
-
-    Attributes:
-        unique_id: unique int
-        model :
-        hardship: Agent's 'perceived hardship (i.e., physical or economic
-            privation).' Exogenous, drawn from U(0,1).
-        regime_legitimacy: Agent's perception of regime legitimacy, equal
-            across agents.  Exogenous.
-        risk_aversion: Exogenous, drawn from U(0,1).
-        threshold: if (grievance - (risk_aversion * arrest_probability)) >
-            threshold, go/remain Active
-        vision: number of cells in each direction (N, S, E and W) that agent
-            can inspect
-        condition: Can be "Quiescent" or "Active;" deterministic function of
-            greivance, perceived risk, and
-        grievance: deterministic function of hardship and regime_legitimacy;
-            how aggrieved is agent at the regime?
-        arrest_probability: agent's assessment of arrest probability, given
-            rebellion
-    """
-
-    def __init__(
-        self,
-        model,
-        vision,
-        movement,
-        hardship,
-        regime_legitimacy,
-        risk_aversion,
-        threshold,
-        arrest_prob_constant,
-    ):
-        """Create a new Citizen.
-
-        Args:
-            model : model instance
-            vision: number of cells in each direction (N, S, E and W) that
-                agent can inspect. Exogenous.
-            movement: whether agent can move or not
-            hardship: Agent's 'perceived hardship (i.e., physical or economic
-                privation).' Exogenous, drawn from U(0,1).
-            regime_legitimacy: Agent's perception of regime legitimacy, equal
-                across agents.  Exogenous.
-            risk_aversion: Exogenous, drawn from U(0,1).
-            threshold: if (grievance - (risk_aversion * arrest_probability)) >
-                threshold, go/remain Active
-            arrest_prob_constant : agent's assessment of arrest probability
-
-        """
-        super().__init__(model, vision, movement)
-        self.hardship = hardship
-        self.regime_legitimacy = regime_legitimacy
-        self.risk_aversion = risk_aversion
-        self.threshold = threshold
-        self.condition = AgentState.QUIESCENT
-        self.grievance = self.hardship * (1 - self.regime_legitimacy)
-        self.arrest_probability = None
-        self.arrest_prob_constant = arrest_prob_constant
-
-    def step(self):
-        """Decide whether to activate, then move if applicable."""
-        self.update_neighbors()
-        self.update_estimated_arrest_probability()
-        net_risk = self.risk_aversion * self.arrest_probability
-        if self.grievance - net_risk > self.threshold:
-            self.condition = AgentState.ACTIVE
-        else:
-            self.condition = AgentState.QUIESCENT
-        if self.movement and self.empty_neighbors:
-            new_pos = self.random.choice(self.empty_neighbors)
-            self.model.grid.move_agent(self, new_pos)
-
-    def update_neighbors(self):
-        """Look around and see who my neighbors are."""
-        self.neighborhood = self.model.grid.get_neighborhood(
-            self.pos, moore=True, radius=self.vision
-        )
-        self.neighbors = self.model.grid.get_cell_list_contents(self.neighborhood)
-        self.empty_neighbors = [
-            c for c in self.neighborhood if self.model.grid.is_cell_empty(c)
-        ]
-
-    def update_estimated_arrest_probability(self):
-        """Based on the ratio of cops to actives in my neighborhood, estimate the p(Arrest | I go active)."""
-        cops_in_vision = len([c for c in self.neighbors if isinstance(c, Cop)])
-        actives_in_vision = 1.0  # citizen counts herself
-        for c in self.neighbors:
-            if isinstance(c, Citizen) and c.condition == AgentState.ACTIVE:
-                actives_in_vision += 1
-        self.arrest_probability = 1 - math.exp(
-            -1 * self.arrest_prob_constant * (cops_in_vision / actives_in_vision)
-        )
-
-    def sent_to_jail(self, value):
-        """Sent agent to jail.
-
-        Args:
-            value: duration of jail sentence
-
-        """
-        self.model.active_agents.remove(self)
-        self.condition = AgentState.ARRESTED
-        self.model.simulator.schedule_event_relative(self.release_from_jail, value)
-
-    def release_from_jail(self):
-        """Release agent from jail."""
-        self.model.active_agents.add(self)
-        self.condition = AgentState.QUIESCENT
-
-
-class Cop(EpsteinAgent):
-    """A cop for life.  No defection.
-
-    Summary of rule: Inspect local vision and arrest a random active agent.
-
-    Attributes:
-        unique_id: unique int
-        x, y: Grid coordinates
-        vision: number of cells in each direction (N, S, E and W) that cop is
-            able to inspect
-    """
-
-    def __init__(self, model, vision, movement, max_jail_term):
-        """Initialize a Cop agent.
-
-        Args:
-            model: a model instance
-            vision: size of neighborhood
-            movement: whether agent can move or not
-            max_jail_term: maximum jail sentence
-        """
-        super().__init__(model, vision, movement)
-        self.max_jail_term = max_jail_term
-
-    def step(self):
-        """Inspect local vision and arrest a random active agent. Move if applicable."""
-        self.update_neighbors()
-        active_neighbors = []
-        for agent in self.neighbors:
-            if isinstance(agent, Citizen) and agent.condition == "Active":
-                active_neighbors.append(agent)
-        if active_neighbors:
-            arrestee = self.random.choice(active_neighbors)
-            arrestee.sent_to_jail(self.random.randint(0, self.max_jail_term))
-        if self.movement and self.empty_neighbors:
-            new_pos = self.random.choice(self.empty_neighbors)
-            self.model.grid.move_agent(self, new_pos)
-
-    def update_neighbors(self):
-        """Look around and see who my neighbors are."""
-        self.neighborhood = self.model.grid.get_neighborhood(
-            self.pos, moore=True, radius=self.vision
-        )
-        self.neighbors = self.model.grid.get_cell_list_contents(self.neighborhood)
-        self.empty_neighbors = [
-            c for c in self.neighborhood if self.model.grid.is_cell_empty(c)
-        ]
-
-
-class EpsteinCivilViolence(Model):
-    """Model 1 from "Modeling civil violence: An agent-based computational approach," by Joshua Epstein.
-
-    http://www.pnas.org/content/99/suppl_3/7243.full
-    Attributes:
-        height: grid height
-        width: grid width
-        citizen_density: approximate % of cells occupied by citizens.
-        cop_density: approximate % of cells occupied by cops.
-        citizen_vision: number of cells in each direction (N, S, E and W) that
-            citizen can inspect
-        cop_vision: number of cells in each direction (N, S, E and W) that cop
-            can inspect
-        legitimacy:  (L) citizens' perception of regime legitimacy, equal
-            across all citizens
-        max_jail_term: (J_max)
-        active_threshold: if (grievance - (risk_aversion * arrest_probability))
-            > threshold, citizen rebels
-        arrest_prob_constant: set to ensure agents make plausible arrest
-            probability estimates
-        movement: binary, whether agents try to move at step end
-        max_iters: model may not have a natural stopping point, so we set a
-            max.
-    """
-
-    def __init__(
-        self,
-        width=40,
-        height=40,
-        citizen_density=0.7,
-        cop_density=0.074,
-        citizen_vision=7,
-        cop_vision=7,
-        legitimacy=0.8,
-        max_jail_term=1000,
-        active_threshold=0.1,
-        arrest_prob_constant=2.3,
-        movement=True,
-        max_iters=1000,
-        seed=None,
-    ):
-        """Initialize the Eppstein civil violence model.
-
-        Args:
-            width: the width of the grid
-            height: the height of the grid
-            citizen_density: density of citizens
-            cop_density: density of cops
-            citizen_vision: size of citizen vision
-            cop_vision: size of cop vision
-            legitimacy: perceived legitimacy
-            max_jail_term: maximum jail term
-            active_threshold: threshold for citizen to become active
-            arrest_prob_constant: arrest probability
-            movement: allow agent movement or not
-            max_iters: number of iterations
-            seed: seed for random number generator
-        """
-        super().__init__(seed)
-        if cop_density + citizen_density > 1:
-            raise ValueError("Cop density + citizen density must be less than 1")
-
-        self.width = width
-        self.height = height
-        self.citizen_density = citizen_density
-        self.cop_density = cop_density
-
-        self.max_iters = max_iters
-
-        self.grid = SingleGrid(self.width, self.height, torus=True)
-
-        for _, pos in self.grid.coord_iter():
-            if self.random.random() < self.cop_density:
-                agent = Cop(
-                    self,
-                    cop_vision,
-                    movement,
-                    max_jail_term,
-                )
-            elif self.random.random() < (self.cop_density + self.citizen_density):
-                agent = Citizen(
-                    self,
-                    citizen_vision,
-                    movement,
-                    hardship=self.random.random(),
-                    regime_legitimacy=legitimacy,
-                    risk_aversion=self.random.random(),
-                    threshold=active_threshold,
-                    arrest_prob_constant=arrest_prob_constant,
-                )
-            else:
-                continue
-            self.grid.place_agent(agent, pos)
-
-        self.active_agents = self.agents
-
-    def step(self):
-        """Run one step of the model."""
-        self.active_agents.shuffle_do("step")
-
-
-if __name__ == "__main__":
-    model = EpsteinCivilViolence(seed=15)
-    simulator = ABMSimulator()
-
-    simulator.setup(model)
-
-    simulator.run_for(time_delta=100)