Mesa 3.0.0__py3-none-any.whl → 3.0.0a0__py3-none-any.whl

mesa/experimental/cell_space/cell.py

@@ -1,20 +1,13 @@
-"""The Cell in a cell space."""
-
 from __future__ import annotations
 
-from collections.abc import Callable
-from functools import cache, cached_property
+from functools import cache
 from random import Random
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
-from mesa.experimental.cell_space.cell_agent import CellAgent
 from mesa.experimental.cell_space.cell_collection import CellCollection
-from mesa.space import PropertyLayer
 
 if TYPE_CHECKING:
-    from mesa.agent import Agent
-
-Coordinate = tuple[int, ...]
+    from mesa.experimental.cell_space.cell_agent import CellAgent
 
 
 class Cell:
@@ -31,13 +24,11 @@ class Cell:
 
     __slots__ = [
         "coordinate",
-        "connections",
+        "_connections",
         "agents",
         "capacity",
         "properties",
         "random",
-        "_mesa_property_layers",
-        "__dict__",
     ]
 
     # def __new__(cls,
@@ -51,40 +42,34 @@ class Cell:
 
     def __init__(
         self,
-        coordinate: Coordinate,
-        capacity: int | None = None,
+        coordinate: tuple[int, ...],
+        capacity: float | None = None,
         random: Random | None = None,
     ) -> None:
-        """Initialise the cell.
+        """ "
 
         Args:
-            coordinate: coordinates of the cell
+            coordinate:
             capacity (int) : the capacity of the cell. If None, the capacity is infinite
             random (Random) : the random number generator to use
 
         """
         super().__init__()
         self.coordinate = coordinate
-        self.connections: dict[Coordinate, Cell] = {}
-        self.agents: list[
-            Agent
-        ] = []  # TODO:: change to AgentSet or weakrefs? (neither is very performant, )
-        self.capacity: int | None = capacity
-        self.properties: dict[Coordinate, object] = {}
+        self._connections: list[Cell] = []  # TODO: change to CellCollection?
+        self.agents = []  # TODO:: change to AgentSet or weakrefs? (neither is very performant, )
+        self.capacity = capacity
+        self.properties: dict[str, object] = {}
         self.random = random
-        self._mesa_property_layers: dict[str, PropertyLayer] = {}
 
-    def connect(self, other: Cell, key: Coordinate | None = None) -> None:
+    def connect(self, other: Cell) -> None:
         """Connects this cell to another cell.
 
         Args:
             other (Cell): other cell to connect to
-            key (Tuple[int, ...]): key for the connection. Should resemble a relative coordinate
 
         """
-        if key is None:
-            key = other.coordinate
-        self.connections[key] = other
+        self._connections.append(other)
 
     def disconnect(self, other: Cell) -> None:
         """Disconnects this cell from another cell.
@@ -93,9 +78,7 @@ class Cell:
             other (Cell): other cell to remove from connections
 
         """
-        keys_to_remove = [k for k, v in self.connections.items() if v == other]
-        for key in keys_to_remove:
-            del self.connections[key]
+        self._connections.remove(other)
 
     def add_agent(self, agent: CellAgent) -> None:
         """Adds an agent to the cell.
