econagents 0.0.8__tar.gz → 0.0.10__tar.gz

{econagents-0.0.8 → econagents-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: econagents
-Version: 0.0.8
+Version: 0.0.10
 Summary: 
 License: MIT
 Author: Dylan Castillo

{econagents-0.0.8 → econagents-0.0.10}/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.8"
+__version__ = "0.0.10"
 
 __all__: list[str] = [
     "AgentRole",

{econagents-0.0.8 → econagents-0.0.10}/econagents/config_parser/__init__.py

@@ -4,15 +4,12 @@ Configuration parsers for different server types.
 This package provides configuration parsers for different server types:
 - Base: No custom event handlers
 - Basic: Custom event handler for player-is-ready messages
-- IBEX-TUDelft: Handles player-is-ready messages and role assignment
 """
 
 from econagents.config_parser.base import BaseConfigParser
 from econagents.config_parser.basic import BasicConfigParser
-from econagents.config_parser.ibex_tudelft import IbexTudelftConfigParser
 
 __all__ = [
     "BaseConfigParser",
     "BasicConfigParser",
-    "IbexTudelftConfigParser",
 ]

{econagents-0.0.8 → econagents-0.0.10}/econagents/config_parser/base.py

@@ -8,11 +8,24 @@ from datetime import datetime, date, time
 import yaml
 from pydantic import BaseModel, Field, create_model
 
-from econagents.core.game_runner import GameRunner, GameRunnerConfig, HybridGameRunnerConfig, TurnBasedGameRunnerConfig
-from econagents.core.manager.phase import PhaseManager, TurnBasedPhaseManager, HybridPhaseManager
+from econagents.core.game_runner import (
+    GameRunner,
+    GameRunnerConfig,
+    HybridGameRunnerConfig,
+    TurnBasedGameRunnerConfig,
+)
+from econagents.core.manager.phase import (
+    PhaseManager,
+    TurnBasedPhaseManager,
+    HybridPhaseManager,
+)
 from econagents.core.state.fields import EventField
-from econagents.core.state.game import GameState, MetaInformation, PrivateInformation, PublicInformation
-from econagents.core.state.market import MarketState
+from econagents.core.state.game import (
+    GameState,
+    MetaInformation,
+    PrivateInformation,
+    PublicInformation,
+)
 from econagents.core.agent_role import AgentRole
 
 TYPE_MAPPING = {
@@ -26,7 +39,6 @@ TYPE_MAPPING = {
     "date": date,
     "time": time,
     "any": Any,
-    "MarketState": MarketState,
 }
 
 
@@ -96,7 +108,9 @@ class AgentConfig(BaseModel):
 
         # Create a dynamic AgentRole subclass
         agent_role = type(
-            f"Dynamic{self.name}Role", (AgentRole,), {"role": self.role_id, "name": self.name, "llm": llm_instance}
+            f"Dynamic{self.name}Role",
+            (AgentRole,),
+            {"role": self.role_id, "name": self.name, "llm": llm_instance},
         )
 
         return agent_role()
@@ -133,7 +147,7 @@ class StateConfig(BaseModel):
             else:
                 try:
                     resolved_type = eval(
-                        field_type_str, {"list": list, "dict": dict, "Any": Any, "MarketState": MarketState}
+                        field_type_str, {"list": list, "dict": dict, "Any": Any}
                     )
                     return resolved_type
                 except (NameError, SyntaxError):
@@ -146,10 +160,7 @@ class StateConfig(BaseModel):
             elif factory_name == "dict":
                 return dict
             else:
-                try:
-                    return eval(factory_name, {"MarketState": MarketState})
-                except (NameError, SyntaxError):
-                    raise ValueError(f"Unsupported default_factory: {factory_name}")
+                raise ValueError(f"Unsupported default_factory: {factory_name}")
 
         def create_fields_dict(field_configs: List[StateFieldConfig]) -> Dict[str, Any]:
             """Create a dictionary of field definitions for create_model."""
@@ -166,7 +177,9 @@ class StateConfig(BaseModel):
                 }
                 # Handle default vs default_factory
                 if field.default_factory:
-                    event_field_args["default_factory"] = get_default_factory(field.default_factory)
+                    event_field_args["default_factory"] = get_default_factory(
+                        field.default_factory
+                    )
                 else:
                     # Pydantic handles Optional defaults correctly (None if optional and no default)
                     event_field_args["default"] = field.default
@@ -218,7 +231,11 @@ class ManagerConfig(BaseModel):
     event_handlers: List[EventHandler] = Field(default_factory=list)
 
     def create_manager(
-        self, game_id: int, state: GameState, agent_role: Optional[AgentRole], auth_kwargs: Dict[str, Any]
+        self,
+        game_id: int,
+        state: GameState,
+        agent_role: Optional[AgentRole],
+        auth_kwargs: Dict[str, Any],
     ) -> PhaseManager:
         """Create a PhaseManager instance from this configuration."""
 
@@ -385,7 +402,9 @@ class ExperimentConfig(BaseModel):
 
                     # Create the prompt file name
                     if phase:
-                        file_name = f"{role.name.lower()}_{base_type}_phase_{phase}.jinja2"
+                        file_name = (
+                            f"{role.name.lower()}_{base_type}_phase_{phase}.jinja2"
+                        )
                     else:
                         file_name = f"{role.name.lower()}_{base_type}.jinja2"
 
@@ -395,18 +414,24 @@ class ExperimentConfig(BaseModel):
 
         return temp_dir
 
-    async def run_experiment(self, login_payloads: List[Dict[str, Any]], game_id: int) -> None:
+    async def run_experiment(
+        self, login_payloads: List[Dict[str, Any]], game_id: int
+    ) -> None:
         """Run the experiment from this configuration."""
         # Create state class
         state_class = self.state.create_state_class()
-        role_configs = {role_config.role_id: role_config for role_config in self.agent_roles}
+        role_configs = {
+            role_config.role_id: role_config for role_config in self.agent_roles
+        }
 
         if not self.agent_roles and self.agents:
             raise ValueError(
                 "Configuration has 'agents' but no 'agent_roles'. Cannot determine agent role configurations."
             )
 
-        agent_to_role_map = {agent_map.id: agent_map.role_id for agent_map in self.agents}
+        agent_to_role_map = {
+            agent_map.id: agent_map.role_id for agent_map in self.agents
+        }
 
         # Create managers for each agent
         agents = []
@@ -420,7 +445,9 @@ class ExperimentConfig(BaseModel):
                 raise ValueError(f"No role_id mapping found for agent {agent_id}")
 
             if role_id not in role_configs:
-                raise ValueError(f"No agent role configuration found for role_id {role_id}")
+                raise ValueError(
+                    f"No agent role configuration found for role_id {role_id}"
+                )
 
             agent_role_instance = role_configs[role_id].create_agent_role()
 
@@ -483,7 +510,11 @@ class BaseConfigParser:
         return ExperimentConfig(**config_data)
 
     def create_manager(
-        self, game_id: int, state: GameState, agent_role: Optional[AgentRole], auth_kwargs: Dict[str, Any]
+        self,
+        game_id: int,
+        state: GameState,
+        agent_role: Optional[AgentRole],
+        auth_kwargs: Dict[str, Any],
     ) -> PhaseManager:
         """
         Create a manager instance based on the configuration.
@@ -502,7 +533,9 @@ class BaseConfigParser:
             game_id=game_id, state=state, agent_role=agent_role, auth_kwargs=auth_kwargs
         )
 
-    async def run_experiment(self, login_payloads: List[Dict[str, Any]], game_id: int) -> None:
+    async def run_experiment(
+        self, login_payloads: List[Dict[str, Any]], game_id: int
+    ) -> None:
         """
         Run the experiment from this configuration.
 
@@ -512,7 +545,9 @@ class BaseConfigParser:
         await self.config.run_experiment(login_payloads, game_id)
 
 
-async def run_experiment_from_yaml(yaml_path: Path, login_payloads: List[Dict[str, Any]], game_id: int) -> None:
+async def run_experiment_from_yaml(
+    yaml_path: Path, login_payloads: List[Dict[str, Any]], game_id: int
+) -> None:
     """Run an experiment from a YAML configuration file."""
     parser = BaseConfigParser(yaml_path)
     await parser.run_experiment(login_payloads, game_id)

{econagents-0.0.8 → econagents-0.0.10}/econagents/llm/base.py

@@ -47,7 +47,6 @@ class BaseLLM(ABC):
         self,
         messages: list[dict[str, Any]],
         tracing_extra: dict[str, Any],
-        **kwargs: Any,
     ) -> str:
         """Get a response from the LLM.
 

{econagents-0.0.8 → econagents-0.0.10}/econagents/llm/ollama.py

@@ -15,6 +15,7 @@ class ChatOllama(BaseLLM):
         self,
         model_name: str,
         host: Optional[str] = None,
+        response_kwargs: Optional[dict[str, Any]] = None,
     ) -> None:
         """Initialize the Ollama LLM interface.
 
@@ -25,17 +26,19 @@ class ChatOllama(BaseLLM):
         self._check_ollama_available()
         self.model_name = model_name
         self.host = host
+        self._response_kwargs = response_kwargs or {}
 
     def _check_ollama_available(self) -> None:
         """Check if Ollama is available."""
         if not importlib.util.find_spec("ollama"):
-            raise ImportError("Ollama is not installed. Install it with: pip install econagents[ollama]")
+            raise ImportError(
+                "Ollama is not installed. Install it with: pip install econagents[ollama]"
+            )
 
     async def get_response(
         self,
         messages: List[Dict[str, Any]],
         tracing_extra: Dict[str, Any],
-        **kwargs: Any,
     ) -> str:
         """Get a response from the LLM.
 
