Mesa 3.0.0b1__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

examples/advanced/wolf_sheep/wolf_sheep/server.py

@@ -1,78 +0,0 @@
-import mesa
-from wolf_sheep.agents import GrassPatch, Sheep, Wolf
-from wolf_sheep.model import WolfSheep
-
-
-def wolf_sheep_portrayal(agent):
-    if agent is None:
-        return
-
-    portrayal = {}
-
-    if type(agent) is Sheep:
-        portrayal["Shape"] = "wolf_sheep/resources/sheep.png"
-        # https://icons8.com/web-app/433/sheep
-        portrayal["scale"] = 0.9
-        portrayal["Layer"] = 1
-
-    elif type(agent) is Wolf:
-        portrayal["Shape"] = "wolf_sheep/resources/wolf.png"
-        # https://icons8.com/web-app/36821/German-Shepherd
-        portrayal["scale"] = 0.9
-        portrayal["Layer"] = 2
-        portrayal["text"] = round(agent.energy, 1)
-        portrayal["text_color"] = "White"
-
-    elif type(agent) is GrassPatch:
-        if agent.fully_grown:
-            portrayal["Color"] = ["#00FF00", "#00CC00", "#009900"]
-        else:
-            portrayal["Color"] = ["#84e184", "#adebad", "#d6f5d6"]
-        portrayal["Shape"] = "rect"
-        portrayal["Filled"] = "true"
-        portrayal["Layer"] = 0
-        portrayal["w"] = 1
-        portrayal["h"] = 1
-
-    return portrayal
-
-
-canvas_element = mesa.visualization.CanvasGrid(wolf_sheep_portrayal, 20, 20, 500, 500)
-chart_element = mesa.visualization.ChartModule(
-    [
-        {"Label": "Wolves", "Color": "#AA0000"},
-        {"Label": "Sheep", "Color": "#666666"},
-        {"Label": "Grass", "Color": "#00AA00"},
-    ]
-)
-
-model_params = {
-    # The following line is an example to showcase StaticText.
-    "title": mesa.visualization.StaticText("Parameters:"),
-    "grass": mesa.visualization.Checkbox("Grass Enabled", True),
-    "grass_regrowth_time": mesa.visualization.Slider("Grass Regrowth Time", 20, 1, 50),
-    "initial_sheep": mesa.visualization.Slider(
-        "Initial Sheep Population", 100, 10, 300
-    ),
-    "sheep_reproduce": mesa.visualization.Slider(
-        "Sheep Reproduction Rate", 0.04, 0.01, 1.0, 0.01
-    ),
-    "initial_wolves": mesa.visualization.Slider("Initial Wolf Population", 50, 10, 300),
-    "wolf_reproduce": mesa.visualization.Slider(
-        "Wolf Reproduction Rate",
-        0.05,
-        0.01,
-        1.0,
-        0.01,
-        description="The rate at which wolf agents reproduce.",
-    ),
-    "wolf_gain_from_food": mesa.visualization.Slider(
-        "Wolf Gain From Food Rate", 20, 1, 50
-    ),
-    "sheep_gain_from_food": mesa.visualization.Slider("Sheep Gain From Food", 4, 1, 10),
-}
-
-server = mesa.visualization.ModularServer(
-    WolfSheep, [canvas_element, chart_element], "Wolf Sheep Predation", model_params
-)
-server.port = 8521

examples/basic/__init__.py

@@ -1,13 +0,0 @@
-from .boid_flockers.model import BoidFlockers
-from .boltzmann_wealth_model.model import BoltzmannWealthModel
-from .conways_game_of_life.model import ConwaysGameOfLife
-from .schelling.model import Schelling
-from .virus_on_network.model import VirusOnNetwork
-
-__all__ = [
-    "BoidFlockers",
-    "BoltzmannWealthModel",
-    "ConwaysGameOfLife",
-    "Schelling",
-    "VirusOnNetwork",
-]

examples/basic/boid_flockers/Readme.md