@@ -121,6 +104,7 @@ class Cell:
 
         """
         self.agents.remove(agent)
+        agent.cell = None
 
     @property
     def is_empty(self) -> bool:
@@ -132,91 +116,37 @@ class Cell:
         """Returns a bool of the contents of a cell."""
         return len(self.agents) == self.capacity
 
-    def __repr__(self):  # noqa
+    def __repr__(self):
         return f"Cell({self.coordinate}, {self.agents})"
 
-    @cached_property
-    def neighborhood(self) -> CellCollection[Cell]:
-        """Returns the direct neighborhood of the cell.
-
-        This is equivalent to cell.get_neighborhood(radius=1)
-
-        """
-        return self.get_neighborhood()
-
     # FIXME: Revisit caching strategy on methods
     @cache  # noqa: B019
-    def get_neighborhood(
-        self, radius: int = 1, include_center: bool = False
-    ) -> CellCollection[Cell]:
-        """Returns a list of all neighboring cells for the given radius.
-
-        For getting the direct neighborhood (i.e., radius=1) you can also use
-        the `neighborhood` property.
-
-        Args:
-            radius (int): the radius of the neighborhood
-            include_center (bool): include the center of the neighborhood
-
-        Returns:
-            a list of all neighboring cells
-
-        """
-        return CellCollection[Cell](
+    def neighborhood(self, radius=1, include_center=False):
+        return CellCollection(
             self._neighborhood(radius=radius, include_center=include_center),
             random=self.random,
         )
 
     # FIXME: Revisit caching strategy on methods
     @cache  # noqa: B019
-    def _neighborhood(
-        self, radius: int = 1, include_center: bool = False
-    ) -> dict[Cell, list[Agent]]:
+    def _neighborhood(self, radius=1, include_center=False):
         # if radius == 0:
         #     return {self: self.agents}
         if radius < 1:
             raise ValueError("radius must be larger than one")
         if radius == 1:
-            neighborhood = {
-                neighbor: neighbor.agents for neighbor in self.connections.values()
-            }
+            neighborhood = {neighbor: neighbor.agents for neighbor in self._connections}
             if not include_center:
                 return neighborhood
             else:
                 neighborhood[self] = self.agents
                 return neighborhood
         else:
-            neighborhood: dict[Cell, list[Agent]] = {}
-            for neighbor in self.connections.values():
+            neighborhood = {}
+            for neighbor in self._connections:
                 neighborhood.update(
                     neighbor._neighborhood(radius - 1, include_center=True)
                 )
             if not include_center:
                 neighborhood.pop(self, None)
             return neighborhood
-
-    # PropertyLayer methods
-    def get_property(self, property_name: str) -> Any:
-        """Get the value of a property."""
-        return self._mesa_property_layers[property_name].data[self.coordinate]
-
-    def set_property(self, property_name: str, value: Any):
-        """Set the value of a property."""
-        self._mesa_property_layers[property_name].set_cell(self.coordinate, value)
-
-    def modify_property(
-        self, property_name: str, operation: Callable, value: Any = None
-    ):
-        """Modify the value of a property."""
-        self._mesa_property_layers[property_name].modify_cell(
-            self.coordinate, operation, value
-        )
-
-    def __getstate__(self):
-        """Return state of the Cell with connections set to empty."""
-        # fixme, once we shift to 3.11, replace this with super. __getstate__
-        state = (self.__dict__, {k: getattr(self, k) for k in self.__slots__})
-        state[1][
-            "connections"
-        ] = {}  # replace this with empty connections to avoid infinite recursion error in pickle/deepcopy
-        return state

mesa/experimental/cell_space/cell_agent.py

@@ -1,133 +1,37 @@
-"""An agent with movement methods for cell spaces."""
-
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Protocol
+from typing import TYPE_CHECKING
 
-from mesa.agent import Agent
+from mesa import Agent, Model
 
 if TYPE_CHECKING:
-    from mesa.experimental.cell_space import Cell
-
-
-class HasCellProtocol(Protocol):
-    """Protocol for discrete space cell holders."""
-
-    cell: Cell
-
-
-class HasCell:
-    """Descriptor for cell movement behavior."""
-
-    _mesa_cell: Cell | None = None
-
-    @property
-    def cell(self) -> Cell | None:  # noqa: D102
-        return self._mesa_cell
-
-    @cell.setter
-    def cell(self, cell: Cell | None) -> None:
-        # remove from current cell
-        if self.cell is not None:
-            self.cell.remove_agent(self)
-
-        # update private attribute
-        self._mesa_cell = cell
-
-        # add to new cell
-        if cell is not None:
-            cell.add_agent(self)
-
-
-class BasicMovement:
-    """Mixin for moving agents in discrete space."""
-
-    def move_to(self: HasCellProtocol, cell: Cell) -> None:
-        """Move to a new cell."""
-        self.cell = cell
-
-    def move_relative(self: HasCellProtocol, direction: tuple[int, ...]):
-        """Move to a cell relative to the current cell.
-
-        Args:
-            direction: The direction to move in.
-        """
-        new_cell = self.cell.connections.get(direction)
-        if new_cell is not None:
-            self.cell = new_cell
-        else:
-            raise ValueError(f"No cell in direction {direction}")
+    from mesa.experimental.cell_space.cell import Cell
 
 
-class FixedCell(HasCell):
-    """Mixin for agents that are fixed to a cell."""
+class CellAgent(Agent):
+    """Cell Agent is an extension of the Agent class and adds behavior for moving in discrete spaces
 