@@ -58,7 +61,7 @@ class ChatOllama(BaseLLM):
             response = await client.chat(
                 model=self.model_name,
                 messages=messages,
-                **kwargs,
+                **(self._response_kwargs),
             )
 
             # End the LLM run
@@ -74,4 +77,6 @@ class ChatOllama(BaseLLM):
 
         except ImportError as e:
             logger.error(f"Failed to import Ollama: {e}")
-            raise ImportError("Ollama is not installed. Install it with: pip install econagents[ollama]") from e
+            raise ImportError(
+                "Ollama is not installed. Install it with: pip install econagents[ollama]"
+            ) from e

{econagents-0.0.8 → econagents-0.0.10}/econagents/llm/openai.py

@@ -14,6 +14,7 @@ class ChatOpenAI(BaseLLM):
         self,
         model_name: str = "gpt-4o",
         api_key: Optional[str] = None,
+        response_kwargs: Optional[dict[str, Any]] = None,
     ) -> None:
         """Initialize the OpenAI LLM interface.
 
@@ -24,17 +25,19 @@ class ChatOpenAI(BaseLLM):
         self.model_name = model_name
         self.api_key = api_key
         self._check_openai_available()
+        self._response_kwargs = response_kwargs or {}
 
     def _check_openai_available(self) -> None:
         """Check if OpenAI is available."""
         if not importlib.util.find_spec("openai"):
-            raise ImportError("OpenAI is not installed. Install it with: pip install econagents[openai]")
+            raise ImportError(
+                "OpenAI is not installed. Install it with: pip install econagents[openai]"
+            )
 
     async def get_response(
         self,
         messages: list[dict[str, Any]],
         tracing_extra: dict[str, Any],
-        **kwargs: Any,
     ) -> str:
         """Get a response from the LLM.
 
