Remove key_by_name

Update model.py

integrate comments

Author: tpike3

mesa/agent.py

@@ -48,14 +48,11 @@ class Agent:
     # so, unique_id is unique relative to a model, and counting starts from 1
     _ids = defaultdict(functools.partial(itertools.count, 1))
 
-    def __init__(
-        self, model: Model, *args, key_by_name: bool = False, **kwargs
-    ) -> None:
+    def __init__(self, model: Model, *args, **kwargs) -> None:
         """Create a new agent.
 
         Args:
             model (Model): The model instance in which the agent exists.
-            key_by_name (bool): If True, use Agent.__name__ as the key in the model's agents_by_type dictionary.
             args: Passed on to super.
             kwargs: Passed on to super.
         """
@@ -64,7 +61,7 @@ def __init__(
         self.model: Model = model
         self.unique_id: int = next(self._ids[model])
         self.pos: Position | None = None
-        self.model.register_agent(self, key_by_name=key_by_name)
+        self.model.register_agent(self)
 
     def remove(self) -> None:
         """Remove and delete the agent from the model.

mesa/examples/advanced/alliance_formation/model.py

@@ -2,6 +2,7 @@
 import numpy as np
 
 import mesa
+from mesa import Agent
 from mesa.examples.advanced.alliance_formation.agents import AllianceAgent
 from mesa.experimental.meta_agents.meta_agent import (
     create_meta_agent,
@@ -165,6 +166,7 @@ def step(self):
                         self,
                         class_name,
                         alliance,
+                        Agent,
                         meta_attributes={
                             "level": attributes[2],
                             "power": attributes[0],

mesa/experimental/meta_agents/meta_agent.py

@@ -40,7 +40,6 @@
 
 import itertools
 from collections.abc import Callable, Iterable
-from concurrent.futures import ThreadPoolExecutor
 from types import MethodType
 from typing import Any
 
@@ -95,28 +94,22 @@ def find_combinations(
         combinations. Defaults to None.
 
     Returns:
-        List[Tuple[AgentSet, float]]: The list of valuable combinations.
+        List[Tuple[AgentSet, float]]: The list of valuable combinations, in
+        a tuple first agentset of valuable combination  and then the value of
+        the combination.
     """
     combinations = []
-    with ThreadPoolExecutor() as executor:
-        futures = []
-        # Allow one size or range of sizes to be passed
-        size_range = (size, size + 1) if isinstance(size, int) else size
+    # Allow one size or range of sizes to be passed
+    size_range = (size, size + 1) if isinstance(size, int) else size
 
-        candidate_groups = itertools.chain.from_iterable(
-            itertools.combinations(group, size) for size in range(*size_range)
+    for candidate_group in itertools.chain.from_iterable(
+        itertools.combinations(group, size) for size in range(*size_range)
+    ):
+        group_set, result = evaluate_combination(
+            candidate_group, model, evaluation_func
         )
-        for candidate_group in candidate_groups:
-            futures.append(
-                executor.submit(
-                    evaluate_combination, candidate_group, model, evaluation_func
-                )
-            )
-
-        for future in futures:
-            group_set, result = future.result()
-            if result:
-                combinations.append((group_set, result))
+        if result:
+            combinations.append((group_set, result))
 
     if len(combinations) > 0 and filter_func:
         filtered_combinations = filter_func(combinations)
@@ -125,27 +118,31 @@ def find_combinations(
     return combinations
 
 
-def extract_class(agents_by_type: dict, new_agent_class: str):
+def extract_class(agents_by_type: dict, new_agent_class: object) -> type[Agent] | None:
     """Helper function for create_meta_agents extracts the types of agents.
 
     Args:
         agents_by_type (dict): The dictionary of agents by type.
         new_agent_class (str): The name of the agent class to be created
 
     Returns:
-        type(Agent) if it agent type exists
+        type(Agent) if agent type exists
         None otherwise
     """
-    if new_agent_class in agents_by_type:
-        return type(agents_by_type[new_agent_class][0])
+    agent_type_names = {}
+    for agent in agents_by_type:
+        agent_type_names[agent.__name__] = agent
+
+    if new_agent_class in agent_type_names:
+        return type(agents_by_type[agent_type_names[new_agent_class]][0])
     return None
 
 
 def create_meta_agent(
     model: Any,
     new_agent_class: str,
     agents: Iterable[Any],
-    mesa_agent_type=Agent,
+    mesa_agent_type: type[Agent] | None,
     meta_attributes: dict[str, Any] | None = None,
     meta_methods: dict[str, Callable] | None = None,
     assume_subagent_methods: bool = False,
@@ -165,15 +162,17 @@ def create_meta_agent(
     from sub-agents.
 
     Returns:
-        Optional[Any]:
-            - None if adding agent(s) to existing class
-            - New class instance if created a new instance of a dynamically
-            created agent type
-            - New class instance if created a new dynamically created agent type
+        - MetaAgent Instance
     """
     # Convert agents to set to ensure uniqueness
     agents = set(agents)
 
+    # Ensure there is at least one agent base class
+    if not mesa_agent_type:
+        mesa_agent_type = (Agent,)
+    elif not isinstance(mesa_agent_type, tuple):
+        mesa_agent_type = (mesa_agent_type,)
+
     def add_methods(
         meta_agent_instance: Any,
         agents: Iterable[Any],
@@ -236,6 +235,8 @@ def add_attributes(
             add_methods(subagents[0].meta_agent, agents, meta_methods)
             subagents[0].meta_agent.add_subagents(agents)
 
+            return subagents[0].meta_agent  # Return the existing meta-agent
+
         else:
             subagent = model.random.choice(subagents)
             agents = set(agents) - set(subagents)
@@ -244,9 +245,12 @@ def add_attributes(
             subagent.meta_agent.add_subagents(agents)
             # TODO: Add way for user to specify how agents join meta-agent
             # instead of random choice
+            return subagent.meta_agent
+
     else:
         # Path 2 - Create a new instance of an existing meta-agent class
         agent_class = extract_class(model.agents_by_type, new_agent_class)
+
         if agent_class:
             meta_agent_instance = agent_class(model, agents)
             add_attributes(meta_agent_instance, agents, meta_attributes)
@@ -256,7 +260,7 @@ def add_attributes(
             # Path 3 - Create a new meta-agent class
             meta_agent_class = type(
                 new_agent_class,
-                (MetaAgent, mesa_agent_type),  # Use the meta_agent_type parameter here
+                (MetaAgent, *mesa_agent_type),  # Inherit Mesa Agent Classes
                 {
                     "unique_id": None,
                     "_subset": None,
@@ -265,6 +269,7 @@ def add_attributes(
             meta_agent_instance = meta_agent_class(model, agents)
             add_attributes(meta_agent_instance, agents, meta_attributes)
             add_methods(meta_agent_instance, agents, meta_methods)
+            print(meta_agent_instance.agents)
             return meta_agent_instance
 
 
@@ -282,7 +287,7 @@ def __init__(
             include in the MetaAgent. Defaults to None.
             name (str, optional): The name of the MetaAgent. Defaults to "MetaAgent".
         """
-        super().__init__(model, key_by_name=True)
+        super().__init__(model)
         self._subset = AgentSet(agents or [], random=model.random)
         self.name = name
 
@@ -305,7 +310,7 @@ def __contains__(self, agent: Agent) -> bool:
     @property
     def agents(self) -> AgentSet:
         """Get list of Meta-Agent subagents."""
-        return set(self._subset)
+        return self._subset
 
     @property
     def subagents_by_type(self) -> dict[type, list[Agent]]:

tests/test_meta_agents.py

@@ -52,6 +52,7 @@ def test_create_meta_agent_new_class(setup_agents):
         model,
         "MetaAgentClass",
         agents,
+        Agent,
         meta_attributes={"attribute1": "value1"},
         meta_methods={"function1": lambda self: "function1"},
         assume_subagent_attributes=True,
@@ -77,6 +78,7 @@ def test_create_meta_agent_existing_class(setup_agents):
         model,
         "MetaAgentClass",
         [agents[0], agents[2]],
+        Agent,
         meta_attributes={"attribute1": "value1"},
         meta_methods={"function1": lambda self: "function1"},
     )
@@ -86,6 +88,7 @@ def test_create_meta_agent_existing_class(setup_agents):
         model,
         "MetaAgentClass",
         [agents[1], agents[3]],
+        Agent,
         meta_attributes={"attribute2": "value2"},
         meta_methods={"function2": lambda self: "function2"},
         assume_subagent_attributes=True,
@@ -112,6 +115,7 @@ def test_add_agents_to_existing_meta_agent(setup_agents):
         model,
         "MetaAgentClass",
         [agents[0], agents[3]],
+        Agent,
         meta_attributes={"attribute1": "value1"},
         meta_methods={"function1": lambda self: "function1"},
         assume_subagent_attributes=True,
@@ -121,6 +125,7 @@ def test_add_agents_to_existing_meta_agent(setup_agents):
         model,
         "MetaAgentClass",
         [agents[1], agents[0], agents[2]],
+        Agent,
         assume_subagent_attributes=True,
         assume_subagent_methods=True,
     )
@@ -145,6 +150,7 @@ def test_meta_agent_integration(setup_agents):
         model,
         "MetaAgentClass",
         agents,
+        Agent,
         meta_attributes={"attribute1": "value1"},
         meta_methods={"function1": lambda self: "function1"},
         assume_subagent_attributes=True,