@@ -1,43 +0,0 @@
-# Boids Flockers
-
-## Summary
-
-An implementation of Craig Reynolds's Boids flocker model. Agents (simulated birds) try to fly towards the average position of their neighbors and in the same direction as them, while maintaining a minimum distance. This produces flocking behavior.
-
-This model tests Mesa's continuous space feature, and uses numpy arrays to represent vectors. It also demonstrates how to create custom visualization components.
-
-## Installation
-
-To install the dependencies use pip and the requirements.txt in this directory. e.g.
-
-```
-    $ pip install -r requirements.txt
-```
-
-## How to Run
-
-* To launch the visualization interactively, run ``mesa runserver`` in this directory. e.g.
-
-```
-$ mesa runserver
-```
-
-or
-
-Directly run the file ``run.py`` in the terminal. e.g.
-
-```
-    $ python run.py
-```
-
-* Then open your browser to [http://127.0.0.1:8521/](http://127.0.0.1:8521/) and press Reset, then Run.
-
-## Files
-
-* [model.py](model.py): Core model file; contains the Boid Model and Boid Agent class.
-* [app.py](app.py): Visualization code.
-
-## Further Reading
-
-The following link can be visited for more information on the boid flockers model:
-https://cs.stanford.edu/people/eroberts/courses/soco/projects/2008-09/modeling-natural-systems/boids.html

examples/basic/conways_game_of_life/portrayal.py

@@ -1,18 +0,0 @@
-def portrayCell(cell):
-    """This function is registered with the visualization server to be called
-    each tick to indicate how to draw the cell in its current state.
-    :param cell:  the cell in the simulation
-    :return: the portrayal dictionary.
-    """
-    if cell is None:
-        raise AssertionError
-    return {
-        "Shape": "rect",
-        "w": 1,
-        "h": 1,
-        "Filled": "true",
-        "Layer": 0,
-        "x": cell.x,
-        "y": cell.y,
-        "Color": "black" if cell.isAlive else "white",
-    }

examples/basic/conways_game_of_life/requirements.txt

@@ -1 +0,0 @@
-mesa~=2.0

examples/basic/conways_game_of_life/server.py

@@ -1,11 +0,0 @@
-import mesa
-
-from .model import ConwaysGameOfLife
-from .portrayal import portrayCell
-
-# Make a world that is 50x50, on a 250x250 display.
-canvas_element = mesa.visualization.CanvasGrid(portrayCell, 50, 50, 250, 250)
-
-server = mesa.visualization.ModularServer(
-    ConwaysGameOfLife, [canvas_element], "Game of Life", {"height": 50, "width": 50}
-)

examples/basic/virus_on_network/app.py

@@ -1,133 +0,0 @@
-import math
-
-import solara
-from matplotlib.figure import Figure
-from matplotlib.ticker import MaxNLocator
-
-from mesa.visualization import Slider, SolaraViz, make_space_matplotlib
-
-from .model import State, VirusOnNetwork, number_infected
-
-
-def agent_portrayal(graph):
-    def get_agent(node):
-        return graph.nodes[node]["agent"][0]
-
-    edge_width = []
-    edge_color = []
-    for u, v in graph.edges():
-        agent1 = get_agent(u)
-        agent2 = get_agent(v)
-        w = 2
-        ec = "#e8e8e8"
-        if State.RESISTANT in (agent1.state, agent2.state):
-            w = 3
-            ec = "black"
-        edge_width.append(w)
-        edge_color.append(ec)
-    node_color_dict = {
-        State.INFECTED: "tab:red",
-        State.SUSCEPTIBLE: "tab:green",
-        State.RESISTANT: "tab:gray",
-    }
-    node_color = [node_color_dict[get_agent(node).state] for node in graph.nodes()]
-    return {
-        "width": edge_width,
-        "edge_color": edge_color,
-        "node_color": node_color,
-    }
-
-
-def get_resistant_susceptible_ratio(model):
-    ratio = model.resistant_susceptible_ratio()
-    ratio_text = r"$\infty$" if ratio is math.inf else f"{ratio:.2f}"
-    infected_text = str(number_infected(model))
-
-    return f"Resistant/Susceptible Ratio: {ratio_text}<br>Infected Remaining: {infected_text}"
-
-
-def make_plot(model):
-    # This is for the case when we want to plot multiple measures in 1 figure.
-    fig = Figure()
-    ax = fig.subplots()
-    measures = ["Infected", "Susceptible", "Resistant"]
-    colors = ["tab:red", "tab:green", "tab:gray"]
-    for i, m in enumerate(measures):
-        color = colors[i]
-        df = model.datacollector.get_model_vars_dataframe()
-        ax.plot(df.loc[:, m], label=m, color=color)
-    fig.legend()
-    # Set integer x axis
-    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
-    ax.set_xlabel("Step")
-    ax.set_ylabel("Number of Agents")
-    return solara.FigureMatplotlib(fig)
-
-
-model_params = {
-    "num_nodes": Slider(
-        label="Number of agents",
-        value=10,
-        min=10,
-        max=100,
-        step=1,
-    ),
-    "avg_node_degree": Slider(
-        label="Avg Node Degree",
-        value=3,
-        min=3,
-        max=8,
-        step=1,
-    ),
-    "initial_outbreak_size": Slider(
-        label="Initial Outbreak Size",
-        value=1,
-        min=1,
-        max=10,
-        step=1,
-    ),
-    "virus_spread_chance": Slider(
-        label="Virus Spread Chance",
-        value=0.4,
-        min=0.0,
-        max=1.0,
-        step=0.1,
-    ),
-    "virus_check_frequency": Slider(
-        label="Virus Check Frequency",
-        value=0.4,
-        min=0.0,
-        max=1.0,
-        step=0.1,
-    ),
-    "recovery_chance": Slider(
-        label="Recovery Chance",
-        value=0.3,
-        min=0.0,
-        max=1.0,
-        step=0.1,
-    ),
-    "gain_resistance_chance": Slider(
-        label="Gain Resistance Chance",
-        value=0.5,
-        min=0.0,
-        max=1.0,
-        step=0.1,
-    ),
-}
-
-SpacePlot = make_space_matplotlib(agent_portrayal)
-
-model1 = VirusOnNetwork()
-
-page = SolaraViz(
-    model1,
-    [
-        SpacePlot,
-        make_plot,
-        # get_resistant_susceptible_ratio,  # TODO: Fix and uncomment
-    ],
-    model_params=model_params,
-    name="Virus Model",
-)
-page  # noqa

mesa/cookiecutter-mesa/cookiecutter.json

@@ -1,8 +0,0 @@
-{
-    "project": "Example Project",
-    "snake": "{{ cookiecutter.project.lower().replace(' ', '_') }}",
-    "camel": "{{ cookiecutter.project.title().replace(' ', '') }}",
-    "agent": "{{ cookiecutter.camel + 'Agent'}}",
-    "model": "{{ cookiecutter.camel + 'Model'}}",
-    "description": "Example short description of the project"
-}

mesa/cookiecutter-mesa/hooks/post_gen_project.py

@@ -1,13 +0,0 @@
-"""helper module."""
-
-import glob
-import os
-
-file_list = glob.glob("**/*.pytemplate", recursive=True)
-
-for file_path in file_list:
-    # Check if the file is a regular file
-    if not os.path.isfile(file_path):
-        continue
-    # Rename the file
-    os.rename(file_path, file_path.replace(".pytemplate", ".py"))

mesa/cookiecutter-mesa/{{cookiecutter.snake}}/README.md

@@ -1,4 +0,0 @@
-{{cookiecutter.project}}
-========================
-
-{{cookiecutter.description}}

mesa/cookiecutter-mesa/{{cookiecutter.snake}}/app.pytemplate

@@ -1,27 +0,0 @@
-"""
-Configure visualization elements and instantiate a server
-"""
-from mesa.visualization import SolaraViz
-
-from {{ cookiecutter.snake }}.model import {{ cookiecutter.model }}, {{ cookiecutter.agent }}  # noqa
-
-import mesa
-
-
-def circle_portrayal_example(agent):
-    return {
-        "size": 40,
-        # This is Matplotlib's color
-        "color": "tab:pink",
-    }
-
-
-model_params = {"num_agents": 10, "width": 10, "height": 10}
-
-page = SolaraViz(
-    {{cookiecutter.model}},
-    model_params,
-    measures=["num_agents"],
-    agent_portrayal=circle_portrayal_example
-)
-page  # noqa

mesa/cookiecutter-mesa/{{cookiecutter.snake}}/setup.pytemplate

@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-from setuptools import find_packages, setup
-
-requires = ["mesa"]
-
-setup(
-    name="{{cookiecutter.snake}}",
-    version="0.0.1",
-    packages=find_packages(),
-    install_requires=requires,
-)

mesa/cookiecutter-mesa/{{cookiecutter.snake}}/{{cookiecutter.snake}}/__init__.py

@@ -1 +0,0 @@
-"""helper modules."""

mesa/cookiecutter-mesa/{{cookiecutter.snake}}/{{cookiecutter.snake}}/model.pytemplate

@@ -1,60 +0,0 @@
-import mesa
-
-
-class {{cookiecutter.agent}}(mesa.Agent):  # noqa
-    """
-    An agent
-    """
-
-    def __init__(self, unique_id, model):
-        """
-        Customize the agent
-        """
-        self.unique_id = unique_id
-        super().__init__(unique_id, model)
-
-    def step(self):
-        """
-        Modify this method to change what an individual agent will do during each step.
-        Can include logic based on neighbors states.
-        """
-        pass
-
-
-class {{cookiecutter.model}}(mesa.Model):
-    """
-    The model class holds the model-level attributes, manages the agents, and generally handles
-    the global level of our model.
-
-    There is only one model-level parameter: how many agents the model contains. When a new model
-    is started, we want it to populate itself with the given number of agents.
-
-    The scheduler is a special model component which controls the order in which agents are activated.
-    """
-
-    def __init__(self, num_agents, width, height):
-        super().__init__()
-        self.num_agents = num_agents
-        self.schedule = mesa.time.RandomActivation(self)
-        self.grid = mesa.space.MultiGrid(width=width, height=height, torus=True)
-
-        for i in range(self.num_agents):
-            agent = {{cookiecutter.agent}}(i, self)
-            self.schedule.add(agent)
-
-            x = self.random.randrange(self.grid.width)
-            y = self.random.randrange(self.grid.height)
-            self.grid.place_agent(agent, (x, y))
-
-        # example data collector
-        self.datacollector = mesa.datacollection.DataCollector({"num_agents": "num_agents"})
-
-        self.running = True
-        self.datacollector.collect(self)
-
-    def step(self):
-        """
-        A model step. Used for collecting data and advancing the schedule
-        """
-        self.datacollector.collect(self)
-        self.schedule.step()

mesa/examples.py

@@ -1,3 +0,0 @@
-"""This module is a collection of example models built using the Mesa framework."""
-
-__path__ = ["examples"]

mesa/main.py

@@ -1,65 +0,0 @@
-"""main module for running mesa models with a server."""
-
-import os
-import sys
-from pathlib import Path
-from subprocess import call
-
-import click
-
-from mesa import __version__
-
-PROJECT_PATH = click.Path(
-    exists=True, file_okay=False, dir_okay=True, resolve_path=True
-)
-COOKIECUTTER_DIR = "mesa/cookiecutter-mesa"
-SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
-COOKIECUTTER_PATH = os.path.join(os.path.dirname(SCRIPTS_DIR), COOKIECUTTER_DIR)
-
-CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
-
-
-@click.group(context_settings=CONTEXT_SETTINGS)
-def cli():
-    """Manage Mesa projects."""
-
-
-@cli.command()
-@click.argument("project", type=PROJECT_PATH, default=".")
-def runserver(project):
-    """Run mesa project PROJECT.
-
-    PROJECT is the path to the directory containing `run.py`, or the current
-    directory if not specified.
-    """
-    run_files = ["run.py", "server.py"]
-    for run_file in run_files:
-        run_path = Path(project) / run_file
-        if not run_path.exists():
-            continue
-        args = [sys.executable, str(run_path)]
-        call(args)
-    sys.exit(f"ERROR: file run.py or server.py (in {Path(project)}) does not exist")
-
-
-@click.command()
-@click.option(
-    "--no-input", is_flag=True, help="Do not prompt user for custom mesa model input."
-)
-def startproject(no_input):
-    """Create a new mesa project."""
-    args = ["cookiecutter", COOKIECUTTER_PATH]
-    if no_input:
-        args.append("--no-input")
-    call(args)
-
-
-@click.command()
-def version():
-    """Show the version of mesa."""
-    print(f"mesa {__version__}")
-
-
-cli.add_command(runserver)
-cli.add_command(startproject)
-cli.add_command(version)

mesa/visualization/components/altair.py

@@ -1,88 +0,0 @@
-"""Altair based solara components for visualization mesa spaces."""
-
-import contextlib
-
-import solara
-
-with contextlib.suppress(ImportError):
-    import altair as alt
-
-from mesa.visualization.utils import update_counter
-
-
-def make_space_altair(agent_portrayal=None):  # noqa: D103
-    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):  # noqa: D103
-    update_counter.get()
-    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