@@ -59,7 +62,7 @@ class ChatOpenAI(BaseLLM):
                 model=self.model_name,
                 messages=messages,  # type: ignore
                 response_format={"type": "json_object"},
-                **kwargs,
+                **(self._response_kwargs),
             )
 
             # Track the LLM call using the observability provider
@@ -74,4 +77,6 @@ class ChatOpenAI(BaseLLM):
             return response.choices[0].message.content
         except ImportError as e:
             logger.error(f"Failed to import OpenAI: {e}")
-            raise ImportError("OpenAI is not installed. Install it with: pip install econagents[openai]") from e
+            raise ImportError(
+                "OpenAI is not installed. Install it with: pip install econagents[openai]"
+            ) from e

{econagents-0.0.8 → econagents-0.0.10}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 
 [tool.poetry]
 name = "econagents"
-version = "0.0.8"  # Do not change, let poetry-dynamic-versioning handle it.
+version = "0.0.10"  # Do not change, let poetry-dynamic-versioning handle it.
 packages = [{include = "econagents"}]
 include = ["econagents/*.so", "econagents/*.pyd"]  # Compiled extensions
 license = "MIT"
@@ -62,13 +62,13 @@ pre_commit = ">=2.16.0"
 pytest = ">=7.1.2"
 pytest-cov = ">=3.0.0"
 pytest-mock = ">=3.7.0"