-    @property
-    def cell(self) -> Cell | None:  # noqa: D102
-        return self._mesa_cell
-
-    @cell.setter
-    def cell(self, cell: Cell) -> None:
-        if self.cell is not None:
-            raise ValueError("Cannot move agent in FixedCell")
-        self._mesa_cell = cell
-
-        cell.add_agent(self)
-
-
-class CellAgent(Agent, HasCell, BasicMovement):
-    """Cell Agent is an extension of the Agent class and adds behavior for moving in discrete spaces.
 
     Attributes:
-        cell (Cell): The cell the agent is currently in.
+        unique_id (int): A unique identifier for this agent.
+        model (Model): The model instance to which the agent belongs
+        pos: (Position | None): The position of the agent in the space
+        cell: (Cell | None): the cell which the agent occupies
     """
 
-    def remove(self):
-        """Remove the agent from the model."""
-        super().remove()
-        self.cell = None  # ensures that we are also removed from cell
-
-
-class FixedAgent(Agent, FixedCell):
-    """A patch in a 2D grid."""
-
-    def remove(self):
-        """Remove the agent from the model."""
-        super().remove()
-
-        # fixme we leave self._mesa_cell on the original value
-        #  so you cannot hijack remove() to move patches
-        self.cell.remove_agent(self)
-
-
-class Grid2DMovingAgent(CellAgent):
-    """Mixin for moving agents in 2D grids."""
-
-    # fmt: off
-    DIRECTION_MAP = {
-        "n": (-1, 0), "north": (-1, 0), "up": (-1, 0),
-        "s": (1, 0), "south": (1, 0), "down": (1, 0),
-        "e": (0, 1), "east": (0, 1), "right": (0, 1),
-        "w": (0, -1), "west": (0, -1), "left": (0, -1),
-        "ne": (-1, 1), "northeast": (-1, 1), "upright": (-1, 1),
-        "nw": (-1, -1), "northwest": (-1, -1), "upleft": (-1, -1),
-        "se": (1, 1), "southeast": (1, 1), "downright": (1, 1),
-        "sw": (1, -1), "southwest": (1, -1), "downleft": (1, -1)
-    }
-    # fmt: on
-
-    def move(self, direction: str, distance: int = 1):
-        """Move the agent in a cardinal direction.
+    def __init__(self, unique_id: int, model: Model) -> None:
+        """
+        Create a new agent.
 
         Args:
-            direction: The cardinal direction to move in.
-            distance: The distance to move.
+            unique_id (int): A unique identifier for this agent.
+            model (Model): The model instance in which the agent exists.
         """
-        direction = direction.lower()  # Convert direction to lowercase
+        super().__init__(unique_id, model)
+        self.cell: Cell | None = None
 
-        if direction not in self.DIRECTION_MAP:
-            raise ValueError(f"Invalid direction: {direction}")
-
-        move_vector = self.DIRECTION_MAP[direction]
-        for _ in range(distance):
-            self.move_relative(move_vector)
+    def move_to(self, cell) -> None:
+        if self.cell is not None:
+            self.cell.remove_agent(self)
+        self.cell = cell
+        cell.add_agent(self)

mesa/experimental/cell_space/cell_collection.py

@@ -1,5 +1,3 @@
-"""CellCollection class."""
-
 from __future__ import annotations
 
 import itertools
@@ -16,7 +14,7 @@ T = TypeVar("T", bound="Cell")
 
 
 class CellCollection(Generic[T]):
-    """An immutable collection of cells.
+    """An immutable collection of cells
 
     Attributes:
         cells (List[Cell]): The list of cells this collection represents
@@ -30,12 +28,6 @@ class CellCollection(Generic[T]):
         cells: Mapping[T, list[CellAgent]] | Iterable[T],
         random: Random | None = None,
     ) -> None:
-        """Initialize a CellCollection.
-
-        Args:
-            cells: cells to add to the collection
-            random: a seeded random number generator.
-        """
         if isinstance(cells, dict):
             self._cells = cells
         else:
@@ -48,71 +40,42 @@ class CellCollection(Generic[T]):
             random = Random()  # FIXME
         self.random = random
 
-    def __iter__(self):  # noqa
+    def __iter__(self):
         return iter(self._cells)
 
-    def __getitem__(self, key: T) -> Iterable[CellAgent]:  # noqa
+    def __getitem__(self, key: T) -> Iterable[CellAgent]:
         return self._cells[key]
 
     # @cached_property
-    def __len__(self) -> int:  # noqa
+    def __len__(self) -> int:
         return len(self._cells)
 
-    def __repr__(self):  # noqa
+    def __repr__(self):
         return f"CellCollection({self._cells})"
 
     @cached_property
-    def cells(self) -> list[T]:  # noqa
+    def cells(self) -> list[T]:
         return list(self._cells.keys())
 
     @property
-    def agents(self) -> Iterable[CellAgent]:  # noqa
+    def agents(self) -> Iterable[CellAgent]:
         return itertools.chain.from_iterable(self._cells.values())
 
     def select_random_cell(self) -> T:
-        """Select a random cell."""
         return self.random.choice(self.cells)
 
     def select_random_agent(self) -> CellAgent:
-        """Select a random agent.
-
-        Returns:
-            CellAgent instance
-
-
-        """
         return self.random.choice(list(self.agents))
 
-    def select(
-        self,
-        filter_func: Callable[[T], bool] | None = None,
-        at_most: int | float = float("inf"),
-    ):
-        """Select cells based on filter function.
-
-        Args:
-            filter_func: filter function
-            at_most: The maximum amount of cells to select. Defaults to infinity.
-              - If an integer, at most the first number of matching cells is selected.
-              - If a float between 0 and 1, at most that fraction of original number of cells
-
-        Returns:
-            CellCollection
-
-        """
-        if filter_func is None and at_most == float("inf"):
+    def select(self, filter_func: Callable[[T], bool] | None = None, n=0):
+        # FIXME: n is not considered
+        if filter_func is None and n == 0:
             return self
 
-        if at_most <= 1.0 and isinstance(at_most, float):
-            at_most = int(len(self) * at_most)  # Note that it rounds down (floor)
-
-        def cell_generator(filter_func, at_most):
-            count = 0
-            for cell in self:
-                if count >= at_most:
-                    break
-                if not filter_func or filter_func(cell):
-                    yield cell
-                    count += 1
-
-        return CellCollection(cell_generator(filter_func, at_most))
+        return CellCollection(
+            {
+                cell: agents
+                for cell, agents in self._cells.items()
+                if filter_func is None or filter_func(cell)
+            }
+        )

mesa/experimental/cell_space/discrete_space.py

@@ -1,16 +1,11 @@
-"""DiscreteSpace base class."""
-
 from __future__ import annotations
 
-from collections.abc import Callable
 from functools import cached_property
 from random import Random
-from typing import Any, Generic, TypeVar
+from typing import Generic, TypeVar
 
-from mesa.agent import AgentSet
 from mesa.experimental.cell_space.cell import Cell
 from mesa.experimental.cell_space.cell_collection import CellCollection
-from mesa.space import PropertyLayer
 
 T = TypeVar("T", bound=Cell)
 
@@ -23,8 +18,8 @@ class DiscreteSpace(Generic[T]):
         all_cells (CellCollection): The cells composing the discrete space
         random (Random): The random number generator
         cell_klass (Type) : the type of cell class
-        empties (CellCollection) : collection of all cells that are empty
-        property_layers (dict[str, PropertyLayer]): the property layers of the discrete space
+        empties (CellCollection) : collecction of all cells that are empty
+
     """
 
     def __init__(
@@ -33,13 +28,6 @@ class DiscreteSpace(Generic[T]):
         cell_klass: type[T] = Cell,
         random: Random | None = None,
     ):
