diff --git a/oasis/social_agent/agent_action.py b/oasis/social_agent/agent_action.py index e9fcb1e6..3aa6f045 100644 --- a/oasis/social_agent/agent_action.py +++ b/oasis/social_agent/agent_action.py @@ -641,4 +641,4 @@ async def purchase_product(self, product_name: str, purchase_num: int): """ purchase_message = (product_name, purchase_num) return await self.perform_action(purchase_message, - ActionType.PURCHASE_PRODUCT.value) + ActionType.PURCHASE_PRODUCT.value) \ No newline at end of file diff --git a/oasis/social_agent/agents_generator.py b/oasis/social_agent/agents_generator.py index 51a591b1..353fc1ff 100644 --- a/oasis/social_agent/agents_generator.py +++ b/oasis/social_agent/agents_generator.py @@ -516,7 +516,7 @@ async def process_agent(i): { "reason": "He is my enemy, and I would like to mute him on social media.", "functions": [{ - "name": "mute", + "name": "mute", "arguments": { "user_id": 1 } diff --git a/oasis/transportation/examples/openManus.txt b/oasis/transportation/examples/openManus.txt new file mode 100644 index 00000000..e1f469a7 --- /dev/null +++ b/oasis/transportation/examples/openManus.txt @@ -0,0 +1,258 @@ + draw a framework for transportation multiagent, there are two roles: coordinator and passengers, the action space include Bounded Action +Affect Agent Volume +off_bus +whole 2025-03-09 07:41:58.776 | WARNING | __main__:main:18 - Processing your request... +2025-03-09 07:41:58.776 | INFO | app.agent.base:run:137 - Executing step 1/30 +bus +on_bus +whole bus agent +off_subway (voluntary) +get off subway voluntarily (etc: they have seen subway too crowded, they prefer other transportation) +off_subway (by adjuster) +get off subway by adjuster +on_subway +get onto subway according to their predetermined route +on_walk +Onto walk +find_route +find closest candidate route to destination, google api + + + +2025-03-09 07:42:04.523 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:42:04.524 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:42:04.524 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['python_execute'] +2025-03-09 07:42:04.524 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'python_execute'... +2025-03-09 07:42:04.525 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'python_execute' completed its mission! Result: Observed output of cmd `python_execute` executed: +{'observation': "No module named 'matplotlib'", 'success': False} +2025-03-09 07:42:04.525 | INFO | app.agent.base:run:137 - Executing step 2/30 +2025-03-09 07:42:11.896 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems that the Python environment does not have the `matplotlib` library installed, which is necessary for drawing the framework. Since I cannot install packages directly, I will provide you with the Python code that you can run in your local environment to visualize the transportation multiagent framework. + +Here's the code: + +```python +import matplotlib.pyplot as plt +import networkx as nx + +# Create a directed graph +G = nx.DiGraph() + +# Add nodes for coordinator and passengers +G.add_node('Coordinator', color='red') +G.add_nodes_from(['Passenger1', 'Passenger2', 'Passenger3'], color='blue') + +# Add edges to represent possible actions +G.add_edge('Coordinator', 'Passenger1', action='Assign Task') +G.add_edge('Coordinator', 'Passenger2', action='Assign Task') +G.add_edge('Coordinator', 'Passenger3', action='Assign Task') +G.add_edge('Passenger1', 'Coordinator', action='Request Service') +G.add_edge('Passenger2', 'Coordinator', action='Request Service') +G.add_edge('Passenger3', 'Coordinator', action='Request Service') + +# Define node colors +colors = [G.nodes[node]['color'] for node in G.nodes] + +# Draw the graph +pos = nx.spring_layout(G) +nx.draw(G, pos, with_labels=True, node_color=colors, node_size=2000, font_size=10, font_color='white') + +# Draw edge labels +edge_labels = nx.get_edge_attributes(G, 'action') +nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels) + +# Show plot +plt.title('Transportation Multiagent Framework') +plt.show() +``` + +### Instructions to Run the Code: +1. Ensure you have Python installed on your system. +2. Install the required libraries by running: + ``` + pip install matplotlib networkx + ``` +3. Copy the code above into a Python file (e.g., `multiagent_framework.py`). +4. Run the file using a Python interpreter: + ``` + python multiagent_framework.py + ``` + +This will display a graphical representation of the transportation multiagent framework with the roles and actions as described. If you need further assistance, feel free to ask! +2025-03-09 07:42:11.896 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:11.896 | INFO | app.agent.base:run:137 - Executing step 3/30 +2025-03-09 07:42:15.750 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: To address your request for drawing a framework for a transportation multiagent system with roles and actions, I attempted to use Python to generate a visual representation. However, due to the lack of necessary libraries in the current environment, I provided you with the code to run locally. + +Here's a step-by-step plan to achieve your goal using the tools available: + +1. **Python Code Preparation**: I have already provided you with the Python code to create the framework using `matplotlib` and `networkx`. + +2. **Local Execution**: You can run this code on your local machine to visualize the framework. This involves installing the required libraries and executing the script. + +3. **File Saving**: If you want to save the code or any other information, I can assist you in creating a file using the FileSaver tool. + +4. **Further Assistance**: If you need help with any specific part of the process, such as understanding the code or troubleshooting, feel free to ask. + +If you would like me to save the provided code to a file for easy access, please let me know! +2025-03-09 07:42:15.750 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:15.750 | INFO | app.agent.base:run:137 - Executing step 4/30 +2025-03-09 07:42:19.822 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like you're emphasizing the capabilities and tools available for interaction. Let's focus on the task at hand: creating a framework for a transportation multiagent system with roles and actions. + +Here's how we can proceed using the available tools: + +1. **Python Code Execution**: Since the environment lacks the necessary libraries to execute the code, I provided you with the code to run locally. This code will help you visualize the framework using `matplotlib` and `networkx`. + +2. **File Saving**: I can save the Python code to a file for you, making it easier to download and run on your local machine. + +3. **Web Search**: If you need additional information or resources about multiagent systems, I can perform a Google search to find relevant articles or documentation. + +4. **Browser Interaction**: If you have a specific website or online tool you want to explore, I can help navigate and interact with it. + +Would you like me to save the Python code to a file, or is there anything else specific you need help with? +2025-03-09 07:42:19.822 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:19.822 | INFO | app.agent.base:run:137 - Executing step 5/30 +2025-03-09 07:42:25.701 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:42:25.701 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:42:25.701 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['file_saver'] +2025-03-09 07:42:25.701 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'file_saver'... +2025-03-09 07:42:25.702 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'file_saver' completed its mission! Result: Observed output of cmd `file_saver` executed: +Content successfully saved to transportation_multiagent_framework.py +2025-03-09 07:42:25.702 | INFO | app.agent.base:run:137 - Executing step 6/30 +2025-03-09 07:42:29.499 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: I have saved the Python code for the transportation multiagent framework to a file named `transportation_multiagent_framework.py`. You can download this file and run it on your local machine to visualize the framework. + +### Next Steps: + +1. **Download the File**: Ensure you have access to the saved file. You can run it using a Python interpreter on your local machine. + +2. **Install Required Libraries**: Make sure you have `matplotlib` and `networkx` installed. You can install them using: + ``` + pip install matplotlib networkx + ``` + +3. **Run the Script**: Execute the script using Python to see the graphical representation of the framework. + +4. **Further Assistance**: If you need more information or have other tasks, feel free to ask. I can perform web searches, interact with web browsers, or execute additional Python code as needed. + +If there's anything else you'd like to do or explore, please let me know! +2025-03-09 07:42:29.499 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:29.500 | INFO | app.agent.base:run:137 - Executing step 7/30 +2025-03-09 07:42:31.621 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like you're reiterating the capabilities and tools available for interaction. If you have a specific task or question in mind, please let me know, and I'll be happy to assist you using the appropriate tools. Whether it's executing Python code, saving files, browsing the web, or searching for information, I'm here to help! +2025-03-09 07:42:31.622 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:31.622 | INFO | app.agent.base:run:137 - Executing step 8/30 +2025-03-09 07:42:33.930 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like there might be a misunderstanding or repetition in your message. If you have a specific task or question, please let me know, and I'll be glad to assist you using the available tools. Whether you need to execute code, save files, browse the web, or search for information, I'm here to help with any specific request you have. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:42:33.930 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:33.930 | INFO | app.agent.base:run:137 - Executing step 9/30 +2025-03-09 07:42:36.589 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like you're repeating the capabilities and tools available for interaction. If you have a specific task, question, or need assistance with something, please let me know. I'm here to help with any specific request you have, whether it's executing code, saving files, browsing the web, or searching for information. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:42:36.589 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:36.589 | INFO | app.agent.base:run:137 - Executing step 10/30 +2025-03-09 07:42:38.543 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like you're repeating the description of the tools available for interaction. If you have a specific task or question in mind, please let me know, and I'll be happy to assist you using the appropriate tools. Whether it's executing Python code, saving files, browsing the web, or searching for information, I'm here to help! Please provide more details or clarify your needs, and I'll proceed accordingly. +2025-03-09 07:42:38.544 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:38.544 | INFO | app.agent.base:run:137 - Executing step 11/30 +2025-03-09 07:42:40.475 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like there is a repetition in your message. If you have a specific task or question, please let me know, and I'll be glad to assist you using the available tools. Whether you need to execute code, save files, browse the web, or search for information, I'm here to help with any specific request you have. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:42:40.475 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:40.475 | INFO | app.agent.base:run:137 - Executing step 12/30 +2025-03-09 07:42:42.899 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like you're repeating the description of the tools available for interaction. If you have a specific task or question in mind, please let me know, and I'll be happy to assist you using the appropriate tools. Whether it's executing Python code, saving files, browsing the web, or searching for information, I'm here to help! Please provide more details or clarify your needs, and I'll proceed accordingly. +2025-03-09 07:42:42.899 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:42.899 | INFO | app.agent.base:run:137 - Executing step 13/30 +2025-03-09 07:42:44.845 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like there is a repeated message about the tools available for interaction. If you have a specific task, question, or need assistance with something, please let me know. I'm here to help with any specific request you have, whether it's executing code, saving files, browsing the web, or searching for information. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:42:44.845 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:44.845 | INFO | app.agent.base:run:137 - Executing step 14/30 +2025-03-09 07:42:46.662 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like you're repeating the description of the tools available for interaction. If you have a specific task or question in mind, please let me know, and I'll be happy to assist you using the appropriate tools. Whether it's executing Python code, saving files, browsing the web, or searching for information, I'm here to help! Please provide more details or clarify your needs, and I'll proceed accordingly. +2025-03-09 07:42:46.662 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:46.663 | WARNING | app.agent.base:handle_stuck_state:163 - Agent detected stuck state. Added prompt: Observed duplicate responses. Consider new strategies and avoid repeating ineffective paths already attempted. +2025-03-09 07:42:46.663 | INFO | app.agent.base:run:137 - Executing step 15/30 +2025-03-09 07:42:50.422 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: I apologize for the repeated responses. Let's try a different approach. If you have a specific task or question, please let me know, and I'll assist you using the appropriate tools. Here are some examples of what I can do: + +- **Execute Python Code**: If you have a specific script or function you need to run, I can execute it for you. +- **Save Files**: I can save any content you need into a file format of your choice. +- **Web Browsing**: If you need to interact with a website or gather information from the web, I can help with that. +- **Information Retrieval**: I can perform searches to find the information you need. + +Please provide more details about what you need, and I'll proceed with the most suitable tools and strategies. +2025-03-09 07:42:50.422 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:50.422 | INFO | app.agent.base:run:137 - Executing step 16/30 +2025-03-09 07:42:51.241 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:42:51.241 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:42:51.241 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['terminate'] +2025-03-09 07:42:51.241 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'terminate'... +2025-03-09 07:42:51.241 | INFO | app.agent.toolcall:_handle_special_tool:172 - šŸ Special tool 'terminate' has completed the task! +2025-03-09 07:42:51.241 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'terminate' completed its mission! Result: Observed output of cmd `terminate` executed: +The interaction has been completed with status: failure +2025-03-09 07:42:51.241 | WARNING | __main__:main:18 - Processing your request... +2025-03-09 07:42:51.241 | INFO | app.agent.base:run:137 - Executing step 17/30 +2025-03-09 07:42:53.388 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like there is a misunderstanding or repetition in the communication. If you have a specific task or question, please let me know, and I'll be glad to assist you using the available tools. Whether you need to execute code, save files, browse the web, or search for information, I'm here to help with any specific request you have. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:42:53.388 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:53.388 | INFO | app.agent.base:run:137 - Executing step 18/30 +2025-03-09 07:42:57.537 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like we're caught in a loop. Let's try to reset and focus on what you need. Please provide a specific task or question, and I'll assist you using the appropriate tools. Whether it's executing Python code, saving files, browsing the web, or searching for information, I'm here to help. Please let me know how I can assist you! +2025-03-09 07:42:57.538 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:42:57.538 | INFO | app.agent.base:run:137 - Executing step 19/30 +2025-03-09 07:43:05.361 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like we're experiencing a repeated cycle of responses. Let's break this pattern by focusing on a specific task or question you have. Please let me know what you need help with, and I'll use the appropriate tools to assist you effectively. Whether it's executing code, saving files, browsing the web, or searching for information, I'm here to help. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:43:05.361 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:43:05.361 | INFO | app.agent.base:run:137 - Executing step 20/30 +2025-03-09 07:43:06.615 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:43:06.615 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:43:06.615 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['terminate'] +2025-03-09 07:43:06.615 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'terminate'... +2025-03-09 07:43:06.616 | INFO | app.agent.toolcall:_handle_special_tool:172 - šŸ Special tool 'terminate' has completed the task! +2025-03-09 07:43:06.616 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'terminate' completed its mission! Result: Observed output of cmd `terminate` executed: +The interaction has been completed with status: failure +2025-03-09 07:43:06.616 | WARNING | __main__:main:18 - Processing your request... +2025-03-09 07:43:06.616 | INFO | app.agent.base:run:137 - Executing step 21/30 +2025-03-09 07:43:09.643 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like we're stuck in a loop of repeated messages. Let's try to address your needs more effectively. Please provide a specific task, question, or area where you need assistance, and I'll use the appropriate tools to help you. Whether it's executing code, saving files, browsing the web, or searching for information, I'm here to assist you. Please let me know how I can help! +2025-03-09 07:43:09.644 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:43:09.644 | INFO | app.agent.base:run:137 - Executing step 22/30 +2025-03-09 07:43:10.740 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:43:10.741 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:43:10.741 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['terminate'] +2025-03-09 07:43:10.741 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'terminate'... +2025-03-09 07:43:10.741 | INFO | app.agent.toolcall:_handle_special_tool:172 - šŸ Special tool 'terminate' has completed the task! +2025-03-09 07:43:10.741 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'terminate' completed its mission! Result: Observed output of cmd `terminate` executed: +The interaction has been completed with status: failure +2025-03-09 07:43:10.741 | WARNING | __main__:main:18 - Processing your request... +2025-03-09 07:43:10.741 | INFO | app.agent.base:run:137 - Executing step 23/30 +2025-03-09 07:43:12.694 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like we're experiencing a repeated cycle of responses. Let's break this pattern by focusing on a specific task or question you have. Please let me know what you need help with, and I'll use the appropriate tools to assist you effectively. Whether it's executing code, saving files, browsing the web, or searching for information, I'm here to help. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:43:12.695 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:43:12.695 | INFO | app.agent.base:run:137 - Executing step 24/30 +2025-03-09 07:43:13.701 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:43:13.701 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:43:13.701 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['terminate'] +2025-03-09 07:43:13.702 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'terminate'... +2025-03-09 07:43:13.702 | INFO | app.agent.toolcall:_handle_special_tool:172 - šŸ Special tool 'terminate' has completed the task! +2025-03-09 07:43:13.702 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'terminate' completed its mission! Result: Observed output of cmd `terminate` executed: +The interaction has been completed with status: failure +2025-03-09 07:43:13.702 | WARNING | __main__:main:18 - Processing your request... +2025-03-09 07:43:13.702 | INFO | app.agent.base:run:137 - Executing step 25/30 +2025-03-09 07:43:15.758 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like we're caught in a loop of repeated messages. Let's try to address your needs more effectively. Please provide a specific task, question, or area where you need assistance, and I'll use the appropriate tools to help you. Whether it's executing code, saving files, browsing the web, or searching for information, I'm here to assist you. Please let me know how I can help! +2025-03-09 07:43:15.758 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:43:15.758 | INFO | app.agent.base:run:137 - Executing step 26/30 +2025-03-09 07:43:16.768 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:43:16.768 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:43:16.768 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['terminate'] +2025-03-09 07:43:16.768 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'terminate'... +2025-03-09 07:43:16.768 | INFO | app.agent.toolcall:_handle_special_tool:172 - šŸ Special tool 'terminate' has completed the task! +2025-03-09 07:43:16.768 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'terminate' completed its mission! Result: Observed output of cmd `terminate` executed: +The interaction has been completed with status: failure +2025-03-09 07:43:16.768 | WARNING | __main__:main:18 - Processing your request... +2025-03-09 07:43:16.768 | INFO | app.agent.base:run:137 - Executing step 27/30 +2025-03-09 07:43:18.841 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like we're experiencing a repeated cycle of responses. Let's break this pattern by focusing on a specific task or question you have. Please let me know what you need help with, and I'll use the appropriate tools to assist you effectively. Whether it's executing code, saving files, browsing the web, or searching for information, I'm here to help. Please provide more details or clarify your needs, and I'll proceed accordingly! +2025-03-09 07:43:18.841 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:43:18.841 | WARNING | app.agent.base:handle_stuck_state:163 - Agent detected stuck state. Added prompt: Observed duplicate responses. Consider new strategies and avoid repeating ineffective paths already attempted. +2025-03-09 07:43:18.841 | INFO | app.agent.base:run:137 - Executing step 28/30 +2025-03-09 07:43:19.731 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:43:19.732 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:43:19.732 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['terminate'] +2025-03-09 07:43:19.732 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'terminate'... +2025-03-09 07:43:19.732 | INFO | app.agent.toolcall:_handle_special_tool:172 - šŸ Special tool 'terminate' has completed the task! +2025-03-09 07:43:19.732 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'terminate' completed its mission! Result: Observed output of cmd `terminate` executed: +The interaction has been completed with status: failure +2025-03-09 07:43:19.733 | WARNING | __main__:main:18 - Processing your request... +2025-03-09 07:43:19.733 | INFO | app.agent.base:run:137 - Executing step 29/30 +2025-03-09 07:43:22.179 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: It seems like we're caught in a loop of repeated messages. Let's try to address your needs more effectively. Please provide a specific task, question, or area where you need assistance, and I'll use the appropriate tools to help you. Whether it's executing code, saving files, browsing the web, or searching for information, I'm here to assist you. Please let me know how I can help! +2025-03-09 07:43:22.179 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 0 tools to use +2025-03-09 07:43:22.180 | INFO | app.agent.base:run:137 - Executing step 30/30 +2025-03-09 07:43:23.202 | INFO | app.agent.toolcall:think:53 - āœØ Manus's thoughts: None +2025-03-09 07:43:23.202 | INFO | app.agent.toolcall:think:54 - šŸ› ļø Manus selected 1 tools to use +2025-03-09 07:43:23.202 | INFO | app.agent.toolcall:think:58 - šŸ§° Tools being prepared: ['terminate'] +2025-03-09 07:43:23.202 | INFO | app.agent.toolcall:execute_tool:140 - šŸ”§ Activating tool: 'terminate'... +2025-03-09 07:43:23.202 | INFO | app.agent.toolcall:_handle_special_tool:172 - šŸ Special tool 'terminate' has completed the task! +2025-03-09 07:43:23.202 | INFO | app.agent.toolcall:act:113 - šŸŽÆ Tool 'terminate' completed its mission! Result: Observed output of cmd `terminate` executed: +The interaction has been completed with status: failure \ No newline at end of file diff --git a/oasis/transportation/examples/simple_simulation.py b/oasis/transportation/examples/simple_simulation.py new file mode 100644 index 00000000..06ba655f --- /dev/null +++ b/oasis/transportation/examples/simple_simulation.py @@ -0,0 +1,170 @@ +import os +import sys +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import random +import networkx as nx + +# Add the parent directory to the path so we can import the modules +sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) + +from oasis.transportation.network import TransportNetwork, TransportNode, TransportLink +from oasis.transportation.simulation import TransportSimulation +from oasis.transportation.io import read_network_from_csv, write_network_to_csv + +def create_sample_network(): + """Create a sample transport network for demonstration""" + network = TransportNetwork(name="Sample City Network") + + # Add nodes (stations) + nodes = [ + TransportNode("n1", 0, 0, "Downtown"), + TransportNode("n2", 10, 0, "East End"), + TransportNode("n3", 0, 10, "North Side"), + TransportNode("n4", 10, 10, "Northeast"), + TransportNode("n5", 5, 5, "Central"), + ] + + for node in nodes: + network.add_node(node) + + # Add links (routes) + links = [ + TransportLink("l1", "n1", "n2", 10000, 1800, 15, {"type": "main_road"}), + TransportLink("l2", "n2", "n1", 10000, 1800, 15, {"type": "main_road"}), + TransportLink("l3", "n1", "n3", 10000, 1200, 12, {"type": "secondary"}), + TransportLink("l4", "n3", "n1", 10000, 1200, 12, {"type": "secondary"}), + TransportLink("l5", "n2", "n4", 10000, 1200, 12, {"type": "secondary"}), + TransportLink("l6", "n4", "n2", 10000, 1200, 12, {"type": "secondary"}), + TransportLink("l7", "n3", "n4", 10000, 1500, 13, {"type": "main_road"}), + TransportLink("l8", "n4", "n3", 10000, 1500, 13, {"type": "main_road"}), + TransportLink("l9", "n1", "n5", 7000, 1000, 10, {"type": "local"}), + TransportLink("l10", "n5", "n1", 7000, 1000, 10, {"type": "local"}), + TransportLink("l11", "n2", "n5", 7000, 1000, 10, {"type": "local"}), + TransportLink("l12", "n5", "n2", 7000, 1000, 10, {"type": "local"}), + TransportLink("l13", "n3", "n5", 7000, 1000, 10, {"type": "local"}), + TransportLink("l14", "n5", "n3", 7000, 1000, 10, {"type": "local"}), + TransportLink("l15", "n4", "n5", 7000, 1000, 10, {"type": "local"}), + TransportLink("l16", "n5", "n4", 7000, 1000, 10, {"type": "local"}), + ] + + for link in links: + network.add_link(link) + + # Add weights for different time periods + time_periods = ["morning_peak", "midday", "evening_peak", "night"] + + # Set initial weights + for link_id, link in network.links.items(): + # Morning peak: heavy traffic from residential to downtown + if link.to_node == "n1" and link.from_node in ["n2", "n3", "n4"]: + network.add_weight_data(link_id, "morning_peak", 3.0) + elif link.from_node == "n1" and link.to_node in ["n2", "n3", "n4"]: + network.add_weight_data(link_id, "morning_peak", 1.0) + else: + network.add_weight_data(link_id, "morning_peak", 1.5) + + # Midday: balanced traffic + network.add_weight_data(link_id, "midday", 1.5) + + # Evening peak: heavy traffic from downtown to residential + if link.from_node == "n1" and link.to_node in ["n2", "n3", "n4"]: + network.add_weight_data(link_id, "evening_peak", 3.0) + elif link.to_node == "n1" and link.from_node in ["n2", "n3", "n4"]: + network.add_weight_data(link_id, "evening_peak", 1.0) + else: + network.add_weight_data(link_id, "evening_peak", 1.5) + + # Night: light traffic + network.add_weight_data(link_id, "night", 0.5) + + return network + +def weight_evolution_model(link_id, current_weight, time_step): + """ + Simple model for weight evolution over time + + This model: + 1. Adds a small random fluctuation + 2. Gradually increases weights for main roads + 3. Gradually decreases weights for local roads + """ + # Get link type from the first character of the link_id + link_type = int(link_id[1:]) + + # Random fluctuation + random_factor = random.uniform(0.95, 1.05) + + # Trend factor based on link type + if link_type <= 8: # Main roads + trend_factor = 1.01 # Slight increase + else: # Local roads + trend_factor = 0.99 # Slight decrease + + # Calculate new weight + new_weight = current_weight * random_factor * trend_factor + + # Ensure weight stays within reasonable bounds + new_weight = max(0.1, min(5.0, new_weight)) + + return new_weight + +def main(): + # Create output directory + os.makedirs("output", exist_ok=True) + + # Create sample network + network = create_sample_network() + + # Save network to CSV + write_network_to_csv(network, "output") + + # Visualize initial network for different time periods + for period in ["morning_peak", "midday", "evening_peak", "night"]: + plt = network.visualize(period) + plt.savefig(f"output/initial_network_{period}.png") + plt.close() + + # Create simulation + simulation = TransportSimulation(network) + + # Simulate 20 time steps + simulation.simulate_time_evolution( + num_steps=20, + weight_evolution_model=weight_evolution_model + ) + + # Visualize evolution for morning peak + plt = simulation.visualize_evolution( + time_steps=[0, 5, 10, 15, 20], + time_period="morning_peak", + figsize=(20, 10), + rows=1 + ) + plt.savefig("output/evolution_morning_peak.png") + plt.close() + + # Visualize evolution for evening peak + plt = simulation.visualize_evolution( + time_steps=[0, 5, 10, 15, 20], + time_period="evening_peak", + figsize=(20, 10), + rows=1 + ) + plt.savefig("output/evolution_evening_peak.png") + plt.close() + + # Plot weight evolution for selected links + plt = simulation.plot_weight_evolution( + link_ids=["l1", "l3", "l9", "l15"], + time_period="morning_peak" + ) + plt.savefig("output/weight_evolution_morning.png") + plt.close() + + print("Simulation completed successfully!") + print("Output files saved to the 'output' directory.") + +if __name__ == "__main__": + main() diff --git a/oasis/transportation/matsim/api.py b/oasis/transportation/matsim/api.py new file mode 100644 index 00000000..12a1c9d9 --- /dev/null +++ b/oasis/transportation/matsim/api.py @@ -0,0 +1,215 @@ +from fastapi import FastAPI, HTTPException, Query +from pydantic import BaseModel +from typing import List, Dict, Optional +import os +import json + +from .network import TransportNetwork, TransportNode, TransportLink +from .simulation import TransportSimulation +from .io import read_network_from_csv, write_network_to_csv + +app = FastAPI(title="Oasis Transportation API") + +# Store simulations in memory +simulations = {} + +class NodeModel(BaseModel): + node_id: str + x: float + y: float + name: Optional[str] = None + attributes: Optional[Dict] = None + +class LinkModel(BaseModel): + link_id: str + from_node: str + to_node: str + length: float + capacity: float + free_speed: float + attributes: Optional[Dict] = None + +class WeightModel(BaseModel): + link_id: str + time_period: str + weight: float + +class NetworkModel(BaseModel): + name: str + nodes: List[NodeModel] + links: List[LinkModel] + weights: Optional[List[WeightModel]] = None + +@app.get("/") +def read_root(): + return {"message": "Welcome to Oasis Transportation API"} + +@app.post("/networks/") +def create_network(network: NetworkModel): + """Create a new transport network""" + transport_network = TransportNetwork(name=network.name) + + # Add nodes + for node_data in network.nodes: + node = TransportNode( + node_id=node_data.node_id, + x=node_data.x, + y=node_data.y, + name=node_data.name or node_data.node_id, + attributes=node_data.attributes or {} + ) + transport_network.add_node(node) + + # Add links + for link_data in network.links: + link = TransportLink( + link_id=link_data.link_id, + from_node=link_data.from_node, + to_node=link_data.to_node, + length=link_data.length, + capacity=link_data.capacity, + free_speed=link_data.free_speed, + attributes=link_data.attributes or {} + ) + transport_network.add_link(link) + + # Add weights + if network.weights: + for weight_data in network.weights: + transport_network.add_weight_data( + link_id=weight_data.link_id, + time_period=weight_data.time_period, + weight=weight_data.weight + ) + + # Save network to CSV files + output_dir = f"output/{network.name}" + write_network_to_csv(transport_network, output_dir) + + return {"message": f"Network '{network.name}' created successfully", "output_dir": output_dir} + +@app.post("/simulations/") +def create_simulation(network_name: str, num_steps: int = 10, seed: int = 42): + """Create a new simulation based on a network""" + # Check if network exists + input_dir = f"output/{network_name}" + if not os.path.exists(input_dir): + raise HTTPException(status_code=404, detail=f"Network '{network_name}' not found") + + # Load network from CSV files + nodes_file = os.path.join(input_dir, "nodes.csv") + links_file = os.path.join(input_dir, "links.csv") + weights_file = os.path.join(input_dir, "weights.csv") + + if not os.path.exists(weights_file): + weights_file = None + + network = read_network_from_csv(nodes_file, links_file, weights_file) + + # Create simulation + simulation_id = f"{network_name}_{seed}" + simulation = TransportSimulation(network, seed=seed) + + # Store simulation + simulations[simulation_id] = simulation + + return {"message": f"Simulation '{simulation_id}' created successfully", "simulation_id": simulation_id} + +@app.post("/simulations/{simulation_id}/run") +def run_simulation(simulation_id: str, num_steps: int = 10): + """Run a simulation for a specified number of steps""" + if simulation_id not in simulations: + raise HTTPException(status_code=404, detail=f"Simulation '{simulation_id}' not found") + + simulation = simulations[simulation_id] + + # Define a simple weight evolution model + def weight_evolution_model(link_id, current_weight, time_step): + # Simple model: random fluctuation around current weight + import random + random.seed(int(link_id[1:]) + time_step) + fluctuation = random.uniform(0.95, 1.05) + return current_weight * fluctuation + + # Run simulation + simulation.simulate_time_evolution( + num_steps=num_steps, + weight_evolution_model=weight_evolution_model + ) + + # Save output visualization + output_dir = f"output/simulations/{simulation_id}" + os.makedirs(output_dir, exist_ok=True) + + # Visualize final state for each time period + time_periods = list(simulation.base_network.time_periods) + for period in time_periods: + plt = simulation.get_network_at_time(num_steps).visualize(period) + plt.savefig(f"{output_dir}/final_state_{period}.png") + plt.close() + + # Visualize evolution for first time period + if time_periods: + plt = simulation.visualize_evolution( + time_steps=list(range(0, num_steps+1, max(1, num_steps//5))), + time_period=time_periods[0] + ) + plt.savefig(f"{output_dir}/evolution_{time_periods[0]}.png") + plt.close() + + return { + "message": f"Simulation '{simulation_id}' completed successfully", + "num_steps": num_steps, + "output_dir": output_dir, + "time_periods": time_periods + } + +@app.get("/simulations/{simulation_id}/network/{time_step}") +def get_network_at_time(simulation_id: str, time_step: int): + """Get the network state at a specific time step""" + if simulation_id not in simulations: + raise HTTPException(status_code=404, detail=f"Simulation '{simulation_id}' not found") + + simulation = simulations[simulation_id] + + try: + network = simulation.get_network_at_time(time_step) + except ValueError as e: + raise HTTPException(status_code=404, detail=str(e)) + + # Convert network to JSON-serializable format + result = { + "name": network.name, + "nodes": [], + "links": [], + "weights": [] + } + + for node_id, node in network.nodes.items(): + result["nodes"].append({ + "node_id": node.node_id, + "x": node.x, + "y": node.y, + "name": node.name, + "attributes": node.attributes + }) + + for link_id, link in network.links.items(): + result["links"].append({ + "link_id": link.link_id, + "from_node": link.from_node, + "to_node": link.to_node, + "length": link.length, + "capacity": link.capacity, + "free_speed": link.free_speed, + "attributes": link.attributes + }) + + for time_period, weight in link.weights_history.items(): + result["weights"].append({ + "link_id": link.link_id, + "time_period": time_period, + "weight": weight + }) + + return result \ No newline at end of file diff --git a/oasis/transportation/matsim/example_config.xml b/oasis/transportation/matsim/example_config.xml new file mode 100644 index 00000000..a326054c --- /dev/null +++ b/oasis/transportation/matsim/example_config.xml @@ -0,0 +1,81 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/oasis/transportation/matsim/example_network.xml b/oasis/transportation/matsim/example_network.xml new file mode 100644 index 00000000..35961d20 --- /dev/null +++ b/oasis/transportation/matsim/example_network.xml @@ -0,0 +1,48 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/oasis/transportation/matsim/example_plans.xml b/oasis/transportation/matsim/example_plans.xml new file mode 100644 index 00000000..b3eb6c53 --- /dev/null +++ b/oasis/transportation/matsim/example_plans.xml @@ -0,0 +1,157 @@ + + + + + + + + + 1_4 4_5 5_6 6_9 + + + + 9_6 6_5 5_4 4_1 + + + + + + + + + + + 7_4 4_5 5_6 6_3 + + + + 3_2 2_5 5_8 8_7 + + + + + + + + + + + 3_6 6_5 5_4 4_7 + + + + 7_8 8_5 5_2 2_3 + + + + + + + + + + + 1_2 2_3 + + + + 3_2 2_1 + + + + + + + + + + + 9_8 8_7 7_4 4_1 + + + + 1_4 4_7 7_8 8_9 + + + + + + + + + + + 5_6 6_9 9_8 + + + + 8_5 + + + + 5_4 4_1 1_2 2_5 + + + + + + + + + + + 2_5 5_8 + + + + 8_5 5_2 + + + + + + + + + + + 8_5 5_2 + + + + 2_5 5_8 + + + + + + + + + + + 4_5 5_6 + + + + 6_5 5_4 + + + + + + + + + + + 6_5 5_4 + + + + 4_5 5_6 + + + + + diff --git a/oasis/transportation/matsim/io.py b/oasis/transportation/matsim/io.py new file mode 100644 index 00000000..d3c1ae9a --- /dev/null +++ b/oasis/transportation/matsim/io.py @@ -0,0 +1,237 @@ +import pandas as pd +import numpy as np +import xml.etree.ElementTree as ET +from typing import Dict, List, Tuple, Optional +import json +import os +from .network import TransportNetwork, TransportNode, TransportLink + +def read_network_from_csv(nodes_file: str, links_file: str, weights_file: Optional[str] = None) -> TransportNetwork: + """ + Read a transport network from CSV files + + Args: + nodes_file: Path to CSV file with node data + links_file: Path to CSV file with link data + weights_file: Optional path to CSV file with weight data + + Returns: + TransportNetwork object + """ + # Read nodes + nodes_df = pd.read_csv(nodes_file) + + # Read links + links_df = pd.read_csv(links_file) + + # Create network + network = TransportNetwork() + + # Add nodes + for _, row in nodes_df.iterrows(): + node = TransportNode( + node_id=str(row['node_id']), + x=float(row['x']), + y=float(row['y']), + name=str(row.get('name', row['node_id'])), + attributes={k: row[k] for k in row.index if k not in ['node_id', 'x', 'y', 'name']} + ) + network.add_node(node) + + # Add links + for _, row in links_df.iterrows(): + link = TransportLink( + link_id=str(row['link_id']), + from_node=str(row['from_node']), + to_node=str(row['to_node']), + length=float(row['length']), + capacity=float(row['capacity']), + free_speed=float(row['free_speed']), + attributes={k: row[k] for k in row.index if k not in ['link_id', 'from_node', 'to_node', 'length', 'capacity', 'free_speed']} + ) + network.add_link(link) + + # Add weights if provided + if weights_file and os.path.exists(weights_file): + weights_df = pd.read_csv(weights_file) + for _, row in weights_df.iterrows(): + network.add_weight_data( + link_id=str(row['link_id']), + time_period=str(row['time_period']), + weight=float(row['weight']) + ) + + return network + +def write_network_to_csv(network: TransportNetwork, output_dir: str): + """ + Write a transport network to CSV files + + Args: + network: TransportNetwork object + output_dir: Directory to write CSV files to + """ + os.makedirs(output_dir, exist_ok=True) + + # Write nodes + nodes_data = [] + for node_id, node in network.nodes.items(): + node_data = { + 'node_id': node.node_id, + 'x': node.x, + 'y': node.y, + 'name': node.name + } + node_data.update(node.attributes) + nodes_data.append(node_data) + + nodes_df = pd.DataFrame(nodes_data) + nodes_df.to_csv(os.path.join(output_dir, 'nodes.csv'), index=False) + + # Write links + links_data = [] + for link_id, link in network.links.items(): + link_data = { + 'link_id': link.link_id, + 'from_node': link.from_node, + 'to_node': link.to_node, + 'length': link.length, + 'capacity': link.capacity, + 'free_speed': link.free_speed + } + link_data.update(link.attributes) + links_data.append(link_data) + + links_df = pd.DataFrame(links_data) + links_df.to_csv(os.path.join(output_dir, 'links.csv'), index=False) + + # Write weights + weights_data = [] + for link_id, link in network.links.items(): + for time_period, weight in link.weights_history.items(): + weights_data.append({ + 'link_id': link_id, + 'time_period': time_period, + 'weight': weight + }) + + weights_df = pd.DataFrame(weights_data) + if not weights_df.empty: + weights_df.to_csv(os.path.join(output_dir, 'weights.csv'), index=False) + +def read_network_from_matsim(network_file: str, weights_file: Optional[str] = None) -> TransportNetwork: + """ + Read a transport network from MATSim XML format + + Args: + network_file: Path to MATSim network XML file + weights_file: Optional path to CSV file with weight data + + Returns: + TransportNetwork object + """ + tree = ET.parse(network_file) + root = tree.getroot() + + network = TransportNetwork() + + # Read nodes + for node_elem in root.findall(".//node"): + node_id = node_elem.get('id') + x = float(node_elem.get('x')) + y = float(node_elem.get('y')) + + attributes = {} + for attr in node_elem.findall("./attribute"): + attributes[attr.get('name')] = attr.text + + node = TransportNode( + node_id=node_id, + x=x, + y=y, + name=attributes.get('name', node_id), + attributes=attributes + ) + network.add_node(node) + + # Read links + for link_elem in root.findall(".//link"): + link_id = link_elem.get('id') + from_node = link_elem.get('from') + to_node = link_elem.get('to') + length = float(link_elem.get('length')) + capacity = float(link_elem.get('capacity')) + free_speed = float(link_elem.get('freespeed')) + + attributes = {} + for attr in link_elem.findall("./attribute"): + attributes[attr.get('name')] = attr.text + + link = TransportLink( + link_id=link_id, + from_node=from_node, + to_node=to_node, + length=length, + capacity=capacity, + free_speed=free_speed, + attributes=attributes + ) + network.add_link(link) + + # Add weights if provided + if weights_file and os.path.exists(weights_file): + weights_df = pd.read_csv(weights_file) + for _, row in weights_df.iterrows(): + network.add_weight_data( + link_id=str(row['link_id']), + time_period=str(row['time_period']), + weight=float(row['weight']) + ) + + return network + +def write_network_to_matsim(network: TransportNetwork, output_file: str): + """ + Write a transport network to MATSim XML format + + Args: + network: TransportNetwork object + output_file: Path to output XML file + """ + root = ET.Element("network") + nodes = ET.SubElement(root, "nodes") + + # Write nodes + for node_id, node in network.nodes.items(): + node_elem = ET.SubElement(nodes, "node") + node_elem.set("id", node.node_id) + node_elem.set("x", str(node.x)) + node_elem.set("y", str(node.y)) + + # Add attributes + for key, value in node.attributes.items(): + attr = ET.SubElement(node_elem, "attribute") + attr.set("name", key) + attr.text = str(value) + + links = ET.SubElement(root, "links") + + # Write links + for link_id, link in network.links.items(): + link_elem = ET.SubElement(links, "link") + link_elem.set("id", link.link_id) + link_elem.set("from", link.from_node) + link_elem.set("to", link.to_node) + link_elem.set("length", str(link.length)) + link_elem.set("capacity", str(link.capacity)) + link_elem.set("freespeed", str(link.free_speed)) + + # Add attributes + for key, value in link.attributes.items(): + attr = ET.SubElement(link_elem, "attribute") + attr.set("name", key) + attr.text = str(value) + + # Create XML tree and write to file + tree = ET.ElementTree(root) + tree.write(output_file, encoding="utf-8", xml_declaration=True) \ No newline at end of file diff --git a/oasis/transportation/matsim/matsim.py b/oasis/transportation/matsim/matsim.py new file mode 100644 index 00000000..53c3efdf --- /dev/null +++ b/oasis/transportation/matsim/matsim.py @@ -0,0 +1,581 @@ +import matsim +import subprocess +import os +import random +import numpy as np +import json +import requests +from typing import List, Dict, Any +import xml.dom.minidom as minidom +import xml.etree.ElementTree as ET + +# Add function to the matsim module +def write_population(population, output_file): + """Write a MATSim population to an XML file + + Args: + population: MATSim population object + output_file: Path to output XML file + """ + # Create the root element + root = ET.Element("population") + + # Add DOCTYPE + root.append(ET.Comment('DOCTYPE population SYSTEM "http://www.matsim.org/files/dtd/population_v6.dtd"')) + + # Add each person + for person_id, person in population.persons.items(): + person_elem = ET.SubElement(root, "person", id=str(person_id)) + + # Add plans + for i, plan in enumerate(person.plans): + selected = "yes" if i == person.selected_plan_index else "no" + plan_elem = ET.SubElement(person_elem, "plan", selected=selected) + + # Add activities and legs alternating + elements = [] + + # Add activities + for i, activity in enumerate(plan.activities): + # Get basic attributes, accommodating different possible property names + act_attrs = {"type": activity.type} + + # Handle link attribute - could be .link or .link_id + if hasattr(activity, "link"): + act_attrs["link"] = activity.link + elif hasattr(activity, "link_id"): + act_attrs["link"] = activity.link_id + + # Handle coordinates + if hasattr(activity, "x") and hasattr(activity, "y"): + act_attrs["x"] = str(activity.x) + act_attrs["y"] = str(activity.y) + + # Handle end time + if hasattr(activity, "end_time") and activity.end_time is not None: + act_attrs["end_time"] = format_time(activity.end_time) + + act_elem = ET.SubElement(plan_elem, "activity", act_attrs) + + # Add leg after each activity except the last one + if i < len(plan.activities) - 1 and i < len(plan.legs): + leg = plan.legs[i] + # Get mode - could be .mode or .transport_mode + leg_mode = leg.mode if hasattr(leg, "mode") else getattr(leg, "transport_mode", "car") + leg_elem = ET.SubElement(plan_elem, "leg", mode=leg_mode) + + # Add route if available + if hasattr(leg, "route") and leg.route is not None: + route = leg.route + route_type = getattr(route, "type", "links") + + # Handle different ways route links might be stored + link_ids = None + if hasattr(route, "link_ids"): + link_ids = route.link_ids + elif hasattr(route, "links"): + link_ids = route.links + + if link_ids is not None: + route_elem = ET.SubElement(leg_elem, "route", type=route_type) + # Handle if links is a string or a list + if isinstance(link_ids, str): + route_elem.text = link_ids + else: + route_elem.text = " ".join(link_ids) + + # Write to file with pretty formatting + tree = ET.ElementTree(root) + xml_str = ET.tostring(root, encoding='utf-8') + + # Pretty print XML + dom = minidom.parseString(xml_str) + pretty_xml = dom.toprettyxml(indent=" ") + + # Remove extra blank lines and write to file + with open(output_file, "w", encoding="utf-8") as f: + f.write('\n') + f.write('\n') + for line in pretty_xml.split("\n")[1:]: # Skip the XML declaration line + if line.strip(): # Skip empty lines + f.write(line + "\n") + +def format_time(seconds_or_time_str): + """Format time as HH:MM:SS + + Args: + seconds_or_time_str: Either seconds (int/float) or time string + + Returns: + Formatted time string + """ + if isinstance(seconds_or_time_str, (int, float)): + # Convert seconds to HH:MM:SS + hours, remainder = divmod(seconds_or_time_str, 3600) + minutes, seconds = divmod(remainder, 60) + return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}" + else: + # Already a string, return as is + return seconds_or_time_str + +class MATSimEnvironment: + """Environment for MATSim simulation with agent feedback""" + + def __init__(self, network_file: str, plans_file: str, config_file: str, output_dir: str): + """Initialize the MATSim environment + + Args: + network_file: Path to the network XML file + plans_file: Path to the plans XML file + config_file: Path to the config XML file + output_dir: Directory to store output files + """ + self.network_file = network_file + self.plans_file = plans_file + self.config_file = config_file + self.output_dir = output_dir + self.iteration = 0 + self.network = None + self.population = None + + # Load network and population + self.load_files() + + def load_files(self): + """Load network and population files""" + self.network = matsim.read_network(self.network_file) + print(f"Loaded network with {len(self.network.nodes)} nodes and {len(self.network.links)} links") + + def run_iteration(self, matsim_jar_path: str) -> Dict[str, Any]: + """Run a single MATSim iteration + + Args: + matsim_jar_path: Path to the MATSim JAR file + + Returns: + Dictionary containing network state information + """ + # Create iteration-specific plans file + iter_plans_file = os.path.join(self.output_dir, f"plans_iter_{self.iteration}.xml") + + # Create iteration-specific output directory + iter_output_dir = os.path.join(self.output_dir, f"iteration_{self.iteration}") + os.makedirs(iter_output_dir, exist_ok=True) + + # Create a copy of the config file specifically for this iteration + iter_config_file = os.path.join(iter_output_dir, f"config_iter_{self.iteration}.xml") + + # In a real implementation, modify the config to: + # 1. Point to the current plans file + # 2. Set the output directory to the iteration output dir + # 3. Configure event handlers for link statistics + with open(self.config_file, 'r') as f: + config_content = f.read() + + # Simple string replacement as a placeholder for proper XML modification + # In a real implementation, use proper XML parsing + config_content = config_content.replace("", + f"{iter_plans_file}") + config_content = config_content.replace("", + f"{iter_output_dir}") + + with open(iter_config_file, 'w') as f: + f.write(config_content) + + # Run MATSim (one iteration) + cmd = [ + "java", "-Xmx4g", + "-cp", matsim_jar_path, + "org.matsim.run.Controler", + iter_config_file, + "--config:controler.lastIteration", "0" # Run only one iteration + ] + + print(f"Running MATSim iteration {self.iteration}...") + print(f" - Config file: {iter_config_file}") + print(f" - Plans file: {iter_plans_file}") + print(f" - Output directory: {iter_output_dir}") + + process = subprocess.run(cmd, capture_output=True, text=True) + + if process.returncode != 0: + print(f"MATSim execution failed: {process.stderr}") + return {} + + # Extract network state from MATSim output + events_file = os.path.join(iter_output_dir, "output_events.xml.gz") + network_state = self._parse_network_state(events_file) + + self.iteration += 1 + return network_state + + def _parse_network_state(self, events_file: str = None) -> Dict[str, Any]: + """Parse MATSim output to extract network state + + Args: + events_file: Path to MATSim events file (optional) + + Returns: + Dictionary with link IDs as keys and travel stats as values + """ + # Check if events file exists and is readable + if events_file and os.path.exists(events_file): + try: + print(f"Parsing events file: {events_file}") + # In a real implementation, use matsim.event_reader + # For example: + # events = matsim.event_reader(events_file) + # Then process events to extract link travel times + + # For now, we'll continue with simulated data + print("Using matsim-tools to parse events (placeholder)") + except Exception as e: + print(f"Error parsing events file: {e}") + print("Falling back to simulated data") + else: + print("Events file not found, using simulated data") + + # Simulating link statistics - replace with actual parsing in real implementation + link_stats = {} + for link_id in self.network.links: + link = self.network.links[link_id] + + # Basic link properties + from_node_id = link.from_node + to_node_id = link.to_node + + # Get coordinates for visualization (if needed) + from_node = self.network.nodes[from_node_id] + to_node = self.network.nodes[to_node_id] + + # Simulate travel times based on link properties + free_flow_time = link.length / link.freespeed * 60 # minutes + + # Capacity factors - higher capacity means less congestion + base_capacity_factor = 2000 / (link.capacity + 500) + + # Simulate different levels of congestion based on link properties and random factors + time_of_day_factor = random.choice([0.7, 1.0, 1.5, 2.0]) # simulate peak hours + congestion_factor = random.uniform(1.0, 2.0) * base_capacity_factor * time_of_day_factor + + # Calculate travel time including congestion + travel_time = free_flow_time * congestion_factor + + # Store all link information + link_stats[link_id] = { + 'travel_time': travel_time, # minutes + 'volume': random.randint(0, int(link.capacity * 0.8)), # vehicles + 'congestion': min(1.0, (congestion_factor - 1) / 2), # congestion index (0-1) + 'length': link.length, # meters + 'capacity': link.capacity, # vehicles per hour + 'freespeed': link.freespeed * 3.6, # km/h + 'from_node': from_node_id, + 'to_node': to_node_id, + 'from_coord': (from_node.x, from_node.y), + 'to_coord': (to_node.x, to_node.y), + 'lanes': getattr(link, 'lanes', 1), + 'time_of_day_factor': time_of_day_factor # additional info for analysis + } + + return link_stats + +# this llm agent is just for testing, later, we will get to +class LLMAgent: + """Agent that uses GPT-4 to make decisions about plan updates""" + + def __init__(self, person_id: str, environment: MATSimEnvironment, openai_api_key: str): + """Initialize agent + + Args: + person_id: ID of the person in the MATSim population + environment: MATSimEnvironment instance + openai_api_key: API key for OpenAI + """ + self.person_id = person_id + self.environment = environment + self.person = environment.population.persons[person_id] + self.api_key = openai_api_key + self.api_url = "https://api.openai.com/v1/chat/completions" + self.headers = { + "Content-Type": "application/json", + "Authorization": f"Bearer {self.api_key}" + } + + def update_plan(self, network_state: Dict[str, Any]): + """Update the agent's plan based on network state using GPT-4 + + Args: + network_state: Dictionary with network state information + """ + if not self.person.plans: + print(f"Warning: Person {self.person_id} has no plans") + return + + # Get the selected plan + selected_plan = self.person.selected_plan + + # Extract current plan data + plan_data = self._extract_plan_data(selected_plan) + + # Get relevant network data for the routes used by this agent + network_data = self._extract_relevant_network_data(network_state, selected_plan) + + # Generate prompt for GPT-4 + prompt = self._generate_prompt(plan_data, network_data) + + # Get GPT-4 response + gpt_response = self._query_gpt4(prompt) + + # Parse and apply the updated plan + self._apply_gpt_suggestions(gpt_response, selected_plan) + + print(f"Agent {self.person_id} has updated their plan using GPT-4") + + def _extract_plan_data(self, plan): + """Extract relevant data from a plan for the LLM + + Args: + plan: MATSim plan + + Returns: + Dictionary with plan data + """ + activities = [] + legs = [] + + for activity in plan.activities: + act_data = { + "type": activity.type, + "location": { + "x": activity.x, + "y": activity.y, + "link": activity.link + }, + "start_time": activity.start_time if hasattr(activity, 'start_time') else None, + "end_time": activity.end_time if hasattr(activity, 'end_time') else None, + } + activities.append(act_data) + + for leg in plan.legs: + route_links = leg.route.link_ids if hasattr(leg, 'route') else [] + leg_data = { + "mode": leg.mode, + "dep_time": leg.dep_time if hasattr(leg, 'dep_time') else None, + "trav_time": leg.trav_time if hasattr(leg, 'trav_time') else None, + "route_links": route_links + } + legs.append(leg_data) + + return { + "activities": activities, + "legs": legs + } + + def _extract_relevant_network_data(self, network_state, plan): + """Extract network data relevant to this agent's routes + + Args: + network_state: Full network state + plan: MATSim plan + + Returns: + Dictionary with relevant network data + """ + relevant_links = set() + + # Collect all links used in the plan + for leg in plan.legs: + if hasattr(leg, 'route') and hasattr(leg.route, 'link_ids'): + for link_id in leg.route.link_ids: + relevant_links.add(link_id) + + # Get data for these links + relevant_data = {link_id: network_state[link_id] for link_id in relevant_links + if link_id in network_state} + + return relevant_data + + def _generate_prompt(self, plan_data, network_data): + """Generate a prompt for GPT-4 + + Args: + plan_data: Agent's current plan + network_data: Relevant network state + + Returns: + Prompt string + """ + prompt = f"""You are a transportation planning AI assistant for agent {self.person_id}. + +Your task is to analyze the current transportation network conditions and suggest modifications to the agent's daily schedule to minimize travel time and avoid congestion. + +CURRENT PLAN: +{json.dumps(plan_data, indent=2)} + +NETWORK CONDITIONS: +{json.dumps(network_data, indent=2)} + +Based on the network conditions: +1. Identify congested links in the agent's route (congestion > 0.5) +2. Suggest adjustments to departure times (earlier or later) to avoid peak congestion +3. Optionally suggest alternative routes if you can see better options using the given network + +Please provide your recommendations in the following JSON format: +```json +{ + "activity_adjustments": [ + {"activity_index": 0, "new_end_time": "HH:MM:SS"}, + ... + ], + "routing_suggestions": [ + {"leg_index": 0, "suggested_links": ["link_id1", "link_id2", ...]} + ... + ], + "explanation": "Your explanation of the changes" +} +``` + +Only include activities or legs that need changes. Be sure the JSON is properly formatted. +""" + return prompt + + def _query_gpt4(self, prompt): + """Query GPT-4 API with the prompt + + Args: + prompt: Prompt string + + Returns: + Response from GPT-4 + """ + try: + payload = { + "model": "gpt-4", + "messages": [ + {"role": "system", "content": "You are a transportation planning assistant that helps optimize travel plans."}, + {"role": "user", "content": prompt} + ], + "temperature": 0.7, + "max_tokens": 1000 + } + + response = requests.post(self.api_url, headers=self.headers, json=payload) + response.raise_for_status() + + response_data = response.json() + return response_data["choices"][0]["message"]["content"] + + except Exception as e: + print(f"Error querying GPT-4: {e}") + # Return a default empty response if API call fails + return """```json + { + "activity_adjustments": [], + "routing_suggestions": [], + "explanation": "Failed to generate recommendations due to API error." + } + ```""" + + def _apply_gpt_suggestions(self, gpt_response, plan): + """Parse GPT-4 response and apply changes to the plan + + Args: + gpt_response: String response from GPT-4 + plan: MATSim plan to modify + """ + try: + # Extract JSON from the response + json_start = gpt_response.find("```json") + 7 if "```json" in gpt_response else gpt_response.find("{") + json_end = gpt_response.find("```", json_start) if "```" in gpt_response[json_start:] else len(gpt_response) + json_str = gpt_response[json_start:json_end].strip() + + # Parse the JSON + recommendations = json.loads(json_str) + + # Apply activity time adjustments + for adjustment in recommendations.get("activity_adjustments", []): + activity_index = adjustment["activity_index"] + new_end_time = adjustment["new_end_time"] + + if 0 <= activity_index < len(plan.activities): + plan.activities[activity_index].end_time = new_end_time + print(f" Adjusted activity {activity_index} end time to {new_end_time}") + + # Apply route suggestions (in a real implementation) + # This is more complex because you'd need to create new Route objects + for suggestion in recommendations.get("routing_suggestions", []): + leg_index = suggestion["leg_index"] + suggested_links = suggestion["suggested_links"] + + if 0 <= leg_index < len(plan.legs): + # In a real implementation, you'd need to create a proper Route object + if hasattr(plan.legs[leg_index], 'route'): + plan.legs[leg_index].route.link_ids = suggested_links + print(f" Updated route for leg {leg_index}") + + print(f" Explanation: {recommendations.get('explanation', 'No explanation provided')}") + + except Exception as e: + print(f"Error applying GPT suggestions: {e}") + + +def run_simulation(network_file: str, plans_file: str, config_file: str, + output_dir: str, matsim_jar_path: str, openai_api_key: str, num_iterations: int): + """Run the simulation for multiple iterations + + Args: + network_file: Path to network XML file + plans_file: Path to plans XML file + config_file: Path to config XML file + output_dir: Directory to store output files + matsim_jar_path: Path to MATSim JAR file + openai_api_key: OpenAI API key for GPT-4 + num_iterations: Number of iterations to run + """ + # Initialize environment + env = MATSimEnvironment(network_file, plans_file, config_file, output_dir) + + # Create LLM agents (one per person in population) + agents = [] + for person_id in env.population.persons: + agents.append(LLMAgent(person_id, env, openai_api_key)) + + print(f"Created {len(agents)} LLM agents") + + # Run simulation iterations + for i in range(num_iterations): + print(f"\nIteration {i+1}/{num_iterations}") + + # Run MATSim and get network state + network_state = env.run_iteration(matsim_jar_path) + + # Update agent plans based on network state using GPT-4 + for agent in agents: + agent.update_plan(network_state) + + # Write updated plans file for the next iteration + write_population(env.population, + os.path.join(output_dir, f"updated_plans_{i}.xml")) + + print(f"Simulation completed after {num_iterations} iterations") + + +if __name__ == "__main__": + # Example usage (replace with actual file paths) + network_file = "example_network.xml" + plans_file = "example_plans.xml" + config_file = "example_config.xml" + output_dir = "output" + + # Update this path to point to your downloaded MATSim JAR file + matsim_jar_path = "path/to/matsim-13.0.jar" # Replace with actual path + + # Replace with your actual OpenAI API key (or leave empty if not using LLM agents) + openai_api_key = "" # Optional if not using LLM features + + # Create output directory if it doesn't exist + os.makedirs(output_dir, exist_ok=True) + + # Run simulation for 5 iterations + run_simulation(network_file, plans_file, config_file, + output_dir, matsim_jar_path, openai_api_key, num_iterations=5) \ No newline at end of file diff --git a/oasis/transportation/matsim/network.py b/oasis/transportation/matsim/network.py new file mode 100644 index 00000000..25d82205 --- /dev/null +++ b/oasis/transportation/matsim/network.py @@ -0,0 +1,184 @@ +import numpy as np +import pandas as pd +from typing import Dict, List, Tuple, Optional +import matplotlib.pyplot as plt +import networkx as nx + +class TransportNode: + """Represents a station or node in the transportation network""" + + def __init__(self, node_id: str, x: float, y: float, name: Optional[str] = None, attributes: Dict = None): + """ + Initialize a transport node + + Args: + node_id: Unique identifier for the node + x: x-coordinate of the node + y: y-coordinate of the node + name: Human-readable name of the node (station name) + attributes: Additional attributes for the node + """ + self.node_id = node_id + self.x = x + self.y = y + self.name = name if name else node_id + self.attributes = attributes if attributes else {} + + def __repr__(self): + return f"TransportNode(id={self.node_id}, name={self.name}, pos=({self.x}, {self.y}))" + + +class TransportLink: + """Represents a route or link between nodes in the transportation network""" + + def __init__(self, link_id: str, from_node: str, to_node: str, + length: float, capacity: float, free_speed: float, + attributes: Dict = None): + """ + Initialize a transport link + + Args: + link_id: Unique identifier for the link + from_node: ID of the origin node + to_node: ID of the destination node + length: Length of the link in meters + capacity: Capacity of the link (vehicles/hour) + free_speed: Free flow speed on the link (m/s) + attributes: Additional attributes for the link + """ + self.link_id = link_id + self.from_node = from_node + self.to_node = to_node + self.length = length + self.capacity = capacity + self.free_speed = free_speed + self.attributes = attributes if attributes else {} + + # Historical weights by time period + self.weights_history = {} + + def add_weight_data(self, time_period: str, weight: float): + """Add historical weight data for a specific time period""" + self.weights_history[time_period] = weight + + def get_weight(self, time_period: str) -> float: + """Get weight for a specific time period""" + return self.weights_history.get(time_period, 1.0) + + def __repr__(self): + return f"TransportLink(id={self.link_id}, {self.from_node}->{self.to_node}, len={self.length}m)" + + +class TransportNetwork: + """Represents a complete transportation network with nodes and links""" + + def __init__(self, name: str = "Transport Network"): + """ + Initialize an empty transport network + + Args: + name: Name of the network + """ + self.name = name + self.nodes = {} # node_id -> TransportNode + self.links = {} # link_id -> TransportLink + self.time_periods = set() + + def add_node(self, node: TransportNode): + """Add a node to the network""" + self.nodes[node.node_id] = node + + def add_link(self, link: TransportLink): + """Add a link to the network""" + self.links[link.link_id] = link + + def get_node(self, node_id: str) -> TransportNode: + """Get a node by its ID""" + return self.nodes.get(node_id) + + def get_link(self, link_id: str) -> TransportLink: + """Get a link by its ID""" + return self.links.get(link_id) + + def add_weight_data(self, link_id: str, time_period: str, weight: float): + """Add weight data for a specific link and time period""" + if link_id in self.links: + self.links[link_id].add_weight_data(time_period, weight) + self.time_periods.add(time_period) + + def to_networkx(self, time_period: Optional[str] = None) -> nx.DiGraph: + """ + Convert the transport network to a NetworkX directed graph + + Args: + time_period: Optional time period to use for edge weights + + Returns: + NetworkX DiGraph representation of the network + """ + G = nx.DiGraph(name=self.name) + + # Add nodes with positions + for node_id, node in self.nodes.items(): + G.add_node(node_id, pos=(node.x, node.y), name=node.name, **node.attributes) + + # Add edges with weights + for link_id, link in self.links.items(): + weight = link.get_weight(time_period) if time_period else 1.0 + G.add_edge( + link.from_node, + link.to_node, + id=link_id, + length=link.length, + capacity=link.capacity, + free_speed=link.free_speed, + weight=weight, + **link.attributes + ) + + return G + + def visualize(self, time_period: Optional[str] = None, figsize=(12, 10), + node_size=100, node_color='skyblue', edge_width_factor=1.0): + """ + Visualize the network with optional weights for a specific time period + + Args: + time_period: Optional time period to use for edge weights + figsize: Figure size + node_size: Size of nodes in the visualization + node_color: Color of nodes + edge_width_factor: Factor to multiply edge widths by + """ + G = self.to_networkx(time_period) + pos = nx.get_node_attributes(G, 'pos') + + plt.figure(figsize=figsize) + + # Draw nodes + nx.draw_networkx_nodes(G, pos, node_size=node_size, node_color=node_color) + + # Draw edges with width proportional to weight + if time_period: + weights = [G[u][v]['weight'] for u, v in G.edges()] + max_weight = max(weights) if weights else 1.0 + normalized_weights = [w/max_weight * edge_width_factor for w in weights] + nx.draw_networkx_edges(G, pos, width=normalized_weights, + edge_color='gray', alpha=0.7, arrows=True) + else: + nx.draw_networkx_edges(G, pos, width=1.0, edge_color='gray', alpha=0.7, arrows=True) + + # Draw labels + nx.draw_networkx_labels(G, pos, font_size=8) + + title = f"{self.name}" + if time_period: + title += f" - Time Period: {time_period}" + plt.title(title) + plt.axis('off') + plt.tight_layout() + + return plt + + def __repr__(self): + return f"TransportNetwork(name={self.name}, nodes={len(self.nodes)}, links={len(self.links)})" \ No newline at end of file diff --git a/oasis/transportation/matsim/simulation.py b/oasis/transportation/matsim/simulation.py new file mode 100644 index 00000000..c116a754 --- /dev/null +++ b/oasis/transportation/matsim/simulation.py @@ -0,0 +1,148 @@ +import numpy as np +import pandas as pd +from typing import Dict, List, Tuple, Optional, Callable +import matplotlib.pyplot as plt +from .network import TransportNetwork, TransportNode, TransportLink +import copy +import random + +class TransportSimulation: + """Simulates transportation network evolution over time""" + + def __init__(self, network: TransportNetwork, seed: int = 42): + """ + Initialize a transport simulation + + Args: + network: The base transport network to simulate + seed: Random seed for reproducibility + """ + self.base_network = network + self.simulated_networks = {} # time_step -> TransportNetwork + self.random = random.Random(seed) + + # Store the original network as the starting point + self.simulated_networks[0] = copy.deepcopy(network) + + def simulate_time_evolution(self, + num_steps: int, + weight_evolution_model: Callable[[str, float, int], float], + time_periods: Optional[List[str]] = None): + """ + Simulate the evolution of the network over time + + Args: + num_steps: Number of time steps to simulate + weight_evolution_model: Function that takes (link_id, current_weight, time_step) + and returns the new weight + time_periods: List of time periods to simulate (if None, use all time periods in base network) + """ + if time_periods is None: + time_periods = list(self.base_network.time_periods) + + # Start with the base network + current_network = self.simulated_networks[0] + + # Simulate each time step + for step in range(1, num_steps + 1): + # Create a new network for this time step + new_network = copy.deepcopy(current_network) + + # Update weights for each link and time period + for link_id, link in new_network.links.items(): + for period in time_periods: + if period in link.weights_history: + current_weight = link.weights_history[period] + new_weight = weight_evolution_model(link_id, current_weight, step) + link.weights_history[period] = new_weight + + # Store the network for this time step + self.simulated_networks[step] = new_network + current_network = new_network + + def get_network_at_time(self, time_step: int) -> TransportNetwork: + """Get the simulated network at a specific time step""" + if time_step in self.simulated_networks: + return self.simulated_networks[time_step] + else: + raise ValueError(f"No simulation data for time step {time_step}") + + def visualize_evolution(self, time_steps: List[int], time_period: str, + figsize=(18, 12), rows=1): + """ + Visualize the network evolution over multiple time steps + + Args: + time_steps: List of time steps to visualize + time_period: Time period to visualize + figsize: Figure size + rows: Number of rows in the subplot grid + """ + cols = int(np.ceil(len(time_steps) / rows)) + fig = plt.figure(figsize=figsize) + + for i, step in enumerate(time_steps): + network = self.get_network_at_time(step) + ax = fig.add_subplot(rows, cols, i+1) + + G = network.to_networkx(time_period) + pos = nx.get_node_attributes(G, 'pos') + + # Draw nodes + nx.draw_networkx_nodes(G, pos, node_size=80, node_color='skyblue', ax=ax) + + # Draw edges with width proportional to weight + weights = [G[u][v]['weight'] for u, v in G.edges()] + max_weight = max(weights) if weights else 1.0 + normalized_weights = [w/max_weight * 3 for w in weights] + nx.draw_networkx_edges(G, pos, width=normalized_weights, + edge_color='gray', alpha=0.7, arrows=True, ax=ax) + + # Draw labels + nx.draw_networkx_labels(G, pos, font_size=7, ax=ax) + + ax.set_title(f"Time Step: {step}, Period: {time_period}") + ax.axis('off') + + plt.tight_layout() + return plt + + def get_weight_evolution_data(self, link_id: str, time_period: str) -> Dict[int, float]: + """ + Get the evolution of weights for a specific link and time period + + Returns: + Dictionary mapping time steps to weights + """ + result = {} + for step, network in self.simulated_networks.items(): + link = network.get_link(link_id) + if link and time_period in link.weights_history: + result[step] = link.weights_history[time_period] + return result + + def plot_weight_evolution(self, link_ids: List[str], time_period: str, figsize=(10, 6)): + """ + Plot the evolution of weights for specific links over time + + Args: + link_ids: List of link IDs to plot + time_period: Time period to plot + figsize: Figure size + """ + plt.figure(figsize=figsize) + + for link_id in link_ids: + data = self.get_weight_evolution_data(link_id, time_period) + if data: + steps = sorted(data.keys()) + weights = [data[step] for step in steps] + plt.plot(steps, weights, marker='o', label=f"Link {link_id}") + + plt.xlabel("Time Step") + plt.ylabel("Weight") + plt.title(f"Weight Evolution for Time Period: {time_period}") + plt.legend() + plt.grid(True, alpha=0.3) + + return plt \ No newline at end of file diff --git a/oasis/transportation/matsim/test_iteration.xml b/oasis/transportation/matsim/test_iteration.xml new file mode 100644 index 00000000..9f2aff09 --- /dev/null +++ b/oasis/transportation/matsim/test_iteration.xml @@ -0,0 +1,100 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/oasis/transportation/sumo/bus_schedule.add.xml b/oasis/transportation/sumo/bus_schedule.add.xml new file mode 100644 index 00000000..ebac4cf1 --- /dev/null +++ b/oasis/transportation/sumo/bus_schedule.add.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/oasis/transportation/sumo/example.sumocfg b/oasis/transportation/sumo/example.sumocfg new file mode 100644 index 00000000..1376b889 --- /dev/null +++ b/oasis/transportation/sumo/example.sumocfg @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/oasis/transportation/sumo/example_network.net.xml b/oasis/transportation/sumo/example_network.net.xml new file mode 100644 index 00000000..6bb9bc43 --- /dev/null +++ b/oasis/transportation/sumo/example_network.net.xml @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/oasis/transportation/sumo/example_routes.rou.xml b/oasis/transportation/sumo/example_routes.rou.xml new file mode 100644 index 00000000..3ab67c69 --- /dev/null +++ b/oasis/transportation/sumo/example_routes.rou.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/oasis/transportation/sumo/output/iteration_0/config_iter_0.sumocfg b/oasis/transportation/sumo/output/iteration_0/config_iter_0.sumocfg new file mode 100644 index 00000000..c78dbcb9 --- /dev/null +++ b/oasis/transportation/sumo/output/iteration_0/config_iter_0.sumocfg @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/oasis/transportation/sumo/output/updated_routes_1.xml b/oasis/transportation/sumo/output/updated_routes_1.xml new file mode 100644 index 00000000..1edfb624 --- /dev/null +++ b/oasis/transportation/sumo/output/updated_routes_1.xml @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/oasis/transportation/sumo/output/updated_routes_2.xml b/oasis/transportation/sumo/output/updated_routes_2.xml new file mode 100644 index 00000000..1edfb624 --- /dev/null +++ b/oasis/transportation/sumo/output/updated_routes_2.xml @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/oasis/transportation/sumo/requirements.txt b/oasis/transportation/sumo/requirements.txt new file mode 100644 index 00000000..9e092e0f --- /dev/null +++ b/oasis/transportation/sumo/requirements.txt @@ -0,0 +1,3 @@ +requests +pyyaml +traci \ No newline at end of file diff --git a/oasis/transportation/sumo/sumo_agent.py b/oasis/transportation/sumo/sumo_agent.py new file mode 100644 index 00000000..07503421 --- /dev/null +++ b/oasis/transportation/sumo/sumo_agent.py @@ -0,0 +1,480 @@ +from sumo_env import SUMOEnvironment +from typing import List, Dict, Any + +class LLMAgent: + """Agent that uses LLM to make decisions about route updates, including multimodal options""" + + def __init__(self, vehicle_id: str, environment: SUMOEnvironment, openai_api_key: str): + """Initialize agent + + Args: + vehicle_id: ID of the vehicle in the SUMO simulation + environment: SUMOEnvironment instance + openai_api_key: API key for OpenAI + """ + self.vehicle_id = vehicle_id + self.environment = environment + self.openai_api_key = openai_api_key + self.route_history = [] + self.multimodal_journey = False # Whether this agent is using multimodal transport + self.transport_modes = [] # List of transport modes used + + def update_route(self, network_state: Dict[str, Any]) -> Dict[str, Any]: + """Update the agent's route based on network state using LLM + + Args: + network_state: Dictionary with network state information + + Returns: + Dictionary with route update information + """ + print(f"Updating route for vehicle {self.vehicle_id}") + + # Check if vehicle exists in environment + if self.vehicle_id not in self.environment.vehicles: + print(f" Vehicle {self.vehicle_id} not found in simulation") + return {} + + # Extract vehicle data + vehicle_data = self._extract_vehicle_data() + + # Extract relevant network data + network_data = self._extract_relevant_network_data(network_state) + + # Extract public transit data + transit_data = self._extract_public_transit_data(network_state) + + # Generate prompt for LLM + prompt = self._generate_prompt(vehicle_data, network_data, transit_data) + + # Query LLM + try: + llm_response = self._query_llm(prompt) + + # Parse and apply LLM suggestions + route_update = self._parse_llm_suggestions(llm_response) + return route_update + + except Exception as e: + print(f"Error querying LLM: {e}") + return {} + + def _extract_vehicle_data(self) -> Dict[str, Any]: + """Extract relevant data from a vehicle + + Returns: + Dictionary with vehicle data + """ + vehicle_data = self.environment.vehicles.get(self.vehicle_id, {}) + + # Format the data for the LLM prompt + formatted_data: Dict[str, Any] = { + "vehicle_id": self.vehicle_id, + "vehicle_type": vehicle_data.get("type", "unknown"), + "current_route": vehicle_data.get("route_id", "unknown"), + "edge_history": vehicle_data.get("edge_history", []), + "travel_times": vehicle_data.get("travel_times", {}), + "is_public_transit": vehicle_data.get("is_public_transit", False), + "multimodal_journey": self.multimodal_journey, + "transport_modes": self.transport_modes + } + + return formatted_data + + def _extract_relevant_network_data(self, network_state: Dict[str, Any]) -> Dict[str, Any]: + """Extract network data relevant to this agent's routes + + Args: + network_state: Full network state + + Returns: + Dictionary with relevant network data + """ + relevant_data = {} + + # Skip public transit key if present + if "public_transit" in network_state: + network_state_edges = {k: v for k, v in network_state.items() if k != "public_transit"} + else: + network_state_edges = network_state + + # Get vehicle's edge history + vehicle_data = self.environment.vehicles.get(self.vehicle_id, {}) + edge_history = vehicle_data.get("edge_history", []) + + # Include data for edges the vehicle has traveled on + for edge_id in edge_history: + if edge_id in network_state_edges: + relevant_data[edge_id] = network_state_edges[edge_id] + + # Include data for all edges if we have limited history + if len(relevant_data) < 5: + # Add some of the most congested edges + congested_edges = sorted( + [(edge_id, data["travel_time"]) for edge_id, data in network_state_edges.items()], + key=lambda x: x[1], + reverse=True + )[:10] + + for edge_id, _ in congested_edges: + if edge_id not in relevant_data: + relevant_data[edge_id] = network_state_edges[edge_id] + + return relevant_data + + def _extract_public_transit_data(self, network_state: Dict[str, Any]) -> Dict[str, Any]: + """Extract public transit data from network state + + Args: + network_state: Full network state + + Returns: + Dictionary with public transit data + """ + transit_data = { + "nearby_stops": [], + "relevant_buses": [], + "relevant_trains": [] + } + + # Skip if public transit data is not available + if "public_transit" not in network_state: + return transit_data + + pt_data = network_state["public_transit"] + + # Get vehicle's current edge + vehicle_data = self.environment.vehicles.get(self.vehicle_id, {}) + current_edge = vehicle_data.get("edge_history", [])[-1] if vehicle_data.get("edge_history") else None + + if not current_edge: + return transit_data + + # Find nearby stops (stops on the current edge or recent history) + edge_history = vehicle_data.get("edge_history", [])[-5:] # Last 5 edges + + for stop_id, stop_data in pt_data.get("stops", {}).items(): + stop_edge = stop_data.get("edge_id") + if stop_edge in edge_history: + transit_data["nearby_stops"].append({ + "id": stop_id, + "edge_id": stop_edge, + "position": stop_data.get("position"), + "waiting_vehicles": stop_data.get("waiting_vehicles", []) + }) + + # Find relevant buses (buses that pass through nearby stops) + for bus_id, bus_data in pt_data.get("buses", {}).items(): + next_stop = bus_data.get("next_stop") + for stop in transit_data["nearby_stops"]: + if next_stop == stop["id"] or stop["id"] in bus_data.get("stops", []): + transit_data["relevant_buses"].append({ + "id": bus_id, + "line": bus_data.get("line", "unknown"), + "current_edge": bus_data.get("current_edge"), + "next_stop": next_stop + }) + break + + # Find relevant trains (trains that pass through nearby stops) + for train_id, train_data in pt_data.get("trains", {}).items(): + next_stop = train_data.get("next_stop") + for stop in transit_data["nearby_stops"]: + if next_stop == stop["id"] or stop["id"] in train_data.get("stops", []): + transit_data["relevant_trains"].append({ + "id": train_id, + "line": train_data.get("line", "unknown"), + "current_edge": train_data.get("current_edge"), + "next_stop": next_stop + }) + break + + return transit_data + + def _generate_prompt(self, vehicle_data: Dict[str, Any], + network_data: Dict[str, Any], + transit_data: Dict[str, Any]) -> str: + """Generate a prompt for the LLM + + Args: + vehicle_data: Vehicle's current data + network_data: Relevant network state + transit_data: Public transit data + + Returns: + Prompt string + """ + prompt = f""" +You are an intelligent navigation system for vehicle {vehicle_data['vehicle_id']} of type {vehicle_data['vehicle_type']}. +Your task is to provide optimal routing recommendations, including multimodal options with buses and trains when appropriate. + +CURRENT VEHICLE STATUS: +- Vehicle ID: {vehicle_data['vehicle_id']} +- Vehicle Type: {vehicle_data['vehicle_type']} +- Current Route: {vehicle_data['current_route']} +- Edge History: {', '.join(vehicle_data['edge_history'][-5:]) if vehicle_data['edge_history'] else 'No history yet'} +- Currently Using Multimodal Journey: {vehicle_data['multimodal_journey']} +- Transport Modes Used: {', '.join(vehicle_data['transport_modes']) if vehicle_data['transport_modes'] else 'Private vehicle only'} + +TRAFFIC NETWORK STATUS: +""" + + # Add information about network edges + for edge_id, edge_data in network_data.items(): + prompt += f""" +Edge ID: {edge_id} +- Mean Speed: {edge_data['mean_speed']:.2f} m/s +- Occupancy: {edge_data['occupancy']:.2f} +- Vehicle Count: {edge_data['vehicle_count']:.1f} +- Travel Time: {edge_data['travel_time']:.2f} seconds +""" + + # Add travel time information if available + if vehicle_data['travel_times']: + prompt += "\nVEHICLE TRAVEL TIMES:\n" + for edge_id, time_data in vehicle_data['travel_times'].items(): + prompt += f"- Edge {edge_id}: {time_data['time']} seconds\n" + + # Add public transit information + prompt += "\nPUBLIC TRANSIT OPTIONS:\n" + + if transit_data["nearby_stops"]: + prompt += "Nearby Transit Stops:\n" + for stop in transit_data["nearby_stops"]: + prompt += f"- Stop {stop['id']} on edge {stop['edge_id']}\n" + else: + prompt += "No nearby transit stops detected.\n" + + if transit_data["relevant_buses"]: + prompt += "\nAvailable Buses:\n" + for bus in transit_data["relevant_buses"]: + prompt += f"- Bus {bus['id']} (Line {bus['line']}), currently on edge {bus['current_edge']}, next stop: {bus['next_stop']}\n" + + if transit_data["relevant_trains"]: + prompt += "\nAvailable Trains:\n" + for train in transit_data["relevant_trains"]: + prompt += f"- Train {train['id']} (Line {train['line']}), currently on edge {train['current_edge']}, next stop: {train['next_stop']}\n" + + # Request routing recommendations including multimodal options + prompt += """ +Based on the traffic network status and public transit options, please provide routing recommendations for this vehicle. +Analyze the traffic conditions and suggest improvements to the vehicle's journey, including multimodal options with buses and trains when appropriate. + +INSTRUCTIONS: +1. Identify congested edges (high travel time, low speed, high occupancy) +2. Consider both private vehicle routing and public transit options +3. Recommend switching to public transit if it would be more efficient +4. Consider the vehicle's type and history in your recommendations +5. Provide a brief explanation for your recommendations + +Output your response in JSON format as follows: +```json +{ + "route_adjustments": [ + { + "edge_to_avoid": "edge_id", + "alternative_edge": "edge_id", + "confidence": 0.8 + } + ], + "public_transit_recommendations": [ + { + "type": "bus", + "id": "bus_id", + "board_at_stop": "stop_id", + "alight_at_stop": "stop_id", + "confidence": 0.9 + } + ], + "multimodal_strategy": { + "use_multimodal": true, + "transport_modes": ["car", "bus", "train"], + "transitions": [ + { + "from_mode": "car", + "to_mode": "bus", + "at_location": "stop_id", + "time_saved_estimate": 300 + } + ] + }, + "explanation": "Brief explanation of your recommendations" +} +``` +""" + return prompt + + def _query_llm(self, prompt: str) -> str: + """Query LLM with the prompt + + Args: + prompt: Prompt string + + Returns: + Response from LLM + """ + if not self.openai_api_key: + # Generate a simulated response if no API key + return self._generate_simulated_llm_response() + + try: + # Send request to OpenAI API + response = requests.post( + "https://api.openai.com/v1/chat/completions", + headers={ + "Authorization": f"Bearer {self.openai_api_key}", + "Content-Type": "application/json" + }, + json={ + "model": "gpt-4", + "messages": [ + {"role": "system", "content": "You are a traffic navigation assistant for SUMO traffic simulation."}, + {"role": "user", "content": prompt} + ], + "temperature": 0.7, + "max_tokens": 500 + }, + timeout=30 + ) + + # Parse the response + response_data = response.json() + if "choices" in response_data and len(response_data["choices"]) > 0: + return response_data["choices"][0]["message"]["content"] + else: + print("Unexpected response format from OpenAI API") + return self._generate_simulated_llm_response() + + except Exception as e: + print(f"Error calling OpenAI API: {e}") + return self._generate_simulated_llm_response() + + def _generate_simulated_llm_response(self) -> str: + """Generate a simulated LLM response when API is unavailable + + Returns: + Simulated response string + """ + print(" Generating simulated LLM response") + + # Create a reasonable simulated response that includes multimodal options + edge_to_avoid = f"edge_{random.randint(1, 9)}" + alternative_edge = f"edge_{random.randint(1, 9)}" + confidence = round(random.uniform(0.6, 0.95), 2) + + # Randomly decide whether to recommend public transit + recommend_transit = random.random() < 0.4 + + response = { + "route_adjustments": [ + { + "edge_to_avoid": edge_to_avoid, + "alternative_edge": alternative_edge, + "confidence": confidence + } + ], + "explanation": "Based on traffic conditions, I've identified congestion on the specified edge." + } + + if recommend_transit: + # Add public transit recommendations + transit_type = "bus" if random.random() < 0.7 else "train" + transit_id = f"{transit_type}_{random.randint(0, 2)}" + board_stop = f"stop_{random.randint(0, 4)}" if transit_type == "bus" else f"station_{random.randint(0, 2)}" + alight_stop = f"stop_{random.randint(0, 4)}" if transit_type == "bus" else f"station_{random.randint(0, 2)}" + + response["multimodal_strategy"] = { + "use_multimodal": True, + "transport_modes": ["car", transit_type], + "transitions": [ + { + "from_mode": "car", + "to_mode": transit_type, + "at_location": board_stop, + "time_saved_estimate": random.randint(100, 500) + } + ] + } + + response["explanation"] += f" I recommend switching to {transit_type} at {board_stop} to save time and avoid traffic congestion." + else: + response["public_transit_recommendations"] = [] + response["multimodal_strategy"] = { + "use_multimodal": False, + "transport_modes": ["car"], + "transitions": [] + } + response["explanation"] += " The private vehicle route is currently optimal, so no public transit recommendations at this time." + + return f"```json\n{json.dumps(response, indent=2)}\n```" + + def _parse_llm_suggestions(self, llm_response: str) -> Dict[str, Any]: + """Parse LLM response and extract route adjustment suggestions + + Args: + llm_response: String response from LLM + + Returns: + Dictionary with route adjustments and multimodal strategy + """ + try: + # Extract JSON from markdown code blocks if present + json_start = llm_response.find("```json") + if json_start != -1: + json_start = llm_response.find("\n", json_start) + 1 + json_end = llm_response.find("```", json_start) + json_str = llm_response[json_start:json_end].strip() + else: + # Try to find any JSON object in the response + json_start = llm_response.find("{") + json_end = llm_response.rfind("}") + 1 + if json_start == -1 or json_end == 0: + print(" No JSON found in LLM response") + return {} + json_str = llm_response[json_start:json_end].strip() + + # Parse the JSON + recommendations = json.loads(json_str) + + print(f" Received routing recommendations:") + print(f" Explanation: {recommendations.get('explanation', 'No explanation provided')}") + + # Process route adjustments + for adjustment in recommendations.get("route_adjustments", []): + edge_to_avoid = adjustment.get("edge_to_avoid") + alternative_edge = adjustment.get("alternative_edge") + confidence = adjustment.get("confidence", 0.0) + + print(f" - Avoid {edge_to_avoid}, use {alternative_edge} instead (confidence: {confidence:.2f})") + + # Process public transit recommendations + for transit_rec in recommendations.get("public_transit_recommendations", []): + transit_type = transit_rec.get("type") + transit_id = transit_rec.get("id") + board_stop = transit_rec.get("board_at_stop") + alight_stop = transit_rec.get("alight_at_stop") + confidence = transit_rec.get("confidence", 0.0) + + print(f" - Take {transit_type} {transit_id} from {board_stop} to {alight_stop} (confidence: {confidence:.2f})") + + # Process multimodal strategy + multimodal = recommendations.get("multimodal_strategy", {}) + if multimodal.get("use_multimodal", False): + self.multimodal_journey = True + self.transport_modes = multimodal.get("transport_modes", ["car"]) + + print(f" - Multimodal journey recommended with modes: {', '.join(self.transport_modes)}") + + for transition in multimodal.get("transitions", []): + from_mode = transition.get("from_mode") + to_mode = transition.get("to_mode") + location = transition.get("at_location") + time_saved = transition.get("time_saved_estimate", 0) + + print(f" - Transit from {from_mode} to {to_mode} at {location} (saves ~{time_saved} seconds)") + + return recommendations + + except Exception as e: + print(f"Error parsing LLM suggestions: {e}") + return {} diff --git a/oasis/transportation/sumo/sumo_env.py b/oasis/transportation/sumo/sumo_env.py new file mode 100644 index 00000000..6eb022c3 --- /dev/null +++ b/oasis/transportation/sumo/sumo_env.py @@ -0,0 +1,441 @@ +# TODO reconfirm the simulation process with stone +import os +import subprocess +import traci +from typing import List, Dict, Any + +class SUMOEnvironment: + """Environment for SUMO simulation with LLM agent feedback""" + + def __init__(self, network_file: str, route_file: str, + config_file: str, output_dir: str, + additional_files: List[str] = None): + """Initialize the SUMO environment + + Args: + network_file: Path to the network XML file + route_file: Path to the route XML file + config_file: Path to the SUMO config file + output_dir: Directory to store output files + additional_files: List of additional files (e.g., public transit schedules) + """ + self.network_file = network_file + self.route_file = route_file + self.config_file = config_file + self.output_dir = output_dir + self.additional_files = additional_files if additional_files else [] + self.iteration = 0 + self.sim_running = False + self.vehicles = {} # Dictionary to store vehicle data + # dictionary to store public transit data + self.public_transit = { + "buses": {}, # Bus data + "trains": {}, # Train data + "stops": {} # Public transit stop data + } + + # Create output directory if it doesn't exist + os.makedirs(output_dir, exist_ok=True) + + async def run_iteration(self, sumo_binary: str) -> Dict[str, Any]: + """Run a single SUMO iteration + + Args: + sumo_binary: Path to the SUMO or SUMO-GUI binary + + Returns: + Dictionary containing network state information + """ + # Create iteration-specific output directory + iter_output_dir = os.path.join(self.output_dir, f"iteration_{self.iteration}") + os.makedirs(iter_output_dir, exist_ok=True) + + # Prepare configuration for this iteration + iter_config_file = os.path.join(iter_output_dir, f"config_iter_{self.iteration}.sumocfg") + self._prepare_iteration_config(iter_config_file, iter_output_dir) + + # Run SUMO using TraCI + try: + # Start the simulation + print(f"Running SUMO iteration {self.iteration}...") + print(f" - Config file: {iter_config_file}") + print(f" - Output directory: {iter_output_dir}") + + traci_port = self._get_free_port() + sumo_cmd = [ + sumo_binary, + "-c", iter_config_file, + "--remote-port", str(traci_port), + "--no-step-log", "true", + "--no-warnings", "true", + "--output-prefix", f"iter_{self.iteration}_", + "--netstate-dump", os.path.join(iter_output_dir, "network_state.xml"), + "--netstate-dump.empty-edges", "true", + "--netstate-dump.max-parts", "1" + ] + + # Add additional files if specified + if self.additional_files: + additional_param = ",".join(self.additional_files) + sumo_cmd.extend(["--additional-files", additional_param]) + + # Try to start SUMO + try: + sumo_process = subprocess.Popen(sumo_cmd) + traci.init(traci_port) + self.sim_running = True + except (subprocess.SubprocessError, traci.exceptions.FatalTraCIError) as e: + print(f"Error starting SUMO: {e}") + print("Falling back to simulated data...") + # replace it with customized data + return self._generate_simulated_network_state() + + # Run the simulation for a fixed number of steps + network_state = {} + step_count = 0 + max_steps = 100 # Number of simulation steps to run + + while step_count < max_steps: + traci.simulationStep() + + # Update vehicle data + vehicle_ids: List[str] = traci.vehicle.getIDList() + for veh_id in vehicle_ids: + if veh_id not in self.vehicles: + # New vehicle - initialize its data + route_id = traci.vehicle.getRouteID(veh_id) + vehicle_type = traci.vehicle.getTypeID(veh_id) + self.vehicles[veh_id] = { + "id": veh_id, + "route_id": route_id, + "type": vehicle_type, + "edge_history": [], + "travel_times": {}, + "is_public_transit": veh_id.startswith("bus_") or veh_id.startswith("train_") + } + + # Update vehicle data + edge_id: str = traci.vehicle.getRoadID(veh_id) + if edge_id.startswith(":"): + # Skip junction edges + continue + + speed = traci.vehicle.getSpeed(veh_id) + position = traci.vehicle.getPosition(veh_id) + lane_id = traci.vehicle.getLaneID(veh_id) + + # Update edge history + veh_data = self.vehicles[veh_id] + if edge_id not in veh_data["edge_history"]: + veh_data["edge_history"].append(edge_id) + + # Update travel time for this edge + if edge_id in veh_data["travel_times"]: + veh_data["travel_times"][edge_id]["time"] += 1 + else: + veh_data["travel_times"][edge_id] = { + "entry_time": step_count, + "time": 1, + "lane_id": lane_id + } + + # Collect public transit data + try: + # Track buses (assuming bus IDs start with "bus_") + bus_ids: List[str] = [veh_id for veh_id in vehicle_ids if veh_id.startswith("bus_")] + for bus_id in bus_ids: + if bus_id not in self.public_transit["buses"]: + route_id = traci.vehicle.getRouteID(bus_id) + line_id = traci.vehicle.getLine(bus_id) if hasattr(traci.vehicle, 'getLine') else "unknown" + self.public_transit["buses"][bus_id] = { + "id": bus_id, + "route_id": route_id, + "line": line_id, + "stops": [], + "current_edge": traci.vehicle.getRoadID(bus_id), + "next_stop": None, + "schedule": {} + } + + # Update bus data + self.public_transit["buses"][bus_id]["current_edge"] = traci.vehicle.getRoadID(bus_id) + + # Get the next stop (if available in this SUMO version) + if hasattr(traci.vehicle, 'getNextStops'): + next_stops = traci.vehicle.getNextStops(bus_id) + if next_stops: + self.public_transit["buses"][bus_id]["next_stop"] = next_stops[0] + + # Track trains (assuming train IDs start with "train_") + train_ids = [veh_id for veh_id in vehicle_ids if veh_id.startswith("train_")] + for train_id in train_ids: + if train_id not in self.public_transit["trains"]: + route_id = traci.vehicle.getRouteID(train_id) + line_id = traci.vehicle.getLine(train_id) if hasattr(traci.vehicle, 'getLine') else "unknown" + self.public_transit["trains"][train_id] = { + "id": train_id, + "route_id": route_id, + "line": line_id, + "stops": [], + "current_edge": traci.vehicle.getRoadID(train_id), + "next_stop": None, + "schedule": {} + } + + # Update train data + self.public_transit["trains"][train_id]["current_edge"] = traci.vehicle.getRoadID(train_id) + + # Get the next stop (if available in this SUMO version) + if hasattr(traci.vehicle, 'getNextStops'): + next_stops = traci.vehicle.getNextStops(train_id) + if next_stops: + self.public_transit["trains"][train_id]["next_stop"] = next_stops[0] + + # Track public transit stops + if hasattr(traci, 'busstop'): + stop_ids = traci.busstop.getIDList() + for stop_id in stop_ids: + if stop_id not in self.public_transit["stops"]: + # Initialize stop data + lane_id = traci.busstop.getLaneID(stop_id) + position = traci.busstop.getStartPos(stop_id) + self.public_transit["stops"][stop_id] = { + "id": stop_id, + "lane_id": lane_id, + "position": position, + "waiting_vehicles": [], + "edge_id": lane_id.split("_")[0] if "_" in lane_id else "unknown" + } + + # Update stop data + if hasattr(traci.busstop, 'getVehicleIDs'): + waiting_vehicles = traci.busstop.getVehicleIDs(stop_id) + self.public_transit["stops"][stop_id]["waiting_vehicles"] = waiting_vehicles + + except Exception as e: + print(f"Error collecting public transit data: {e}") + # Continue with simulation even if we can't collect transit data + + # Collect edge data for network state + for edge_id in traci.edge.getIDList(): + if edge_id.startswith(":"): + # Skip junction edges + continue + + mean_speed = traci.edge.getLastStepMeanSpeed(edge_id) + occupancy = traci.edge.getLastStepOccupancy(edge_id) + vehicle_count = traci.edge.getLastStepVehicleNumber(edge_id) + travel_time = traci.edge.getTraveltime(edge_id) + + if edge_id not in network_state: + network_state[edge_id] = { + "mean_speed": [], + "occupancy": [], + "vehicle_count": [], + "travel_time": [] + } + + network_state[edge_id]["mean_speed"].append(mean_speed) + network_state[edge_id]["occupancy"].append(occupancy) + network_state[edge_id]["vehicle_count"].append(vehicle_count) + network_state[edge_id]["travel_time"].append(travel_time) + + step_count += 1 + + # Calculate averages for the network state + for edge_id, data in network_state.items(): + for key, values in data.items(): + if values: # Ensure the list is not empty + data[key] = sum(values) / len(values) + else: + data[key] = 0 + + # Add public transit information to network state + network_state["public_transit"] = { + "buses": self.public_transit["buses"], + "trains": self.public_transit["trains"], + "stops": self.public_transit["stops"] + } + + # Close the TraCI connection + traci.close() + self.sim_running = False + + self.iteration += 1 + return network_state + + except Exception as e: + print(f"Error during SUMO simulation: {e}") + if self.sim_running: + try: + traci.close() + except: + pass + self.sim_running = False + + print("Falling back to simulated data...") + return self._generate_simulated_network_state() + + def _prepare_iteration_config(self, config_file: str, output_dir: str): + """Prepare a SUMO configuration file for the current iteration + + Args: + config_file: Path to write the new config file + output_dir: Output directory for this iteration + """ + # Create a basic SUMO configuration file + # In a real implementation, you'd want to modify an existing config + root = ET.Element("configuration") + + input_section = ET.SubElement(root, "input") + ET.SubElement(input_section, "net-file", value=self.network_file) + ET.SubElement(input_section, "route-files", value=self.route_file) + + if self.additional_files: + ET.SubElement(input_section, "additional-files", value=",".join(self.additional_files)) + + output_section = ET.SubElement(root, "output") + ET.SubElement(output_section, "tripinfo-output", + value=os.path.join(output_dir, "tripinfo.xml")) + ET.SubElement(output_section, "summary-output", + value=os.path.join(output_dir, "summary.xml")) + + time_section = ET.SubElement(root, "time") + ET.SubElement(time_section, "begin", value="0") + ET.SubElement(time_section, "end", value="3600") # 1 hour simulation + print("Config file: " + config_file) + # Write the configuration to file + tree = ET.ElementTree(root) + tree.write(config_file, encoding="utf-8", xml_declaration=True) + + def _get_free_port(self) -> int: + """Get a free port for TraCI connection""" + import socket + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.bind(('', 0)) + port = s.getsockname()[1] + s.close() + return port + + def _generate_simulated_network_state(self) -> Dict[str, Any]: + """Generate simulated network state when SUMO is unavailable + + Returns: + Dictionary with network state data + """ + print("Generating simulated network data...") + + # Try to parse the network file to get edge IDs + edge_ids = [] + try: + tree = ET.parse(self.network_file) + root = tree.getroot() + for edge in root.findall(".//edge"): + if "id" in edge.attrib and not edge.attrib["id"].startswith(":"): + edge_ids.append(edge.attrib["id"]) + except: + # If network file can't be parsed, generate some dummy edge IDs + edge_ids = [f"edge_{i}" for i in range(10)] + + # Generate simulated data for each edge + network_state = {} + for edge_id in edge_ids: + # Generate realistic traffic data + # Lower speeds and higher occupancy for some edges to simulate congestion + is_congested = random.random() < 0.3 + + if is_congested: + mean_speed = random.uniform(5.0, 15.0) # m/s + occupancy = random.uniform(0.4, 0.8) + vehicle_count = random.randint(5, 20) + travel_time = random.uniform(60.0, 180.0) # seconds + else: + mean_speed = random.uniform(20.0, 33.0) # m/s + occupancy = random.uniform(0.05, 0.3) + vehicle_count = random.randint(0, 7) + travel_time = random.uniform(20.0, 45.0) # seconds + + network_state[edge_id] = { + "mean_speed": mean_speed, + "occupancy": occupancy, + "vehicle_count": vehicle_count, + "travel_time": travel_time + } + + # Add simulated public transit data + network_state["public_transit"] = self._generate_simulated_public_transit(edge_ids) + + return network_state + + def _generate_simulated_public_transit(self, edge_ids: List[str]) -> Dict[str, Any]: + """Generate simulated public transit data + + Args: + edge_ids: List of edge IDs in the network + + Returns: + Dictionary with simulated public transit data + """ + # Generate simulated bus data + buses = {} + for i in range(5): # Simulate 5 buses + bus_id = f"bus_{i}" + route = random.sample(edge_ids, min(5, len(edge_ids))) + current_edge = route[random.randint(0, len(route)-1)] + + buses[bus_id] = { + "id": bus_id, + "route_id": f"bus_route_{i}", + "line": f"line_{i}", + "stops": [f"stop_{j}" for j in range(3)], + "current_edge": current_edge, + "next_stop": f"stop_{random.randint(0, 2)}", + "schedule": {} + } + + # Generate simulated train data + trains = {} + for i in range(3): # Simulate 3 trains + train_id = f"train_{i}" + route = random.sample(edge_ids, min(4, len(edge_ids))) + current_edge = route[random.randint(0, len(route)-1)] + + trains[train_id] = { + "id": train_id, + "route_id": f"train_route_{i}", + "line": f"line_{i+10}", + "stops": [f"station_{j}" for j in range(2)], + "current_edge": current_edge, + "next_stop": f"station_{random.randint(0, 1)}", + "schedule": {} + } + + # Generate simulated stop data + stops = {} + for i in range(8): # Simulate 8 stops (5 bus stops, 3 train stations) + stop_type = "station" if i >= 5 else "stop" + stop_id = f"{stop_type}_{i % 5 if stop_type == 'stop' else i % 3}" + + # Select a random edge for this stop + edge_id = random.choice(edge_ids) + lane_id = f"{edge_id}_0" + + stops[stop_id] = { + "id": stop_id, + "lane_id": lane_id, + "position": (random.uniform(0, 1000), random.uniform(0, 1000)), + "waiting_vehicles": [], + "edge_id": edge_id + } + + # Randomly add waiting vehicles + if random.random() < 0.4: + vehicle_type = "train" if stop_type == "station" else "bus" + vehicle_id = f"{vehicle_type}_{random.randint(0, 2 if vehicle_type == 'train' else 4)}" + stops[stop_id]["waiting_vehicles"].append(vehicle_id) + + return { + "buses": buses, + "trains": trains, + "stops": stops + } diff --git a/oasis/transportation/sumo/sumo_llm.py b/oasis/transportation/sumo/sumo_llm.py new file mode 100644 index 00000000..78a29cbb --- /dev/null +++ b/oasis/transportation/sumo/sumo_llm.py @@ -0,0 +1,1185 @@ +import os +import json +import random +import requests +import traci +import subprocess +from typing import List, Dict, Any, Optional, Tuple +import xml.etree.ElementTree as ET +import tempfile +import shutil +import sumo_agent +from sumo_env import SUMOEnvironment +def modify_routes_file(original_route_file: str, output_route_file: str, + route_adjustments: Dict[str, Dict[str, Any]]): + """Modify a SUMO route file based on LLM suggestions, including multimodal options + + Args: + original_route_file: Path to the original route XML file + output_route_file: Path to write the modified route file + route_adjustments: Dictionary with vehicle IDs and route adjustments + """ + try: + # Parse the original route file + tree = ET.parse(original_route_file) + root = tree.getroot() + + # Track park and ride activities for multimodal journeys + park_and_ride_stops = {} + + # Process each vehicle element + for vehicle in root.findall(".//vehicle"): + vehicle_id = vehicle.get("id") + + if vehicle_id in route_adjustments: + adjustments = route_adjustments[vehicle_id] + + # Find the route element + route_elem = vehicle.find("route") + if route_elem is not None: + # Get current edges + edges = route_elem.get("edges", "").split() + + # Apply standard route adjustments + for adjustment in adjustments.get("route_adjustments", []): + edge_to_avoid = adjustment.get("edge_to_avoid") + alternative_edge = adjustment.get("alternative_edge") + + if edge_to_avoid in edges and alternative_edge is not None: + # Replace the edge to avoid with the alternative + index = edges.index(edge_to_avoid) + edges[index] = alternative_edge + + # Handle multimodal journey if recommended + multimodal = adjustments.get("multimodal_strategy", {}) + if multimodal.get("use_multimodal", False): + # Process transitions between modes + for transition in multimodal.get("transitions", []): + from_mode = transition.get("from_mode") + to_mode = transition.get("to_mode") + location = transition.get("at_location") + + # Find matching public transit recommendations + for pt_rec in adjustments.get("public_transit_recommendations", []): + if pt_rec.get("type") == to_mode and pt_rec.get("board_at_stop") == location: + # Record park and ride location + park_and_ride_stops[vehicle_id] = { + "stop_id": location, + "vehicle_id": vehicle_id, + "pt_type": to_mode, + "pt_id": pt_rec.get("id"), + "board_at": pt_rec.get("board_at_stop"), + "alight_at": pt_rec.get("alight_at_stop") + } + + # Modify route to end at the park and ride location + # In a real implementation, we'd look up the edge ID for the stop + # For now, just truncate the route at a reasonable point + if len(edges) > 3: + # Keep route up to about halfway through (simulating driving to P+R) + truncate_point = len(edges) // 2 + edges = edges[:truncate_point] + + # Update route with the modified edges + route_elem.set("edges", " ".join(edges)) + + # Create public transit trips for vehicles that switch to public transport + if park_and_ride_stops: + # In a real implementation, we would: + # 1. Add person definitions for each driver who leaves their vehicle + # 2. Add walk legs to connect from the parking spot to transit stop + # 3. Add public transit trips using the specific bus/train IDs + # 4. Add walk legs to destination + + print(f"Multimodal journeys planned for {len(park_and_ride_stops)} vehicles") + for vehicle_id, pr_data in park_and_ride_stops.items(): + print(f" - Vehicle {vehicle_id} will switch to {pr_data['pt_type']} at {pr_data['board_at']}") + + # Create a person element for the driver + person_id = f"person_{vehicle_id}" + person_elem = ET.SubElement(root, "person", id=person_id) + + # Add a plan element + plan_elem = ET.SubElement(person_elem, "plan") + + # Add the initial drive leg (handled by the vehicle route adjustment above) + + # Add activity for parking + ET.SubElement(plan_elem, "stop", + location=pr_data["board_at"], + actType="parking") + + # Add a walk leg to the transit stop + ET.SubElement(plan_elem, "walk", + from_=pr_data["board_at"], + to=pr_data["board_at"], + duration="60") # 60 seconds walking time + + # Add wait for transit + ET.SubElement(plan_elem, "stop", + location=pr_data["board_at"], + actType="waiting") + + # Add the public transit leg + ET.SubElement(plan_elem, "ride", + from_=pr_data["board_at"], + to=pr_data["alight_at"], + lines=pr_data["pt_id"]) + + # Add final walk leg to destination + ET.SubElement(plan_elem, "walk", + from_=pr_data["alight_at"], + to="destination", # In real implementation, use actual destination + duration="120") # 120 seconds walking time + + # Write modified XML to output file + tree.write(output_route_file) + print(f"Modified routes written to {output_route_file}") + + except Exception as e: + print(f"Error modifying routes file: {e}") + + # On failure, copy the original file + shutil.copy(original_route_file, output_route_file) + print(f"Copied original routes to {output_route_file}") + + +def run_simulation(network_file: str, route_file: str, config_file: str, + output_dir: str, sumo_binary: str, openai_api_key: str, + num_iterations: int, additional_files: List[str] = None): + """Run the simulation for multiple iterations + + Args: + network_file: Path to network XML file + route_file: Path to route XML file + config_file: Path to SUMO config file + output_dir: Directory to store output files + sumo_binary: Path to SUMO or SUMO-GUI binary + openai_api_key: OpenAI API key for LLM (can be empty) + num_iterations: Number of iterations to run + additional_files: List of additional files (e.g., public transit schedules) + """ + # Initialize environment + env = SUMOEnvironment(network_file, route_file, config_file, output_dir, additional_files) + + # Initial route file + current_route_file = route_file + + # Run simulation iterations + for i in range(num_iterations): + print(f"\nIteration {i+1}/{num_iterations}") + + # Run SUMO and get network state + network_state = env.run_iteration(sumo_binary) + + # Only create LLM agents after the first iteration when we have vehicle data + if i > 0 or env.vehicles: + # Create LLM agents for vehicles seen in the simulation + agents = [] + for vehicle_id in env.vehicles: + agents.append(sumo_agent.LLMAgent(vehicle_id, env, openai_api_key)) + + print(f"Created {len(agents)} LLM agents") + + # Update vehicle routes based on network state using LLM + route_adjustments = {} + for agent in agents: + adjustment = agent.update_route(network_state) + if adjustment: + route_adjustments[agent.vehicle_id] = adjustment + + # Create updated route file for the next iteration + next_route_file = os.path.join(output_dir, f"updated_routes_{i}.xml") + modify_routes_file(current_route_file, next_route_file, route_adjustments) + + # Use the new route file for the next iteration + current_route_file = next_route_file + + print(f"Simulation completed after {num_iterations} iterations") + + +class TrafficSimulator: + """Traffic simulator with public transit action space""" + + def __init__(self, sumo_environment: SUMOEnvironment): + """Initialize the traffic simulator + + Args: + sumo_environment: SUMOEnvironment instance for underlying simulation + """ + self.env = sumo_environment + self.agents = {} # Dict to store agent states + self.bus_stops = {} # Dict to store bus stop info + self.train_stops = {} # Dict to store train stop info + self.buses = {} # Dict to store bus info + self.trains = {} # Dict to store train info + + # Initialize transit infrastructure + self._initialize_transit_infrastructure() + + def _initialize_transit_infrastructure(self): + """Initialize bus and train stops from SUMO environment""" + # Extract bus stops from public transit data + if self.env.public_transit.get("stops"): + for stop_id, stop_data in self.env.public_transit["stops"].items(): + if stop_data.get("type") == "bus": + self.bus_stops[stop_id] = { + "id": stop_id, + "position": stop_data.get("position"), + "capacity": stop_data.get("capacity", 10), + "waiting_agents": [], + "served_by": stop_data.get("served_by", []) + } + elif stop_data.get("type") == "train": + self.train_stops[stop_id] = { + "id": stop_id, + "position": stop_data.get("position"), + "capacity": stop_data.get("capacity", 50), + "waiting_agents": [], + "served_by": stop_data.get("served_by", []) + } + + # Extract bus and train info + if self.env.public_transit.get("buses"): + self.buses = self.env.public_transit["buses"].copy() + if self.env.public_transit.get("trains"): + self.trains = self.env.public_transit["trains"].copy() + + def get_onto_bus(self, agent_id: str, bus_stop_id: str) -> Dict[str, Any]: + """Agent gets onto bus at specified stop + + This function simulates an agent boarding a bus at a specific bus stop. + It performs comprehensive validation, capacity checking, and state management. + + Step-by-step process: + 1. Validate that the requested bus stop exists in the network + 2. Initialize agent state if this is a new agent + 3. Find all buses currently at the stop that have available capacity + 4. Use SUMO TraCI (if available) to get real-time capacity data + 5. Select the best bus (most available space) for boarding + 6. Update passenger lists and agent state + 7. Remove agent from waiting lists if applicable + 8. Return detailed result with capacity information + + Args: + agent_id: Unique identifier for the agent attempting to board + bus_stop_id: Unique identifier for the bus stop location + + Returns: + Dictionary with action result, success status, and detailed information: + - success: Boolean indicating if boarding was successful + - error: Error message if boarding failed + - bus_id: ID of the boarded bus (if successful) + - capacity_info: Real-time capacity details + - wait_time: Estimated wait time if no bus available + """ + try: + # STEP 1: Validate bus stop existence + # Check if the requested bus stop exists in our transit network + if bus_stop_id not in self.bus_stops: + return { + "success": False, + "error": f"Bus stop {bus_stop_id} does not exist", + "agent_id": agent_id, + "action": "get_onto_bus" + } + + # STEP 2: Initialize agent state if needed + # Create agent record if this is their first action in the system + if agent_id not in self.agents: + self.agents[agent_id] = { + "current_location": None, + "mode": "walking", # Default mode is walking + "vehicle_id": None, + "destination": None + } + + # STEP 3: Find available buses at the stop + # Search for buses that are: + # - Currently at the requested stop + # - In "at_stop" status (not departing) + # - Have available capacity for more passengers + available_buses = [] + for bus_id, bus_data in self.buses.items(): + if (bus_data.get("current_stop") == bus_stop_id and + bus_data.get("status") == "at_stop"): + + # STEP 4: Check capacity using SUMO TraCI if simulation is running + if self.env.sim_running: + try: + # Use real-time SUMO data for accurate capacity info + capacity = traci.vehicle.getPersonCapacity(bus_id) + current_passengers = traci.vehicle.getPersonNumber(bus_id) + if current_passengers < capacity: + available_buses.append({ + "id": bus_id, + "capacity": capacity, + "current_passengers": current_passengers, + "available_space": capacity - current_passengers + }) + except traci.exceptions.TraCIException: + # STEP 4a: Fallback to simulated data if TraCI fails + capacity = bus_data.get("capacity", 30) + current_passengers = len(bus_data.get("passengers", [])) + if current_passengers < capacity: + available_buses.append({ + "id": bus_id, + "capacity": capacity, + "current_passengers": current_passengers, + "available_space": capacity - current_passengers + }) + else: + # STEP 4b: Use simulated data when SUMO is not running + capacity = bus_data.get("capacity", 30) + current_passengers = len(bus_data.get("passengers", [])) + if current_passengers < capacity: + available_buses.append({ + "id": bus_id, + "capacity": capacity, + "current_passengers": current_passengers, + "available_space": capacity - current_passengers + }) + + # STEP 5: Handle case when no buses have available capacity + if not available_buses: + # Check if buses exist but are at capacity vs no buses at all + buses_at_stop = [] + for bus_id, bus_data in self.buses.items(): + if (bus_data.get("current_stop") == bus_stop_id and + bus_data.get("status") == "at_stop"): + buses_at_stop.append(bus_id) + + if buses_at_stop: + # Buses exist but are full - agent must wait for space or next bus + return { + "success": False, + "error": f"All buses at stop {bus_stop_id} are at capacity", + "agent_id": agent_id, + "action": "get_onto_bus", + "wait_time": random.randint(30, 300), # Wait for next bus or space + "buses_at_capacity": buses_at_stop + } + else: + # No buses at the stop at all - agent must wait for arrival + return { + "success": False, + "error": f"No available bus at stop {bus_stop_id}", + "agent_id": agent_id, + "action": "get_onto_bus", + "wait_time": random.randint(30, 300) # Estimated wait time in seconds + } + + # STEP 6: Select the best bus for boarding + # Choose the bus with the most available space to optimize passenger distribution + best_bus = max(available_buses, key=lambda x: x["available_space"]) + bus_id = best_bus["id"] + + # STEP 7: Add passenger to bus and update tracking + if self.env.sim_running: + try: + # In SUMO, passengers are managed through person simulation + # For now, we track manually and sync with SUMO state + if "passengers" not in self.buses[bus_id]: + self.buses[bus_id]["passengers"] = [] + self.buses[bus_id]["passengers"].append(agent_id) + except traci.exceptions.TraCIException as e: + print(f"Warning: Could not sync passenger data with SUMO: {e}") + # Continue with manual tracking even if SUMO sync fails + if "passengers" not in self.buses[bus_id]: + self.buses[bus_id]["passengers"] = [] + self.buses[bus_id]["passengers"].append(agent_id) + else: + # Manual tracking when SUMO is not running + if "passengers" not in self.buses[bus_id]: + self.buses[bus_id]["passengers"] = [] + self.buses[bus_id]["passengers"].append(agent_id) + + # STEP 8: Update agent state to reflect boarding + self.agents[agent_id].update({ + "current_location": bus_stop_id, + "mode": "bus", # Agent is now on a bus + "vehicle_id": bus_id, # Track which specific bus + "boarded_at": bus_stop_id # Remember where they got on + }) + + # STEP 9: Clean up waiting lists + # Remove agent from bus stop waiting list if they were waiting + if agent_id in self.bus_stops[bus_stop_id]["waiting_agents"]: + self.bus_stops[bus_stop_id]["waiting_agents"].remove(agent_id) + + # STEP 10: Return success response with detailed information + return { + "success": True, + "agent_id": agent_id, + "action": "get_onto_bus", + "bus_stop_id": bus_stop_id, + "bus_id": bus_id, + "bus_route": self.buses[bus_id].get("route", []), + "next_stops": self.buses[bus_id].get("upcoming_stops", []), + "capacity_info": { + "total_capacity": best_bus["capacity"], + "current_passengers": best_bus["current_passengers"] + 1, # +1 for this agent + "remaining_space": best_bus["available_space"] - 1 + } + } + + except Exception as e: + # Handle any unexpected errors gracefully + return { + "success": False, + "error": f"Error boarding bus: {str(e)}", + "agent_id": agent_id, + "action": "get_onto_bus" + } + + def get_off_bus(self, agent_id: str, bus_stop_id: str) -> Dict[str, Any]: + """Agent gets off bus at specified stop + + This function simulates an agent alighting (getting off) a bus at a specific stop. + It performs validation to ensure the agent is on a bus and the bus is at the correct stop. + + Step-by-step process: + 1. Validate that the agent exists and is currently on a bus + 2. Verify the bus stop exists in the network + 3. Check that the agent's current bus is actually at the requested stop + 4. Remove the agent from the bus passenger list + 5. Update agent state to reflect they are now walking + 6. Optionally add agent to stop waiting list if they plan to transfer + 7. Return detailed result with updated agent status + + Args: + agent_id: Unique identifier for the agent attempting to alight + bus_stop_id: Unique identifier for the bus stop where agent wants to get off + + Returns: + Dictionary with action result, success status, and detailed information: + - success: Boolean indicating if alighting was successful + - error: Error message if alighting failed + - previous_bus_id: ID of the bus the agent was on + - new_location: Updated location after alighting + - new_mode: Updated mode after alighting + - transfer_options: Available transit options at this stop + """ + try: + # STEP 1: Validate agent exists and is on a bus + # Check if agent exists in our system + if agent_id not in self.agents: + return { + "success": False, + "error": f"Agent {agent_id} does not exist", + "agent_id": agent_id, + "action": "get_off_bus" + } + + agent = self.agents[agent_id] + + # Verify agent is currently on a bus (not walking or on other transport) + if agent.get("mode") != "bus": + return { + "success": False, + "error": f"Agent {agent_id} is not currently on a bus (mode: {agent.get('mode')})", + "agent_id": agent_id, + "action": "get_off_bus" + } + + # Verify agent has a valid bus ID + bus_id = agent.get("vehicle_id") + if not bus_id: + return { + "success": False, + "error": f"Agent {agent_id} does not have a valid bus ID", + "agent_id": agent_id, + "action": "get_off_bus" + } + + # STEP 2: Validate bus stop exists + if bus_stop_id not in self.bus_stops: + return { + "success": False, + "error": f"Bus stop {bus_stop_id} does not exist", + "agent_id": agent_id, + "action": "get_off_bus" + } + + # STEP 3: Verify the bus is actually at the requested stop + # Check if the bus exists in our system + if bus_id not in self.buses: + return { + "success": False, + "error": f"Bus {bus_id} not found in system", + "agent_id": agent_id, + "action": "get_off_bus" + } + + bus = self.buses[bus_id] + + # Verify the bus is currently at the stop where agent wants to get off + if bus.get("current_stop") != bus_stop_id: + return { + "success": False, + "error": f"Bus {bus_id} is not at stop {bus_stop_id} (currently at: {bus.get('current_stop')})", + "agent_id": agent_id, + "action": "get_off_bus", + "bus_current_stop": bus.get("current_stop") + } + + # Verify the bus is in a state where passengers can alight + if bus.get("status") != "at_stop": + return { + "success": False, + "error": f"Bus {bus_id} is not stopped at {bus_stop_id} (status: {bus.get('status')})", + "agent_id": agent_id, + "action": "get_off_bus" + } + + # STEP 4: Remove agent from bus passenger list + # Initialize passengers list if it doesn't exist + if "passengers" not in bus: + bus["passengers"] = [] + + # Check if agent is actually on the passenger list + if agent_id not in bus["passengers"]: + return { + "success": False, + "error": f"Agent {agent_id} is not listed as passenger on bus {bus_id}", + "agent_id": agent_id, + "action": "get_off_bus" + } + + # Remove agent from bus passenger list + bus["passengers"].remove(agent_id) + + # Sync with SUMO if simulation is running + if self.env.sim_running: + try: + # In SUMO, passenger alighting is managed through person simulation + # For now, we track manually and would sync with SUMO state + current_passengers = traci.vehicle.getPersonNumber(bus_id) + # Note: In full SUMO integration, we would use person commands here + except traci.exceptions.TraCIException as e: + print(f"Warning: Could not sync passenger data with SUMO: {e}") + # Continue with manual tracking even if SUMO sync fails + + # STEP 5: Update agent state to reflect alighting + previous_bus_id = agent["vehicle_id"] + boarded_at = agent.get("boarded_at") + + self.agents[agent_id].update({ + "current_location": bus_stop_id, + "mode": "walking", # Agent is now walking + "vehicle_id": None, # No longer on any vehicle + "previous_bus": previous_bus_id, # Track for history/analytics + "alighted_at": bus_stop_id # Remember where they got off + }) + + # STEP 6: Handle potential transfers + # Get available transfer options at this stop + transfer_options = { + "buses": [], + "trains": [] + } + + # Find other buses at this stop + for other_bus_id, other_bus_data in self.buses.items(): + if (other_bus_id != bus_id and # Don't include the bus they just got off + other_bus_data.get("current_stop") == bus_stop_id and + other_bus_data.get("status") == "at_stop"): + + # Check capacity for potential boarding + capacity = other_bus_data.get("capacity", 30) + current_passengers = len(other_bus_data.get("passengers", [])) + if current_passengers < capacity: + transfer_options["buses"].append({ + "bus_id": other_bus_id, + "route": other_bus_data.get("route", []), + "available_space": capacity - current_passengers + }) + + # Find trains at nearby stations (if this stop connects to rail) + stop_info = self.bus_stops[bus_stop_id] + if stop_info.get("connects_to_rail"): + # Logic for finding connected train stations would go here + # For now, simplified approach + for train_stop_id, train_stop_data in self.train_stops.items(): + if train_stop_data.get("connects_to_bus_stop") == bus_stop_id: + for train_id, train_data in self.trains.items(): + if (train_data.get("current_stop") == train_stop_id and + train_data.get("status") == "at_stop"): + + capacity = train_data.get("capacity", 200) + current_passengers = len(train_data.get("passengers", [])) + if current_passengers < capacity: + transfer_options["trains"].append({ + "train_id": train_id, + "station_id": train_stop_id, + "route": train_data.get("route", []), + "available_space": capacity - current_passengers + }) + + # STEP 7: Return success response with detailed information + return { + "success": True, + "agent_id": agent_id, + "action": "get_off_bus", + "bus_stop_id": bus_stop_id, + "previous_bus_id": previous_bus_id, + "boarded_at": boarded_at, + "new_location": bus_stop_id, + "new_mode": "walking", + "transfer_options": transfer_options, + "journey_segment": { + "from": boarded_at, + "to": bus_stop_id, + "vehicle": previous_bus_id, + "mode": "bus" + } + } + + except Exception as e: + # Handle any unexpected errors gracefully + return { + "success": False, + "error": f"Error alighting from bus: {str(e)}", + "agent_id": agent_id, + "action": "get_off_bus" + } + + def get_onto_train(self, agent_id: str, train_stop_id: str) -> Dict[str, Any]: + """Agent gets onto train at specified stop + + This function simulates an agent boarding a train at a specific train station. + It performs comprehensive validation, capacity checking, and state management. + Trains typically have higher capacity than buses and longer boarding times. + + Step-by-step process: + 1. Validate that the requested train station exists in the network + 2. Initialize agent state if this is a new agent + 3. Find all trains currently at the station that have available capacity + 4. Use SUMO TraCI (if available) to get real-time capacity data + 5. Select the best train (most available space) for boarding + 6. Update passenger lists and agent state + 7. Remove agent from waiting lists if applicable + 8. Return detailed result with capacity and route information + + Args: + agent_id: Unique identifier for the agent attempting to board + train_stop_id: Unique identifier for the train station location + + Returns: + Dictionary with action result, success status, and detailed information: + - success: Boolean indicating if boarding was successful + - error: Error message if boarding failed + - train_id: ID of the boarded train (if successful) + - capacity_info: Real-time capacity details + - wait_time: Estimated wait time if no train available + - route_info: Train route and upcoming stations + """ + try: + # STEP 1: Validate train station existence + # Check if the requested train station exists in our transit network + if train_stop_id not in self.train_stops: + return { + "success": False, + "error": f"Train stop {train_stop_id} does not exist", + "agent_id": agent_id, + "action": "get_onto_train" + } + + # STEP 2: Initialize agent state if needed + # Create agent record if this is their first action in the system + if agent_id not in self.agents: + self.agents[agent_id] = { + "current_location": None, + "mode": "walking", # Default mode is walking + "vehicle_id": None, + "destination": None + } + + # STEP 3: Find available trains at the station + # Search for trains that are: + # - Currently at the requested station + # - In "at_stop" status (not departing) + # - Have available capacity for more passengers + available_trains = [] + for train_id, train_data in self.trains.items(): + if (train_data.get("current_stop") == train_stop_id and + train_data.get("status") == "at_stop"): + + # STEP 4: Check capacity using SUMO TraCI if simulation is running + if self.env.sim_running: + try: + # Use real-time SUMO data for accurate capacity info + capacity = traci.vehicle.getPersonCapacity(train_id) + current_passengers = traci.vehicle.getPersonNumber(train_id) + if current_passengers < capacity: + available_trains.append({ + "id": train_id, + "capacity": capacity, + "current_passengers": current_passengers, + "available_space": capacity - current_passengers + }) + except traci.exceptions.TraCIException: + # STEP 4a: Fallback to simulated data if TraCI fails + capacity = train_data.get("capacity", 200) + current_passengers = len(train_data.get("passengers", [])) + if current_passengers < capacity: + available_trains.append({ + "id": train_id, + "capacity": capacity, + "current_passengers": current_passengers, + "available_space": capacity - current_passengers + }) + else: + # STEP 4b: Use simulated data when SUMO is not running + capacity = train_data.get("capacity", 200) + current_passengers = len(train_data.get("passengers", [])) + if current_passengers < capacity: + available_trains.append({ + "id": train_id, + "capacity": capacity, + "current_passengers": current_passengers, + "available_space": capacity - current_passengers + }) + + # STEP 5: Handle case when no trains have available capacity + if not available_trains: + # Check if trains exist but are at capacity vs no trains at all + trains_at_station = [] + for train_id, train_data in self.trains.items(): + if (train_data.get("current_stop") == train_stop_id and + train_data.get("status") == "at_stop"): + trains_at_station.append(train_id) + + if trains_at_station: + # Trains exist but are full - agent must wait for space or next train + return { + "success": False, + "error": f"All trains at station {train_stop_id} are at capacity", + "agent_id": agent_id, + "action": "get_onto_train", + "wait_time": random.randint(60, 600), # Trains have longer intervals + "trains_at_capacity": trains_at_station + } + else: + # No trains at the station at all - agent must wait for arrival + return { + "success": False, + "error": f"No available train at station {train_stop_id}", + "agent_id": agent_id, + "action": "get_onto_train", + "wait_time": random.randint(60, 600) # Estimated wait time in seconds + } + + # STEP 6: Select the best train for boarding + # Choose the train with the most available space to optimize passenger distribution + best_train = max(available_trains, key=lambda x: x["available_space"]) + train_id = best_train["id"] + + # STEP 7: Add passenger to train and update tracking + if self.env.sim_running: + try: + # In SUMO, passengers are managed through person simulation + # For now, we track manually and sync with SUMO state + if "passengers" not in self.trains[train_id]: + self.trains[train_id]["passengers"] = [] + self.trains[train_id]["passengers"].append(agent_id) + except traci.exceptions.TraCIException as e: + print(f"Warning: Could not sync passenger data with SUMO: {e}") + # Continue with manual tracking even if SUMO sync fails + if "passengers" not in self.trains[train_id]: + self.trains[train_id]["passengers"] = [] + self.trains[train_id]["passengers"].append(agent_id) + else: + # Manual tracking when SUMO is not running + if "passengers" not in self.trains[train_id]: + self.trains[train_id]["passengers"] = [] + self.trains[train_id]["passengers"].append(agent_id) + + # STEP 8: Update agent state to reflect boarding + self.agents[agent_id].update({ + "current_location": train_stop_id, + "mode": "train", # Agent is now on a train + "vehicle_id": train_id, # Track which specific train + "boarded_at": train_stop_id # Remember where they got on + }) + + # STEP 9: Clean up waiting lists + # Remove agent from train station waiting list if they were waiting + if agent_id in self.train_stops[train_stop_id]["waiting_agents"]: + self.train_stops[train_stop_id]["waiting_agents"].remove(agent_id) + + # STEP 10: Return success response with detailed information + return { + "success": True, + "agent_id": agent_id, + "action": "get_onto_train", + "train_stop_id": train_stop_id, + "train_id": train_id, + "train_route": self.trains[train_id].get("route", []), + "next_stops": self.trains[train_id].get("upcoming_stops", []), + "capacity_info": { + "total_capacity": best_train["capacity"], + "current_passengers": best_train["current_passengers"] + 1, # +1 for this agent + "remaining_space": best_train["available_space"] - 1 + }, + "travel_info": { + "vehicle_type": "train", + "boarding_time": "30-60 seconds", # Trains typically take longer to board + "frequency": "5-15 minutes" # Train frequency is usually lower than buses + } + } + + except Exception as e: + # Handle any unexpected errors gracefully + return { + "success": False, + "error": f"Error boarding train: {str(e)}", + "agent_id": agent_id, + "action": "get_onto_train" + } + + def get_off_train(self, agent_id: str, train_stop_id: str) -> Dict[str, Any]: + """Agent gets off train at specified stop + + This function simulates an agent alighting (getting off) a train at a specific station. + It performs validation to ensure the agent is on a train and the train is at the correct station. + Trains typically have longer boarding/alighting times and serve longer distance routes. + + Step-by-step process: + 1. Validate that the agent exists and is currently on a train + 2. Verify the train station exists in the network + 3. Check that the agent's current train is actually at the requested station + 4. Remove the agent from the train passenger list + 5. Update agent state to reflect they are now walking + 6. Handle potential transfers to buses or other trains + 7. Return detailed result with journey information and transfer options + + Args: + agent_id: Unique identifier for the agent attempting to alight + train_stop_id: Unique identifier for the train station where agent wants to get off + + Returns: + Dictionary with action result, success status, and detailed information: + - success: Boolean indicating if alighting was successful + - error: Error message if alighting failed + - previous_train_id: ID of the train the agent was on + - new_location: Updated location after alighting + - transfer_options: Available transit options at this station + - journey_segment: Details about the completed journey segment + """ + try: + # STEP 1: Validate agent exists and is on a train + # Check if agent exists in our system + if agent_id not in self.agents: + return { + "success": False, + "error": f"Agent {agent_id} does not exist", + "agent_id": agent_id, + "action": "get_off_train" + } + + agent = self.agents[agent_id] + + # Verify agent is currently on a train (not walking or on other transport) + if agent.get("mode") != "train": + return { + "success": False, + "error": f"Agent {agent_id} is not currently on a train (mode: {agent.get('mode')})", + "agent_id": agent_id, + "action": "get_off_train" + } + + # Verify agent has a valid train ID + train_id = agent.get("vehicle_id") + if not train_id: + return { + "success": False, + "error": f"Agent {agent_id} does not have a valid train ID", + "agent_id": agent_id, + "action": "get_off_train" + } + + # STEP 2: Validate train station exists + if train_stop_id not in self.train_stops: + return { + "success": False, + "error": f"Train station {train_stop_id} does not exist", + "agent_id": agent_id, + "action": "get_off_train" + } + + # STEP 3: Verify the train is actually at the requested station + # Check if the train exists in our system + if train_id not in self.trains: + return { + "success": False, + "error": f"Train {train_id} not found in system", + "agent_id": agent_id, + "action": "get_off_train" + } + + train = self.trains[train_id] + + # Verify the train is currently at the station where agent wants to get off + if train.get("current_stop") != train_stop_id: + return { + "success": False, + "error": f"Train {train_id} is not at station {train_stop_id} (currently at: {train.get('current_stop')})", + "agent_id": agent_id, + "action": "get_off_train", + "train_current_stop": train.get("current_stop") + } + + # Verify the train is in a state where passengers can alight + if train.get("status") != "at_stop": + return { + "success": False, + "error": f"Train {train_id} is not stopped at {train_stop_id} (status: {train.get('status')})", + "agent_id": agent_id, + "action": "get_off_train" + } + + # STEP 4: Remove agent from train passenger list + # Initialize passengers list if it doesn't exist + if "passengers" not in train: + train["passengers"] = [] + + # Check if agent is actually on the passenger list + if agent_id not in train["passengers"]: + return { + "success": False, + "error": f"Agent {agent_id} is not listed as passenger on train {train_id}", + "agent_id": agent_id, + "action": "get_off_train" + } + + # Remove agent from train passenger list + train["passengers"].remove(agent_id) + + # Sync with SUMO if simulation is running + if self.env.sim_running: + try: + # In SUMO, passenger alighting is managed through person simulation + # For now, we track manually and would sync with SUMO state + current_passengers = traci.vehicle.getPersonNumber(train_id) + # Note: In full SUMO integration, we would use person commands here + except traci.exceptions.TraCIException as e: + print(f"Warning: Could not sync passenger data with SUMO: {e}") + # Continue with manual tracking even if SUMO sync fails + + # STEP 5: Update agent state to reflect alighting + previous_train_id = agent["vehicle_id"] + boarded_at = agent.get("boarded_at") + + self.agents[agent_id].update({ + "current_location": train_stop_id, + "mode": "walking", # Agent is now walking + "vehicle_id": None, # No longer on any vehicle + "previous_train": previous_train_id, # Track for history/analytics + "alighted_at": train_stop_id # Remember where they got off + }) + + # STEP 6: Handle potential transfers and connections + # Get available transfer options at this station + transfer_options = { + "trains": [], + "buses": [], + "connections": [] + } + + # Find other trains at this station + for other_train_id, other_train_data in self.trains.items(): + if (other_train_id != train_id and # Don't include the train they just got off + other_train_data.get("current_stop") == train_stop_id and + other_train_data.get("status") == "at_stop"): + + # Check capacity for potential boarding + capacity = other_train_data.get("capacity", 200) + current_passengers = len(other_train_data.get("passengers", [])) + if current_passengers < capacity: + transfer_options["trains"].append({ + "train_id": other_train_id, + "route": other_train_data.get("route", []), + "line": other_train_data.get("line", "Unknown"), + "available_space": capacity - current_passengers, + "direction": other_train_data.get("direction", "Unknown") + }) + + # Find buses at connected bus stops + station_info = self.train_stops[train_stop_id] + if station_info.get("connects_to_bus"): + # Logic for finding connected bus stops + connected_bus_stops = station_info.get("connected_bus_stops", []) + for bus_stop_id in connected_bus_stops: + if bus_stop_id in self.bus_stops: + for bus_id, bus_data in self.buses.items(): + if (bus_data.get("current_stop") == bus_stop_id and + bus_data.get("status") == "at_stop"): + + capacity = bus_data.get("capacity", 30) + current_passengers = len(bus_data.get("passengers", [])) + if current_passengers < capacity: + transfer_options["buses"].append({ + "bus_id": bus_id, + "bus_stop_id": bus_stop_id, + "route": bus_data.get("route", []), + "available_space": capacity - current_passengers, + "walking_distance": "2-5 minutes" # Typical station to bus stop distance + }) + + # Add information about station connections and facilities + transfer_options["connections"] = { + "walking_paths": station_info.get("walking_connections", []), + "facilities": station_info.get("facilities", []), + "accessibility": station_info.get("accessibility", {}), + "platform_info": station_info.get("platforms", {}) + } + + # STEP 7: Return success response with detailed information + return { + "success": True, + "agent_id": agent_id, + "action": "get_off_train", + "train_stop_id": train_stop_id, + "previous_train_id": previous_train_id, + "boarded_at": boarded_at, + "new_location": train_stop_id, + "new_mode": "walking", + "transfer_options": transfer_options, + "journey_segment": { + "from": boarded_at, + "to": train_stop_id, + "vehicle": previous_train_id, + "mode": "train", + "vehicle_type": "rail_transport" + }, + "station_info": { + "station_name": station_info.get("name", train_stop_id), + "zone": station_info.get("zone", "Unknown"), + "services": station_info.get("services", []), + "next_departure_estimate": random.randint(300, 900) # 5-15 minutes typical + } + } + + except Exception as e: + # Handle any unexpected errors gracefully + return { + "success": False, + "error": f"Error alighting from train: {str(e)}", + "agent_id": agent_id, + "action": "get_off_train" + } + + def get_agent_status(self, agent_id: str) -> Dict[str, Any]: + """Get current status of an agent + + Args: + agent_id: ID of the agent + + Returns: + Dictionary with agent status information + """ + if agent_id not in self.agents: + return { + "exists": False, + "agent_id": agent_id + } + + agent = self.agents[agent_id] + status = { + "exists": True, + "agent_id": agent_id, + "current_location": agent.get("current_location"), + "mode": agent.get("mode"), + "vehicle_id": agent.get("vehicle_id"), + "destination": agent.get("destination") + } + + # Add vehicle-specific information + if agent.get("mode") == "bus" and agent.get("vehicle_id"): + bus_id = agent["vehicle_id"] + if bus_id in self.buses: + status["vehicle_info"] = { + "route": self.buses[bus_id].get("route", []), + "next_stops": self.buses[bus_id].get("upcoming_stops", []), + "passenger_count": len(self.buses[bus_id].get("passengers", [])) + } + elif agent.get("mode") == "train" and agent.get("vehicle_id"): + train_id = agent["vehicle_id"] + if train_id in self.trains: + status["vehicle_info"] = { + "route": self.trains[train_id].get("route", []), + "next_stops": self.trains[train_id].get("upcoming_stops", []), + "passenger_count": len(self.trains[train_id].get("passengers", [])) + } + + return status + + def get_available_stops(self) -> Dict[str, Any]: + """Get information about all available stops + + Returns: + Dictionary with bus and train stop information + """ + return { + "bus_stops": {stop_id: { + "id": stop_data["id"], + "position": stop_data["position"], + "waiting_agents": len(stop_data["waiting_agents"]), + "served_by": stop_data["served_by"] + } for stop_id, stop_data in self.bus_stops.items()}, + "train_stops": {stop_id: { + "id": stop_data["id"], + "position": stop_data["position"], + "waiting_agents": len(stop_data["waiting_agents"]), + "served_by": stop_data["served_by"] + } for stop_id, stop_data in self.train_stops.items()} + } + + def update_simulation_state(self, network_state: Dict[str, Any]): + """Update simulator state based on SUMO network state + + Args: + network_state: Network state from SUMO environment + """ + # Update public transit vehicles positions and schedules + if "public_transit" in network_state: + transit_data = network_state["public_transit"] + + # Update bus positions + if "buses" in transit_data: + for bus_id, bus_data in transit_data["buses"].items(): + if bus_id in self.buses: + self.buses[bus_id].update(bus_data) + + # Update train positions + if "trains" in transit_data: + for train_id, train_data in transit_data["trains"].items(): + if train_id in self.trains: + self.trains[train_id].update(train_data) + + +if __name__ == "__main__": + # Example usage with the test files we've created + network_file = "example_network.net.xml" + route_file = "example_routes.rou.xml" + config_file = "example.sumocfg" + output_dir = "output" + + # Update this path to point to your SUMO binary + # Use sumo-gui for visualization or sumo for headless simulation + # If SUMO is installed properly, you can just use the command name + sumo_binary = "sumo" # or "sumo-gui" for visualization + + # Replace with your actual OpenAI API key (or leave empty) + openai_api_key = "" # Optional if not using LLM features + + # Additional files for public transit + additional_files = ["bus_schedule.add.xml"] + + # Create output directory if it doesn't exist + os.makedirs(output_dir, exist_ok=True) + + # Run simulation for 3 iterations (reduced for faster testing) + run_simulation(network_file, route_file, config_file, + output_dir, sumo_binary, openai_api_key, num_iterations=3, additional_files=additional_files) diff --git a/oasis/transportation/sumo/traffic_simulator_demo.py b/oasis/transportation/sumo/traffic_simulator_demo.py new file mode 100644 index 00000000..f3b3abd4 --- /dev/null +++ b/oasis/transportation/sumo/traffic_simulator_demo.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +""" +Demo script for the TrafficSimulator with public transit action space +""" + +import os +import sys +import json +from sumo_llm import SUMOEnvironment, TrafficSimulator + +def create_sample_environment(): + """Create a sample SUMO environment with mock data for demonstration""" + # Create a mock SUMO environment + env = SUMOEnvironment( + network_file="mock_network.net.xml", + route_file="mock_routes.rou.xml", + config_file="mock.sumocfg", + output_dir="demo_output" + ) + + # Add some sample public transit data + env.public_transit = { + "stops": { + "bus_stop_1": { + "type": "bus", + "position": {"x": 100, "y": 200}, + "capacity": 15, + "served_by": ["bus_route_1", "bus_route_2"] + }, + "bus_stop_2": { + "type": "bus", + "position": {"x": 300, "y": 200}, + "capacity": 12, + "served_by": ["bus_route_1"] + }, + "train_stop_1": { + "type": "train", + "position": {"x": 150, "y": 400}, + "capacity": 100, + "served_by": ["train_line_red", "train_line_blue"] + }, + "train_stop_2": { + "type": "train", + "position": {"x": 500, "y": 400}, + "capacity": 80, + "served_by": ["train_line_red"] + } + }, + "buses": { + "bus_001": { + "route": ["bus_stop_1", "bus_stop_2", "bus_stop_3"], + "current_stop": "bus_stop_1", + "status": "at_stop", + "capacity": 30, + "passengers": [], + "upcoming_stops": ["bus_stop_2", "bus_stop_3"] + }, + "bus_002": { + "route": ["bus_stop_2", "bus_stop_1"], + "current_stop": "bus_stop_2", + "status": "at_stop", + "capacity": 25, + "passengers": [], + "upcoming_stops": ["bus_stop_1"] + } + }, + "trains": { + "train_red_01": { + "route": ["train_stop_1", "train_stop_2", "train_stop_3"], + "current_stop": "train_stop_1", + "status": "at_stop", + "capacity": 200, + "passengers": [], + "upcoming_stops": ["train_stop_2", "train_stop_3"] + }, + "train_blue_01": { + "route": ["train_stop_1", "train_stop_4", "train_stop_5"], + "current_stop": "train_stop_1", + "status": "at_stop", + "capacity": 180, + "passengers": [], + "upcoming_stops": ["train_stop_4", "train_stop_5"] + } + } + } + + return env + +def demonstrate_traffic_simulator(): + """Demonstrate the TrafficSimulator functionality""" + print("šŸšŒšŸš‚ Traffic Simulator Demo šŸš‚šŸšŒ") + print("=" * 50) + + # Create sample environment and simulator + env = create_sample_environment() + simulator = TrafficSimulator(env) + + print("\nšŸ“ Available Stops:") + stops = simulator.get_available_stops() + print(f"Bus stops: {list(stops['bus_stops'].keys())}") + print(f"Train stops: {list(stops['train_stops'].keys())}") + + # Test scenario: Agent travels using public transit + agent_id = "agent_alice" + + print(f"\nšŸ‘¤ Agent '{agent_id}' starts journey") + + # 1. Agent gets onto bus + print("\nšŸšŒ Action 1: Getting onto bus at bus_stop_1") + result = simulator.get_onto_bus(agent_id, "bus_stop_1") + print(f"Result: {json.dumps(result, indent=2)}") + + # Check agent status + status = simulator.get_agent_status(agent_id) + print(f"\nAgent status: {json.dumps(status, indent=2)}") + + # 2. Agent gets off bus + print("\nšŸšŒ Action 2: Getting off bus at bus_stop_2") + # First, simulate bus moving to bus_stop_2 + simulator.buses["bus_001"]["current_stop"] = "bus_stop_2" + + result = simulator.get_off_bus(agent_id, "bus_stop_2") + print(f"Result: {json.dumps(result, indent=2)}") + + # 3. Agent gets onto train + print("\nšŸš‚ Action 3: Getting onto train at train_stop_1") + result = simulator.get_onto_train(agent_id, "train_stop_1") + print(f"Result: {json.dumps(result, indent=2)}") + + # Check agent status again + status = simulator.get_agent_status(agent_id) + print(f"\nAgent status: {json.dumps(status, indent=2)}") + + # 4. Agent gets off train + print("\nšŸš‚ Action 4: Getting off train at train_stop_2") + # Simulate train moving to train_stop_2 + simulator.trains["train_red_01"]["current_stop"] = "train_stop_2" + + result = simulator.get_off_train(agent_id, "train_stop_2") + print(f"Result: {json.dumps(result, indent=2)}") + + # Final status + status = simulator.get_agent_status(agent_id) + print(f"\nFinal agent status: {json.dumps(status, indent=2)}") + + # Test error scenarios + print("\nāŒ Testing Error Scenarios:") + + # Try to board non-existent bus + print("\n1. Trying to board at non-existent stop:") + result = simulator.get_onto_bus("agent_bob", "non_existent_stop") + print(f"Result: {result['error']}") + + # Try to get off when not on vehicle + print("\n2. Trying to get off bus when not on bus:") + result = simulator.get_off_bus("agent_bob", "bus_stop_1") + print(f"Result: {result['error']}") + + # Try to board when no vehicle available + print("\n3. Trying to board when no bus available:") + # Make bus unavailable + simulator.buses["bus_001"]["status"] = "en_route" + result = simulator.get_onto_bus("agent_charlie", "bus_stop_1") + print(f"Result: {result['error']}") + print(f"Estimated wait time: {result.get('wait_time', 'N/A')} seconds") + + print("\nāœ… Demo completed!") + +def test_multiple_agents(): + """Test multiple agents using the system simultaneously""" + print("\nšŸ‘„ Multi-Agent Test") + print("-" * 30) + + env = create_sample_environment() + simulator = TrafficSimulator(env) + + agents = ["agent_1", "agent_2", "agent_3"] + + # All agents try to board the same bus + print("Multiple agents boarding bus_001:") + for agent in agents: + result = simulator.get_onto_bus(agent, "bus_stop_1") + print(f"{agent}: {'Success' if result['success'] else result['error']}") + + # Check passenger count + bus_passengers = simulator.buses["bus_001"]["passengers"] + print(f"\nBus passengers: {bus_passengers}") + print(f"Total passengers on bus: {len(bus_passengers)}") + +if __name__ == "__main__": + try: + demonstrate_traffic_simulator() + test_multiple_agents() + except Exception as e: + print(f"Error running demo: {e}") + import traceback + traceback.print_exc()