-python-dotenv = "^1.0.1"
+python-dotenv = "^1.1.1"
 jupyter = "^1.1.1"
 nest-asyncio = "^1.6.0"
-ruff = "^0.11.13"
-types-requests = "^2.32.4.20250611"
-pytest-asyncio = "^0.26.0"
-types-pyyaml = "^6.0.12.20250516"
+ruff = "^0.12.12"
+types-requests = "^2.32.4.20250809"
+pytest-asyncio = "^1.1.0"
+types-pyyaml = "^6.0.12.20250822"
 
 [tool.poetry.group.debug]
 optional = true

econagents-0.0.8/econagents/config_parser/ibex_tudelft.py

@@ -1,243 +0,0 @@
-import json
-from pathlib import Path
-from typing import Any, Dict, Optional, Type, List, Callable, cast
-from pydantic import create_model
-
-from econagents import AgentRole
-from econagents.core.events import Message
-from econagents.core.manager.phase import PhaseManager
-from econagents.core.state.game import GameState
-from econagents.core.game_runner import GameRunner
-from econagents.config_parser.base import BaseConfigParser
-from econagents.llm.observability import get_observability_provider
-
-
-def handle_market_event_impl(self: GameState, event_type: str, data: dict[str, Any]) -> None:
-    """Handles market-related events by delegating to the MarketState instance."""
-    try:
-        getattr(self.public_information, self.meta._market_state_variable_name).process_event(  # type: ignore
-            event_type=event_type, data=data
-        )
-    except Exception as e:
-        raise ValueError(f"Error processing market event: {e}") from e
-
-
-def handle_asset_movement_event_impl(self: GameState, event_type: str, data: dict[str, Any]) -> None:
-    """Handles asset-movement events by delegating to the MarketState instance."""
-    try:
-        winning_condition = self.public_information.winning_condition  # type: ignore
-        self.private_information.wallet[winning_condition]["balance"] = data["balance"]  # type: ignore
-        self.private_information.wallet[winning_condition]["shares"] = data["shares"]  # type: ignore
-    except Exception as e:
-        raise ValueError(f"Error processing asset-movement event: {e}") from e
-
-
-def get_custom_handlers_impl(self: GameState) -> Dict[str, Callable[[Message], None]]:
-    """Returns custom handlers for market events."""
-    market_events = ["add-order", "update-order", "delete-order", "contract-fulfilled"]
-    asset_movement_event_handlers: Dict[str, Callable[[Message], None]] = {
-        "asset-movement": self._handle_asset_movement_event  # type: ignore
-    }
-    market_event_handlers: Dict[str, Callable[[Message], None]] = {
-        event: self._handle_market_event  # type: ignore
-        for event in market_events
-    }
-    return {**asset_movement_event_handlers, **market_event_handlers}
-
-
-class IbexTudelftConfigParser(BaseConfigParser):
-    """
-    IBEX-TUDelft configuration parser that extends the BasicConfigParser
-    and adds role assignment functionality.
-    """
-
-    def __init__(self, config_path: Path):
-        """
-        Initialize the IBEX-TUDelft config parser.
-
-        Args:
-            config_path: Path to the YAML configuration file
-        """
-        super().__init__(config_path)
-        self._role_classes: Dict[int, Type[AgentRole]] = {}
-
-    def register_role_class(self, role_id: int, role_class: Type[AgentRole]) -> None:
-        """
-        Register a role class for a specific role ID.
-
-        Args:
-            role_id: The role ID
-            role_class: The agent role class
-        """
-        self._role_classes[role_id] = role_class
-
-    def create_manager(
-        self, game_id: int, state: GameState, agent_role: Optional[AgentRole], auth_kwargs: Dict[str, Any]
-    ) -> PhaseManager:
-        """
-        Create a manager instance with custom event handlers for assign-name and assign-role events.
-        The manager won't have a role initially, but will be assigned one during the game.
-
-        Args:
-            game_id: The game ID
-            state: The game state instance
-            agent_role: The agent role instance (may be None)
-            auth_kwargs: Authentication mechanism keyword arguments
-
-        Returns:
-            A PhaseManager instance with custom event handlers
-        """
-        # Get the manager with the name assignment handler
-        manager = super().create_manager(
-            game_id=game_id,
-            state=state,
-            agent_role=None,
-            auth_kwargs=auth_kwargs,
-        )
-
-        # Register custom event handler for assign-name event
-        async def handle_name_assignment(message: Message) -> None:
-            """Handle the name assignment event."""
-            # Include the agent ID from auth_kwargs in the ready message
-            agent_id = auth_kwargs.get("agent_id")
-            ready_msg = {"gameId": game_id, "type": "player-is-ready", "agentId": agent_id}
-            await manager.send_message(json.dumps(ready_msg))
-
-        # Register custom event handler for assign-role event
-        async def handle_role_assignment(message: Message) -> None:
-            """Handle the role assignment event."""
-            role_id = int(message.data.get("role", 0))
-            manager.logger.info(f"Role assigned: {role_id}")
-
-            # Initialize the agent based on the assigned role
-            self._initialize_agent(manager, role_id)
-
-        manager.register_event_handler("assign-role", handle_role_assignment)
-        manager.register_event_handler("assign-name", handle_name_assignment)
-
-        return manager
-
-    def _detect_market_state_in_config(self) -> tuple[bool, Optional[tuple[str, str]]]:
-        """
-        Detects if MarketState is used in the state configuration.
-
-        Returns:
-            A tuple: (has_market_state_field, market_state_details).
-            market_state_details is (field_name_on_section, section_attribute_name_on_gamestate)
-            or None if not found.
-        """
-        state_conf = self.config.state
-        # Check public_information first, then private, then meta
-        for field_conf in state_conf.public_information:
-            if field_conf.type == "MarketState":
-                return True, (field_conf.name, "public_information")
-        for field_conf in state_conf.private_information:
-            if field_conf.type == "MarketState":
-                return True, (field_conf.name, "private_information")
-        for field_conf in state_conf.meta_information:
-            if field_conf.type == "MarketState":
-                return True, (field_conf.name, "meta")
-        return False, None
-
-    def _create_enhanced_state_class(self, base_class: Type[GameState]) -> Type[GameState]:
-        """
-        Creates an enhanced GameState class by subclassing base_class and injecting market event handlers.
-        """
-        enhanced_class_name = f"Enhanced{base_class.__name__}"
-        enhanced_class = create_model(
-            enhanced_class_name,
-            __base__=base_class,
-        )
-        setattr(enhanced_class, "_handle_market_event", handle_market_event_impl)
-        setattr(enhanced_class, "_handle_asset_movement_event", handle_asset_movement_event_impl)
-        setattr(enhanced_class, "get_custom_handlers", get_custom_handlers_impl)
-        return cast(Type[GameState], enhanced_class)
-
-    def _check_additional_required_fields(self, base_dynamic_state_class: Type[GameState]) -> None:
-        public_fields = base_dynamic_state_class().public_information.model_json_schema()["properties"]  # type: ignore
-        private_fields = base_dynamic_state_class().private_information.model_json_schema()["properties"]  # type: ignore
-
-        if (
-            "winning_condition" not in public_fields.keys()  # type: ignore
-            or "wallet" not in private_fields.keys()  # type: ignore
-        ):
-            raise ValueError("Winning condition or wallet is not present in the config")
-
-    async def run_experiment(self, login_payloads: List[Dict[str, Any]], game_id: int) -> None:
-        """
-        Run the experiment from this configuration, potentially enhancing the GameState
-        class with market event handlers if MarketState is specified in the config.
-        """
-        # Step 1: Get the base state class from the original StateConfig
-        base_dynamic_state_class = self.config.state.create_state_class()
-
-        # Step 2: Detect if MarketState is used and get details
-        has_market_state_field, market_state_details = self._detect_market_state_in_config()
-
-        # Step 3: If MarketState is present, create an enhanced state class
-        if has_market_state_field and market_state_details:
-            self._check_additional_required_fields(base_dynamic_state_class)
-            final_state_class = self._create_enhanced_state_class(base_dynamic_state_class)
-        else:
-            final_state_class = base_dynamic_state_class
-
-        if not self.config.agent_roles:
-            raise ValueError("Configuration has no 'agent_roles'.")
-
-        # Create managers for each agent
-        agents_for_runner = []
-        for payload in login_payloads:
-            current_agent_manager = self.create_manager(
-                game_id=game_id,
-                state=final_state_class(),
-                agent_role=None,
-                auth_kwargs=payload,
-            )
-            current_agent_manager.state.meta.game_id = game_id
-            if market_state_details:
-                setattr(current_agent_manager.state.meta, "_market_state_variable_name", market_state_details[0])
-            agents_for_runner.append(current_agent_manager)
-
-        # Create runner config
-        runner_config_instance = self.config.runner.create_runner_config()
-        runner_config_instance.state_class = final_state_class
-        runner_config_instance.game_id = game_id
-
-        if any(hasattr(role, "prompts") and role.prompts for role in self.config.agent_roles):
-            prompts_dir = self.config._compile_inline_prompts()
-            runner_config_instance.prompts_dir = prompts_dir
-
-        runner = GameRunner(config=runner_config_instance, agents=agents_for_runner)
-        await runner.run_game()
-
-        if self.config._temp_prompts_dir and self.config._temp_prompts_dir.exists():
-            import shutil
-
-            shutil.rmtree(self.config._temp_prompts_dir)
-
-    def _initialize_agent(self, manager: PhaseManager, role_id: int) -> None:
-        """
-        Initialize the agent instance based on the assigned role.
-
-        Args:
-            manager: The phase manager instance
-            role_id: The role ID
-        """
-        agent_roles = self.config.agent_roles
-        agent_role = next((role for role in agent_roles if role.role_id == role_id), None)
-        if agent_role:
-            manager.agent_role = agent_role.create_agent_role()
-            manager.agent_role.logger = manager.logger  # type: ignore
-            if self.config.runner.observability_provider:
-                manager.agent_role.llm.observability = get_observability_provider(
-                    self.config.runner.observability_provider
-                )
-        else:
-            manager.logger.error("Invalid role assigned; cannot initialize agent.")
-            raise ValueError("Invalid role for agent initialization.")
-
-
-async def run_experiment_from_yaml(yaml_path: Path, login_payloads: List[Dict[str, Any]], game_id: int) -> None:
-    """Run an experiment from a YAML configuration file."""
-    parser = IbexTudelftConfigParser(yaml_path)
-    await parser.run_experiment(login_payloads, game_id)

