econagents 0.0.2__tar.gz → 0.0.5__tar.gz

{econagents-0.0.2 → econagents-0.0.5}/PKG-INFO

@@ -1,41 +1,28 @@
 Metadata-Version: 2.3
 Name: econagents
-Version: 0.0.2
-Summary: econagents is a Python library that lets you use LLM agents in economic experiments. The framework connects LLM agents to game servers through WebSockets and provides a flexible architecture for designing, customizing, and running economic simulations.
-License: MIT License
-         
-         Copyright (c) Delft University of Technology
-         
-         Permission is hereby granted, free of charge, to any person obtaining a copy
-         of this software and associated documentation files (the "Software"), to deal
-         in the Software without restriction, including without limitation the rights
-         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-         copies of the Software, and to permit persons to whom the Software is
-         furnished to do so, subject to the following conditions:
-         
-         The above copyright notice and this permission notice shall be included in all
-         copies or substantial portions of the Software.
-         
-         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-         SOFTWARE.
-Requires-Python: >=3.10,<3.13
-Classifier: License :: Other/Proprietary License
+Version: 0.0.5
+Summary: 
+License: MIT
+Author: Dylan Castillo
+Author-email: dylan@iwanalabs.com
+Requires-Python: >=3.10,<4
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
-Provides-Extra: default
 Provides-Extra: langfuse
 Provides-Extra: langsmith
 Provides-Extra: ollama
 Provides-Extra: openai
-Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Provides-Extra: standard
+Requires-Dist: langfuse (>=2.60.3,<3.0.0) ; extra == "langfuse" or extra == "all"
+Requires-Dist: langsmith (>=0.3.33,<0.4.0) ; extra == "langsmith" or extra == "standard" or extra == "all"
+Requires-Dist: ollama (>=0.4.8,<0.5.0) ; extra == "ollama" or extra == "all"
+Requires-Dist: openai (>=1.68.2,<2.0.0) ; extra == "openai" or extra == "standard" or extra == "all"
+Requires-Dist: pydantic (>=2.11.3,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: websockets (>=15.0,<16.0)
 Description-Content-Type: text/markdown

{econagents-0.0.2 → econagents-0.0.5}/econagents/__init__.py

@@ -12,7 +12,7 @@ from econagents.core.state.game import GameState, MetaInformation, PrivateInform
 from econagents.llm.openai import ChatOpenAI
 
 # Don't manually change, let poetry-dynamic-versioning handle it.
-__version__ = "0.0.2"
+__version__ = "0.0.5"
 
 __all__: list[str] = [
     "AgentRole",

{econagents-0.0.2 → econagents-0.0.5}/econagents/core/agent_role.py

@@ -3,6 +3,7 @@ import logging
 import re
 from abc import ABC
 from pathlib import Path
+from jinja2 import FileSystemLoader
 from typing import Any, Callable, ClassVar, Dict, Generic, Literal, Optional, Pattern, Protocol, TypeVar
 
 from jinja2.sandbox import SandboxedEnvironment
@@ -129,12 +130,20 @@ class AgentRole(ABC, Generic[StateT_contra], LoggerMixin):
         Raises:
             FileNotFoundError: If no matching prompt template is found
         """
+        # Initialize Jinja environment with a file system loader
+        env = SandboxedEnvironment(loader=FileSystemLoader(prompts_path))
+
         # Try role-specific prompt first, then fall back to 'all'
         for role in [self.name, "all"]:
-            if prompt_file := self._resolve_prompt_file(prompt_type, phase, role, prompts_path):
-                with prompt_file.open() as f:
-                    template = SandboxedEnvironment().from_string(f.read())
-                return template.render(**context)
+            if prompt_file_path := self._resolve_prompt_file(prompt_type, phase, role, prompts_path):
+                # Get filename relative to the prompts_path for the loader
+                template_filename = str(prompt_file_path.relative_to(prompts_path))
+                try:
+                    template = env.get_template(template_filename)
+                    return template.render(**context)
+                except Exception as e:  # Catch potential Jinja errors during loading/rendering
+                    self.logger.error(f"Error loading/rendering template {template_filename}: {e}")
+                    raise  # Re-raise after logging
 
         raise FileNotFoundError(
             f"No prompt template found for type={prompt_type}, phase={phase}, "

{econagents-0.0.2 → econagents-0.0.5}/econagents/core/game_runner.py

@@ -63,6 +63,10 @@ class GameRunnerConfig(BaseModel):
     observability_provider: Optional[Literal["langsmith", "langfuse"]] = None
     """Name of the observability provider to use. Options: 'langsmith' or 'langfuse'"""
 
+    # Agent stop configuration
+    end_game_event: str = "game-over"
+    """Event type that signals the end of the game and should stop the agent."""
+
 
 class TurnBasedGameRunnerConfig(GameRunnerConfig):
     """Configuration class for TurnBasedGameRunner."""
@@ -303,6 +307,10 @@ class GameRunner:
             agent_manager.auth_mechanism = self.config.auth_mechanism
             agent_manager.logger.debug(f"Injected default auth mechanism: {agent_manager.auth_mechanism}")
 
+        if agent_manager.end_game_event_type != self.config.end_game_event:
+            agent_manager.end_game_event_type = self.config.end_game_event
+            agent_manager.logger.debug(f"Injected default end game event: {agent_manager.end_game_event_type}")
+
         if agent_manager.llm_provider and self.config.observability_provider:
             try:
                 provider = get_observability_provider(self.config.observability_provider)
@@ -349,7 +357,7 @@ class GameRunner:
             agent_manager.logger.info(f"Connecting to WebSocket URL: {agent_manager.url}")
             await agent_manager.start()
         except Exception:
-            agent_manager.logger.exception(f"Error in simulation for Agent {agent_id}")
+            agent_manager.logger.exception(f"Error in game for Agent {agent_id}")
             raise
 
     async def run_game(self) -> None:
@@ -360,7 +368,7 @@ class GameRunner:
 
         try:
             tasks = []
-            game_logger.info("Starting simulations")
+            game_logger.info("Starting game")
 
             for i, agent_manager in enumerate(self.agents, start=1):
                 tasks.append(self.spawn_agent(agent_manager, i))
@@ -369,4 +377,5 @@ class GameRunner:
             game_logger.exception(f"Failed to run game: {e}")
             raise
         finally:
+            game_logger.info("Game over")
             self.cleanup_logging()

{econagents-0.0.2 → econagents-0.0.5}/econagents/core/manager/base.py

@@ -68,6 +68,10 @@ class AgentManager(LoggerMixin):
         self._global_pre_event_hooks: list[Callable[[Message], Any]] = []
         self._global_post_event_hooks: list[Callable[[Message], Any]] = []
 
+        # Default event type to trigger stopping the agent
+        self._end_game_event_type: str = "game-over"
+        self.register_event_handler(self._end_game_event_type, self._handle_end_game)
+
         # Initialize transport if URL is provided
         if url:
             self._initialize_transport()
@@ -156,6 +160,30 @@ class AgentManager(LoggerMixin):
             return None
         return Message(message_type=message_type, event_type=event_type, data=data)
 
+    @property
+    def end_game_event_type(self) -> str:
+        """Get the event type that triggers the agent to stop."""
+        return self._end_game_event_type
+
+    @end_game_event_type.setter
+    def end_game_event_type(self, value: str):
+        """
+        Set the event type that triggers the agent to stop.
+
+        Unregisters the stop handler from the old event type and registers it
+        for the new event type.
+
+        Args:
+            value (str): The new event type to listen for.
+        """
+        if self._end_game_event_type != value:
+            # Unregister from the old event type
+            self.unregister_event_handler(self._end_game_event_type, self._handle_end_game)
+            # Register for the new event type
+            self._end_game_event_type = value
+            self.register_event_handler(self._end_game_event_type, self._handle_end_game)
+            self.logger.info(f"End game event type set to: {value}")
+
     async def on_message(self, message: Message):
         """
         Default implementation to handle incoming messages from the server.
@@ -202,6 +230,7 @@ class AgentManager(LoggerMixin):
         self.running = False
         if self.transport:
             await self.transport.stop()
+            self.logger.info("Agent manager stopped and connection closed.")
 
     async def on_event(self, message: Message):
         """
@@ -270,6 +299,16 @@ class AgentManager(LoggerMixin):
             if hasattr(result, "__await__"):
                 await result
 
+    async def _handle_end_game(self, message: Message):
+        """
+        Default handler for the 'end_game_event_type'. Stops the agent manager.
+
+        Args:
+            message (Message): The event message triggering the end game.
+        """
+        self.logger.info(f"Received end game event ({message.event_type}). Stopping agent manager...")
+        await self.stop()
+
     # Event handler registration
     def register_event_handler(self, event_type: str, handler: Callable[[Message], Any]):
         """
@@ -355,7 +394,17 @@ class AgentManager(LoggerMixin):
             if handler is None:
                 self._event_handlers.pop(event_type)
             else:
-                self._event_handlers[event_type] = [h for h in self._event_handlers[event_type] if h != handler]
+                # Use list comprehension to avoid modifying list while iterating
+                handlers_to_keep = [h for h in self._event_handlers[event_type] if h != handler]
+                if not handlers_to_keep:
+                    # Remove the key if the list becomes empty
+                    self._event_handlers.pop(event_type, None)
+                else:
+                    self._event_handlers[event_type] = handlers_to_keep
+                # Explicitly handle removal of the default end game handler
+                if event_type == self._end_game_event_type and handler == self._handle_end_game:
+                    self.logger.warning(f"Default end game handler for '{event_type}' unregistered.")
+
         return self
 
     def unregister_global_event_handler(self, handler: Optional[Callable] = None):
@@ -384,7 +433,13 @@ class AgentManager(LoggerMixin):
             if hook is None:
                 self._pre_event_hooks.pop(event_type)
             else:
-                self._pre_event_hooks[event_type] = [h for h in self._pre_event_hooks[event_type] if h != hook]
+                # Use list comprehension to avoid modifying list while iterating
+                hooks_to_keep = [h for h in self._pre_event_hooks[event_type] if h != hook]
+                if not hooks_to_keep:
+                    # Remove the key if the list becomes empty
+                    self._pre_event_hooks.pop(event_type, None)
+                else:
+                    self._pre_event_hooks[event_type] = hooks_to_keep
         return self
 
     def unregister_global_pre_event_hook(self, hook: Optional[Callable] = None):
@@ -413,7 +468,13 @@ class AgentManager(LoggerMixin):
             if hook is None:
                 self._post_event_hooks.pop(event_type)
             else:
-                self._post_event_hooks[event_type] = [h for h in self._post_event_hooks[event_type] if h != hook]
+                # Use list comprehension to avoid modifying list while iterating
+                hooks_to_keep = [h for h in self._post_event_hooks[event_type] if h != hook]
+                if not hooks_to_keep:
+                    # Remove the key if the list becomes empty
+                    self._post_event_hooks.pop(event_type, None)
+                else:
+                    self._post_event_hooks[event_type] = hooks_to_keep
         return self
 
     def unregister_global_post_event_hook(self, hook: Optional[Callable] = None):

{econagents-0.0.2 → econagents-0.0.5}/econagents/core/manager/phase.py

@@ -3,14 +3,14 @@ import json
 import logging
 import random
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Optional
 from pathlib import Path
+from typing import Any, Callable, Optional
 
 from econagents.core.agent_role import AgentRole
 from econagents.core.events import Message
 from econagents.core.manager.base import AgentManager
 from econagents.core.state.game import GameState
-from econagents.core.transport import AuthenticationMechanism, SimpleLoginPayloadAuth
+from econagents.core.transport import AuthenticationMechanism
 
 
 class PhaseManager(AgentManager, ABC):

{econagents-0.0.2 → econagents-0.0.5}/econagents/core/state/game.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, Protocol, Type, TypeVar
+from typing import Any, Callable, Optional, Protocol, Type, TypeVar, cast
 
 from pydantic import BaseModel, ConfigDict
 
@@ -220,3 +220,25 @@ class GameState(BaseModel):
             dict[str, EventHandler]: A mapping of event types to handler functions.
         """
         return {}
+
+    def reset(self) -> None:
+        """
+        Resets meta, private_information, and public_information
+        to their initial state by re-initializing them using their default factories.
+        This effectively removes any dynamically added attributes.
+        """
+        # Re-initialize components using their default factories from the GameState model definition
+        meta_field = self.__class__.model_fields["meta"]
+        if meta_field.default_factory:
+            fac = cast("Callable[[], Any]", meta_field.default_factory)
+            self.meta = fac()
+
+        private_field = self.__class__.model_fields["private_information"]
+        if private_field.default_factory:
+            fac = cast("Callable[[], Any]", private_field.default_factory)
+            self.private_information = fac()
+
+        public_field = self.__class__.model_fields["public_information"]
+        if public_field.default_factory:
+            fac = cast("Callable[[], Any]", public_field.default_factory)
+            self.public_information = fac()

{econagents-0.0.2 → econagents-0.0.5}/pyproject.toml

@@ -9,8 +9,7 @@ style = "semver"
 
 [project]
 name = "econagents"
-license = { file = "LICENSE" }
-description = "econagents is a Python library that lets you use LLM agents in economic experiments. The framework connects LLM agents to game servers through WebSockets and provides a flexible architecture for designing, customizing, and running economic simulations."
+license = "MIT"
 readme = "README.md"
 homepage = "https://github.com/iwanalabs/econagents"
 repository = "https://github.com/iwanalabs/econagents"
@@ -18,44 +17,27 @@ dynamic = ["version"]
 
 [tool.poetry]
 name = "econagents"
-version = "0.0.2"  # Do not change, let poetry-dynamic-versioning handle it.
+version = "0.0.5"  # Do not change, let poetry-dynamic-versioning handle it.
 packages = [{include = "econagents"}]
 include = ["econagents/*.so", "econagents/*.pyd"]  # Compiled extensions
+license = "MIT"
+description = ""
+authors = ["Dylan Castillo <dylan@iwanalabs.com>"]
 
 [tool.poetry.build]
 generate-setup-file = false
 
 [tool.poetry.dependencies]
 # Be as loose as possible if writing a library.
-python = ">=3.10,<3.13"
-pydantic = "^2.10.6"
+python = ">=3.10,<4"
+pydantic = "^2.11.3"
 requests = "^2.32.3"
 websockets = "^15.0"
+openai = {version = "^1.68.2", optional = true}
+ollama = {version = "^0.4.8", optional = true}
+langsmith = {version = "^0.3.33", optional = true}
+langfuse = {version = "^2.60.3", optional = true}
 
-# Optional dependencies
-[tool.poetry.group.openai]
-optional = true
-
-[tool.poetry.group.openai.dependencies]
-openai = "^1.68.2"
-
-[tool.poetry.group.ollama]
-optional = true
-
-[tool.poetry.group.ollama.dependencies]
-ollama = "^0.1.9"
-
-[tool.poetry.group.langsmith]
-optional = true
-
-[tool.poetry.group.langsmith.dependencies]
-langsmith = "^0.3.19"
-
-[tool.poetry.group.langfuse]
-optional = true
-
-[tool.poetry.group.langfuse.dependencies]
-langfuse = "^2.60.2"
 
 [tool.poetry.group.docs.dependencies]
 myst-parser = {extras = ["linkify"], version = "^4.0.1"}
@@ -74,7 +56,7 @@ pytest-mock = ">=3.7.0"
 python-dotenv = "^1.0.1"
 jupyter = "^1.1.1"
 nest-asyncio = "^1.6.0"
-ruff = "^0.11.2"
+ruff = "^0.11.6"
 types-requests = "^2.32.0.20250306"
 pytest-asyncio = "^0.25.3"
 
@@ -179,5 +161,5 @@ openai = ["openai"]
 ollama = ["ollama"]
 langsmith = ["langsmith"]
 langfuse = ["langfuse"]
-default = ["openai", "langsmith"]
+standard = ["openai", "langsmith"]
 all = ["openai", "ollama", "langsmith", "langfuse"]