-        """Instantiate a DiscreteSpace.
-
-        Args:
-            capacity: capacity of cells
-            cell_klass: base class for all cells
-            random: random number generator
-        """
         super().__init__()
         self.capacity = capacity
         self._cells: dict[tuple[int, ...], T] = {}
@@ -50,99 +38,27 @@ class DiscreteSpace(Generic[T]):
 
         self._empties: dict[tuple[int, ...], None] = {}
         self._empties_initialized = False
-        self.property_layers: dict[str, PropertyLayer] = {}
 
     @property
-    def cutoff_empties(self):  # noqa
+    def cutoff_empties(self):
         return 7.953 * len(self._cells) ** 0.384
 
-    @property
-    def agents(self) -> AgentSet:
-        """Return an AgentSet with the agents in the space."""
-        return AgentSet(self.all_cells.agents, random=self.random)
-
-    def _connect_cells(self): ...
     def _connect_single_cell(self, cell: T): ...
 
     @cached_property
     def all_cells(self):
-        """Return all cells in space."""
         return CellCollection({cell: cell.agents for cell in self._cells.values()})
 
-    def __iter__(self):  # noqa
+    def __iter__(self):
         return iter(self._cells.values())
 
-    def __getitem__(self, key: tuple[int, ...]) -> T:  # noqa: D105
+    def __getitem__(self, key):
         return self._cells[key]
 
     @property
-    def empties(self) -> CellCollection[T]:
-        """Return all empty in spaces."""
+    def empties(self) -> CellCollection:
         return self.all_cells.select(lambda cell: cell.is_empty)
 
     def select_random_empty_cell(self) -> T:
-        """Select random empty cell."""
+        """select random empty cell"""
         return self.random.choice(list(self.empties))
-
-    # PropertyLayer methods
-    def add_property_layer(
-        self, property_layer: PropertyLayer, add_to_cells: bool = True
-    ):
-        """Add a property layer to the grid.
-
-        Args:
-            property_layer: the property layer to add
-            add_to_cells: whether to add the property layer to all cells (default: True)
-        """
-        if property_layer.name in self.property_layers:
-            raise ValueError(f"Property layer {property_layer.name} already exists.")
-        self.property_layers[property_layer.name] = property_layer
-        if add_to_cells:
-            for cell in self._cells.values():
-                cell._mesa_property_layers[property_layer.name] = property_layer
-
-    def remove_property_layer(self, property_name: str, remove_from_cells: bool = True):
-        """Remove a property layer from the grid.
-
-        Args:
-            property_name: the name of the property layer to remove
-            remove_from_cells: whether to remove the property layer from all cells (default: True)
-        """
-        del self.property_layers[property_name]
-        if remove_from_cells:
-            for cell in self._cells.values():
-                del cell._mesa_property_layers[property_name]
-
-    def set_property(
-        self, property_name: str, value, condition: Callable[[T], bool] | None = None
-    ):
-        """Set the value of a property for all cells in the grid.
-
-        Args:
-            property_name: the name of the property to set
-            value: the value to set
-            condition: a function that takes a cell and returns a boolean
-        """
-        self.property_layers[property_name].set_cells(value, condition)
-
-    def modify_properties(
-        self,
-        property_name: str,
-        operation: Callable,
-        value: Any = None,
-        condition: Callable[[T], bool] | None = None,
-    ):
-        """Modify the values of a specific property for all cells in the grid.
-
-        Args:
-            property_name: the name of the property to modify
-            operation: the operation to perform
-            value: the value to use in the operation
-            condition: a function that takes a cell and returns a boolean (used to filter cells)
-        """
-        self.property_layers[property_name].modify_cells(operation, value, condition)
-
-    def __setstate__(self, state):
-        """Set the state of the discrete space and rebuild the connections."""
-        self.__dict__ = state
-        self._connect_cells()