econagents-0.0.8/econagents/core/state/market.py

@@ -1,124 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel, Field, computed_field
-
-
-class Order(BaseModel):
-    id: int
-    sender: int
-    price: float
-    quantity: float
-    type: str
-    condition: int
-    now: bool = False
-
-
-class Trade(BaseModel):
-    from_id: int
-    to_id: int
-    price: float
-    quantity: float
-    condition: int
-    median: Optional[float] = None
-
-
-class MarketState(BaseModel):
-    """
-    Represents the current state of the market:
-    - Active orders in an order book
-    - History of recent trades
-    """
-
-    orders: dict[int, Order] = Field(default_factory=dict)
-    trades: list[Trade] = Field(default_factory=list)
-
-    @computed_field
-    def order_book(self) -> str:
-        asks = sorted(
-            [order for order in self.orders.values() if order.type == "ask"],
-            key=lambda x: x.price,
-            reverse=True,
-        )
-        bids = sorted(
-            [order for order in self.orders.values() if order.type == "bid"],
-            key=lambda x: x.price,
-            reverse=True,
-        )
-        sorted_orders = asks + bids
-        return "\n".join([str(order) for order in sorted_orders])
-
-    def process_event(self, event_type: str, data: dict):
-        """
-        Update the MarketState based on the eventType and
-        event data from the server.
-        """
-        if event_type == "add-order":
-            self._on_add_order(data["order"])
-
-        elif event_type == "update-order":
-            self._on_update_order(data["order"])
-
-        elif event_type == "delete-order":
-            self._on_delete_order(data["order"])
-
-        elif event_type == "contract-fulfilled":
-            self._on_contract_fulfilled(data)
-
-    def get_orders_from_player(self, player_id: int) -> list[Order]:
-        """Get all orders from a specific player."""
-        return [order for order in self.orders.values() if order.sender == player_id]
-
-    def _on_add_order(self, order_data: dict):
-        """
-        The server is telling us a new order has been added.
-        We'll store it in self.orders by ID.
-        """
-        order_id = order_data["id"]
-        new_order = Order(
-            id=order_id,
-            sender=order_data["sender"],
-            price=order_data["price"],
-            quantity=order_data["quantity"],
-            type=order_data["type"],
-            condition=order_data["condition"],
-            now=order_data.get("now", False),
-        )
-        self.orders[order_id] = new_order
-
-    def _on_update_order(self, order_data: dict):
-        """
-        The server is telling us the order's quantity or other fields
-        have changed (often due to partial fills).
-        """
-        order_id = order_data["id"]
-        if order_id in self.orders:
-            existing = self.orders[order_id]
-            existing.quantity = order_data.get("quantity", existing.quantity)
-            self.orders[order_id] = existing
-
-    def _on_delete_order(self, order_data: dict):
-        """
-        The server is telling us this order is removed
-        from the order book (fully filled or canceled).
-        """
-        order_id = order_data["id"]
-        if order_id in self.orders:
-            del self.orders[order_id]
-
-    def _on_contract_fulfilled(self, data: dict):
-        """
-        This indicates a trade has happened between 'from' and 'to'.
-        The server might also send update-order or delete-order events
-        to reflect the fill on the order book.
-        We track the trade in self.trades, but we typically rely
-        on update-order or delete-order to fix the order's quantity.
-        """
-        new_trade = Trade(
-            from_id=data["from"],
-            to_id=data["to"],
-            price=data["price"],
-            quantity=data.get("quantity", 1.0),
-            condition=data["condition"],
-            median=data.get("median"),
-        )
-        self.trades.append(new_trade)