notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from src.inference.gemini import ChatGemini\n",
    "from src.inference.ollama import ChatOllama\n",
    "from src.message import SystemMessage,HumanMessage\n",
    "from dotenv import load_dotenv\n",
    "import os\n",
    "\n",
    "load_dotenv()\n",
    "api_key=os.getenv('GOOGLE_API_KEY')\n",
    "llm=ChatGemini(model='gemini-2.0-flash-exp',api_key=api_key,temperature=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# llm=ChatOllama(model='deepseek-r1:8b',temperature=0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "plan_prompt='''\n",
    "Generate the comprehensive plan for developing the software application according to the  user's desired specifications. \n",
    "Your primary objective is to understand the app's logic, purpose, and it's functionality, then create a detailed plan for implementing it.\n",
    "\n",
    "## Instructions\n",
    "- Be clear, concise, and avoid ambiguity in your explanations.\n",
    "- Don't include anything about testing or deployment of the app, in the plan.\n",
    "- Use a modular and scalable design, ensuring the app can be expanded or modified easily.\n",
    "- For now make the plan for making python based apps.\n",
    "- Don't include code in the plan.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel,Field\n",
    "\n",
    "class Plan(BaseModel):\n",
    "    title:str=Field(...,description='The name of the app to develop',example=['Calculator'])\n",
    "    overview:str=Field(...,description='A high-level description of the app',example=['A simple calculator for basic arithmetic operations.'])\n",
    "    requirements:str=Field(...,description='The user requirements of the app',example=['I want to be able to add, subtract, multiply, and divide two numbers.'])\n",
    "    logic:str=Field(...,description='The logic about the working of the app',example=['Supports addition, subtraction, multiplication, and division.'])\n",
    "    libraries:list[str]=Field(description='The python libraries needed for implementing the app',example=[['streamlit','numpy','pandas']],default_factory=[])\n",
    "    plan:list[str]=Field(...,description='The plan for developing the app',example=['Design the user interface. Develop the backend logic.'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"title\": \"Tic Tac Toe\",\n",
      "  \"overview\": \"A classic two-player game of Tic Tac Toe.\",\n",
      "  \"requirements\": \"The game should allow two players to take turns marking spaces on a 3x3 grid. The first player to get three of their marks in a row (horizontally, vertically, or diagonally) wins. If all spaces are filled and no player has won, the game is a draw.\",\n",
      "  \"logic\": \"The game uses a 3x3 grid represented as a list of lists. Players take turns inputting their moves. The game checks for a win after each move. If no win is detected and the board is full, the game is a draw.\",\n",
      "  \"libraries\": [\n",
      "    \"tkinter\"\n",
      "  ],\n",
      "  \"plan\": [\n",
      "    \"Set up the game board using tkinter.\",\n",
      "    \"Create a function to handle player moves.\",\n",
      "    \"Implement a function to check for a win.\",\n",
      "    \"Implement a function to check for a draw.\",\n",
      "    \"Create a main game loop to handle turns and game state.\",\n",
      "    \"Add a reset button to start a new game.\"\n",
      "  ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "response=llm.invoke([SystemMessage(plan_prompt),HumanMessage('Create a tic tac toe')],model=Plan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"title\": \"Tic Tac Toe\",\n",
      "  \"overview\": \"A classic two-player game of Tic Tac Toe.\",\n",
      "  \"requirements\": \"The game should allow two players to take turns marking spaces on a 3x3 grid. The first player to get three of their marks in a row (horizontally, vertically, or diagonally) wins. If all spaces are filled and no player has won, the game is a draw.\",\n",
      "  \"logic\": \"The game uses a 3x3 grid represented as a list of lists. Players take turns inputting their moves. The game checks for a win after each move. If no win is detected and the board is full, the game is a draw.\",\n",
      "  \"libraries\": [\n",
      "    \"tkinter\"\n",
      "  ],\n",
      "  \"plan\": [\n",
      "    \"Set up the game board using tkinter.\",\n",
      "    \"Create a function to handle player moves.\",\n",
      "    \"Implement a function to check for a win.\",\n",
      "    \"Implement a function to check for a draw.\",\n",
      "    \"Create a main game loop to handle turns and game state.\",\n",
      "    \"Add a reset button to start a new game.\"\n",
      "  ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "print(response.model_dump_json(indent=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "plan_template=f'''\n",
    "# {response.title}\n",
    "\n",
    "{response.overview}\n",
    "\n",
    "## Requirements\n",
    "\n",
    "{response.requirements}\n",
    "\n",
    "## Logic\n",
    "\n",
    "{response.logic}\n",
    "\n",
    "## Python libraries\n",
    "\n",
    "{'\\n'.join([f'- {library}' for library in response.libraries])}\n",
    "\n",
    "## Plan\n",
    "\n",
    "{'\\n'.join(f'- {step}' for step in response.plan)}\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Markdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "# Tic Tac Toe\n",
       "\n",
       "A classic two-player game of Tic Tac Toe.\n",
       "\n",
       "## Requirements\n",
       "\n",
       "The game should allow two players to take turns marking spaces on a 3x3 grid. The first player to get three of their marks in a row (horizontally, vertically, or diagonally) wins. If all spaces are filled and no player has won, the game is a draw.\n",
       "\n",
       "## Logic\n",
       "\n",
       "The game uses a 3x3 grid represented as a list of lists. Players take turns inputting their moves. The game checks for a win after each move. If no win is detected and the board is full, the game is a draw.\n",
       "\n",
       "## Python libraries\n",
       "\n",
       "- tkinter\n",
       "\n",
       "## Plan\n",
       "\n",
       "- Set up the game board using tkinter.\n",
       "- Create a function to handle player moves.\n",
       "- Implement a function to check for a win.\n",
       "- Implement a function to check for a draw.\n",
       "- Create a main game loop to handle turns and game state.\n",
       "- Add a reset button to start a new game.\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(plan_template)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel,Field\n",
    "\n",
    "\n",
    "class File(BaseModel):\n",
    "    name: str=Field(...,description='The name of the file',example=['main.py','logic.py','snake.py'])\n",
    "    description: str=Field(...,description='A brief explanation of the file’s purpose, its role in the app, and how it contributes to the overall functionality.')\n",
    "    file_path:str=Field(...,description='The path of the file',example=['./app_name/subfolder1/abc.py'])\n",
    "    imports: list[str]=Field(description='The libraries or modules in the app to be imported in the file',example=[['Tool','pandas','Food']],default_factory=[])\n",
    "    classes: list['Class']=Field(description='The classes present in the file',default_factory=[])\n",
    "    variables: list[str]=Field(description='The variables present in the file',examples=[['constant','settings']],default_factory=[])\n",
    "    \n",
    "class Function(BaseModel):\n",
    "    name:str=Field(...,description='The name of the function',examples=['move_snake'])\n",
    "    parameters:list[str]=Field(description='The parameters the of the function',examples=[['snake:Snake','direction:str']],default_factory=[])\n",
    "    description:str=Field(...,description='The purpose of the function in detail',examples=['This function tells the snake to mov'])\n",
    "    return_type:str=Field(description='The return type of the function', examples=['int','list[str]','Move'],default=None)\n",
    "\n",
    "class Class(BaseModel):\n",
    "    name:str=Field(description='The name of the class',examples=['Snake'])\n",
    "    properties:list[str]=Field(description='The properties present in the class',examples=['size','file_size'],default=[])\n",
    "    methods:list[Function]=Field(description='The functions present in the class',default_factory=[])\n",
    "\n",
    "class Folder(BaseModel):\n",
    "    name: str = Field(..., description=\"The name of the folder or the module\", examples=[\"app\"])\n",
    "    files: list[File] = Field(..., description=\"Files directly inside the current folder\")\n",
    "    subfolders: list[\"Folder\"] = Field(..., description=\"It contains further subfolders and files\")\n",
    "\n",
    "    class Config:\n",
    "        # Pydantic needs this for recursive models\n",
    "        arbitrary_types_allowed = True\n",
    "        from_attributes = True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "structure_prompt='''\n",
    "Generate the file structure of the app based upon the plan provided.\n",
    "\n",
    "## Instructions\n",
    "- Ensure the file contents and structure are consistent with modern best practices for software development using python.\n",
    "- Use a modular and scalable design, ensuring the app can be expanded or modified easily.\n",
    "- Each subfolder has their own respective files for implementating that particular logic of the app.\n",
    "- Include `main.py` in the root directory of the app, it is this file the user will run, launch the app.\n",
    "- Adapt the structure and components based on the specific requirements of the app described by the user.\n",
    "- If needed include the requirements.txt file in the root directory.\n",
    "- Each module has its own `__init__.py` file.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"name\": \"tic_tac_toe\",\n",
      "  \"files\": [\n",
      "    {\n",
      "      \"name\": \"main.py\",\n",
      "      \"description\": \"This is the main entry point of the application. It initializes the game and starts the main game loop.\",\n",
      "      \"file_path\": \"./main.py\",\n",
      "      \"imports\": [\n",
      "        \"tkinter\",\n",
      "        \"game\"\n",
      "      ],\n",
      "      \"classes\": [],\n",
      "      \"variables\": []\n",
      "    },\n",
      "    {\n",
      "      \"name\": \"game.py\",\n",
      "      \"description\": \"This file contains the main game logic, including the game board, player moves, win conditions, and draw conditions.\",\n",
      "      \"file_path\": \"./game/game.py\",\n",
      "      \"imports\": [\n",
      "        \"tkinter\",\n",
      "        \"tkinter.messagebox\"\n",
      "      ],\n",
      "      \"classes\": [\n",
      "        {\n",
      "          \"name\": \"TicTacToe\",\n",
      "          \"properties\": [\n",
      "            \"board\",\n",
      "            \"current_player\",\n",
      "            \"buttons\"\n",
      "          ],\n",
      "          \"methods\": [\n",
      "            {\n",
      "              \"name\": \"__init__\",\n",
      "              \"parameters\": [\n",
      "                \"self\",\n",
      "                \"master\"\n",
      "              ],\n",
      "              \"description\": \"Initializes the game board and sets up the GUI.\"\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"create_board\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Creates the game board using tkinter buttons.\"\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"handle_click\",\n",
      "              \"parameters\": [\n",
      "                \"self\",\n",
      "                \"row\",\n",
      "                \"col\"\n",
      "              ],\n",
      "              \"description\": \"Handles a player's move, updates the board, and checks for a win or draw.\"\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"check_win\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Checks if the current player has won the game.\"\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"check_draw\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Checks if the game is a draw.\"\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"reset_board\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Resets the game board for a new game.\"\n",
      "            }\n",
      "          ]\n",
      "        }\n",
      "      ],\n",
      "      \"variables\": []\n",
      "    },\n",
      "    {\n",
      "      \"name\": \"__init__.py\",\n",
      "      \"description\": \"This file makes the game directory a Python package.\",\n",
      "      \"file_path\": \"./game/__init__.py\",\n",
      "      \"imports\": [],\n",
      "      \"classes\": [],\n",
      "      \"variables\": []\n",
      "    },\n",
      "    {\n",
      "      \"name\": \"requirements.txt\",\n",
      "      \"description\": \"This file lists the required Python libraries for the project.\",\n",
      "      \"file_path\": \"./requirements.txt\",\n",
      "      \"imports\": [],\n",
      "      \"classes\": [],\n",
      "      \"variables\": []\n",
      "    }\n",
      "  ],\n",
      "  \"subfolders\": [\n",
      "    {\n",
      "      \"name\": \"game\",\n",
      "      \"files\": [\n",
      "        {\n",
      "          \"name\": \"game.py\",\n",
      "          \"description\": \"This file contains the main game logic, including the game board, player moves, win conditions, and draw conditions.\",\n",
      "          \"file_path\": \"./game/game.py\",\n",
      "          \"imports\": [\n",
      "            \"tkinter\",\n",
      "            \"tkinter.messagebox\"\n",
      "          ],\n",
      "          \"classes\": [\n",
      "            {\n",
      "              \"name\": \"TicTacToe\",\n",
      "              \"properties\": [\n",
      "                \"board\",\n",
      "                \"current_player\",\n",
      "                \"buttons\"\n",
      "              ],\n",
      "              \"methods\": [\n",
      "                {\n",
      "                  \"name\": \"__init__\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\",\n",
      "                    \"master\"\n",
      "                  ],\n",
      "                  \"description\": \"Initializes the game board and sets up the GUI.\"\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"create_board\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Creates the game board using tkinter buttons.\"\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"handle_click\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\",\n",
      "                    \"row\",\n",
      "                    \"col\"\n",
      "                  ],\n",
      "                  \"description\": \"Handles a player's move, updates the board, and checks for a win or draw.\"\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"check_win\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Checks if the current player has won the game.\"\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"check_draw\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Checks if the game is a draw.\"\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"reset_board\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Resets the game board for a new game.\"\n",
      "                }\n",
      "              ]\n",
      "            }\n",
      "          ],\n",
      "          \"variables\": []\n",
      "        },\n",
      "        {\n",
      "          \"name\": \"__init__.py\",\n",
      "          \"description\": \"This file makes the game directory a Python package.\",\n",
      "          \"file_path\": \"./game/__init__.py\",\n",
      "          \"imports\": [],\n",
      "          \"classes\": [],\n",
      "          \"variables\": []\n",
      "        }\n",
      "      ],\n",
      "      \"subfolders\": []\n",
      "    }\n",
      "  ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "response=llm.invoke([SystemMessage(structure_prompt),HumanMessage(plan_template)],model=Folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"name\": \"tic_tac_toe\",\n",
      "  \"files\": [\n",
      "    {\n",
      "      \"name\": \"main.py\",\n",
      "      \"description\": \"This is the main entry point of the application. It initializes the game and starts the main game loop.\",\n",
      "      \"file_path\": \"./main.py\",\n",
      "      \"imports\": [\n",
      "        \"tkinter\",\n",
      "        \"game\"\n",
      "      ],\n",
      "      \"classes\": [],\n",
      "      \"variables\": []\n",
      "    },\n",
      "    {\n",
      "      \"name\": \"game.py\",\n",
      "      \"description\": \"This file contains the main game logic, including the game board, player moves, win conditions, and draw conditions.\",\n",
      "      \"file_path\": \"./game/game.py\",\n",
      "      \"imports\": [\n",
      "        \"tkinter\",\n",
      "        \"tkinter.messagebox\"\n",
      "      ],\n",
      "      \"classes\": [\n",
      "        {\n",
      "          \"name\": \"TicTacToe\",\n",
      "          \"properties\": [\n",
      "            \"board\",\n",
      "            \"current_player\",\n",
      "            \"buttons\"\n",
      "          ],\n",
      "          \"methods\": [\n",
      "            {\n",
      "              \"name\": \"__init__\",\n",
      "              \"parameters\": [\n",
      "                \"self\",\n",
      "                \"master\"\n",
      "              ],\n",
      "              \"description\": \"Initializes the game board and sets up the GUI.\",\n",
      "              \"return_type\": null\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"create_board\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Creates the game board using tkinter buttons.\",\n",
      "              \"return_type\": null\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"handle_click\",\n",
      "              \"parameters\": [\n",
      "                \"self\",\n",
      "                \"row\",\n",
      "                \"col\"\n",
      "              ],\n",
      "              \"description\": \"Handles a player's move, updates the board, and checks for a win or draw.\",\n",
      "              \"return_type\": null\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"check_win\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Checks if the current player has won the game.\",\n",
      "              \"return_type\": null\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"check_draw\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Checks if the game is a draw.\",\n",
      "              \"return_type\": null\n",
      "            },\n",
      "            {\n",
      "              \"name\": \"reset_board\",\n",
      "              \"parameters\": [\n",
      "                \"self\"\n",
      "              ],\n",
      "              \"description\": \"Resets the game board for a new game.\",\n",
      "              \"return_type\": null\n",
      "            }\n",
      "          ]\n",
      "        }\n",
      "      ],\n",
      "      \"variables\": []\n",
      "    },\n",
      "    {\n",
      "      \"name\": \"__init__.py\",\n",
      "      \"description\": \"This file makes the game directory a Python package.\",\n",
      "      \"file_path\": \"./game/__init__.py\",\n",
      "      \"imports\": [],\n",
      "      \"classes\": [],\n",
      "      \"variables\": []\n",
      "    },\n",
      "    {\n",
      "      \"name\": \"requirements.txt\",\n",
      "      \"description\": \"This file lists the required Python libraries for the project.\",\n",
      "      \"file_path\": \"./requirements.txt\",\n",
      "      \"imports\": [],\n",
      "      \"classes\": [],\n",
      "      \"variables\": []\n",
      "    }\n",
      "  ],\n",
      "  \"subfolders\": [\n",
      "    {\n",
      "      \"name\": \"game\",\n",
      "      \"files\": [\n",
      "        {\n",
      "          \"name\": \"game.py\",\n",
      "          \"description\": \"This file contains the main game logic, including the game board, player moves, win conditions, and draw conditions.\",\n",
      "          \"file_path\": \"./game/game.py\",\n",
      "          \"imports\": [\n",
      "            \"tkinter\",\n",
      "            \"tkinter.messagebox\"\n",
      "          ],\n",
      "          \"classes\": [\n",
      "            {\n",
      "              \"name\": \"TicTacToe\",\n",
      "              \"properties\": [\n",
      "                \"board\",\n",
      "                \"current_player\",\n",
      "                \"buttons\"\n",
      "              ],\n",
      "              \"methods\": [\n",
      "                {\n",
      "                  \"name\": \"__init__\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\",\n",
      "                    \"master\"\n",
      "                  ],\n",
      "                  \"description\": \"Initializes the game board and sets up the GUI.\",\n",
      "                  \"return_type\": null\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"create_board\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Creates the game board using tkinter buttons.\",\n",
      "                  \"return_type\": null\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"handle_click\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\",\n",
      "                    \"row\",\n",
      "                    \"col\"\n",
      "                  ],\n",
      "                  \"description\": \"Handles a player's move, updates the board, and checks for a win or draw.\",\n",
      "                  \"return_type\": null\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"check_win\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Checks if the current player has won the game.\",\n",
      "                  \"return_type\": null\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"check_draw\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Checks if the game is a draw.\",\n",
      "                  \"return_type\": null\n",
      "                },\n",
      "                {\n",
      "                  \"name\": \"reset_board\",\n",
      "                  \"parameters\": [\n",
      "                    \"self\"\n",
      "                  ],\n",
      "                  \"description\": \"Resets the game board for a new game.\",\n",
      "                  \"return_type\": null\n",
      "                }\n",
      "              ]\n",
      "            }\n",
      "          ],\n",
      "          \"variables\": []\n",
      "        },\n",
      "        {\n",
      "          \"name\": \"__init__.py\",\n",
      "          \"description\": \"This file makes the game directory a Python package.\",\n",
      "          \"file_path\": \"./game/__init__.py\",\n",
      "          \"imports\": [],\n",
      "          \"classes\": [],\n",
      "          \"variables\": []\n",
      "        }\n",
      "      ],\n",
      "      \"subfolders\": []\n",
      "    }\n",
      "  ]\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "print(response.model_dump_json(indent=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel,Field\n",
    "\n",
    "class Script(BaseModel):\n",
    "    file_name: str=Field(...,description='The name of the file',examples=['main.py'])\n",
    "    file_path: str=Field(...,description='The path of the file',examples=['./app_name/main.py'])\n",
    "    code_block: str=Field(...,description='The python script goes here',examples=['''print(\"Hello World\")'''])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "develop_prompt='''\n",
    "Generate the python script for the provided file of the app. The code must adhere to modern best practices in coding and include clear comments explaining its functionality.\n",
    "\n",
    "## Instructions:\n",
    "- Ensure the code is syntactically correct and free of errors.\n",
    "- Include comprehensive comments to explain the purpose of classes, functions, methods.\n",
    "- Handle potential edge cases, input validation, and exceptions where necessary.\n",
    "- Ensure the code is optimized for readability, maintainability, and scalability.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "model=response.files[0]\n",
    "filename=model.name\n",
    "description=model.description\n",
    "imports=model.imports\n",
    "classes=model.classes\n",
    "variables=model.variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_prompt=f'''\n",
    "### Filename: \n",
    "{filename}\n",
    "### Description: \n",
    "{description}\n",
    "Imports in the File: \n",
    "{\"\\n\".join([f'- {import_}' for import_ in imports])}\n",
    "Classes in the File: \n",
    "{\"\\n\".join([f'- {class_}' for class_ in classes])}\n",
    "Variables in the File: \n",
    "{\"\\n\".join([f'- {variable_}' for variable_ in variables])}\n",
    "\n",
    "Write the Python script for this file.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"file_name\": \"main.py\",\n",
      "  \"file_path\": \"./main.py\",\n",
      "  \"code_block\": \"# main.py\\n\\nimport tkinter as tk\\nfrom game import Game  # Assuming game.py contains the Game class\\n\\n\\n# Main function to initialize and run the game\\ndef main():\\n    # Create the main application window\\n    root = tk.Tk()\\n    root.title(\\\"My Awesome Game\\\")  # Set the title of the window\\n\\n    # Initialize the game with the root window\\n    game = Game(root)\\n\\n    # Start the main game loop\\n    root.mainloop()\\n\\n\\n# Entry point of the script\\nif __name__ == \\\"__main__\\\":\\n    main()\\n\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "response=llm.invoke([SystemMessage(develop_prompt),HumanMessage(user_prompt)],model=Script)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "content='''\n",
    "<StructureContent>\n",
    "    <Folder>\n",
    "        <Name type=\"str\">calculator_app</Name>\n",
    "        <Files type=\"list[File]\">\n",
    "            <File>\n",
    "                <Name type=\"str\">main.py</Name>\n",
    "                <Description type=\"str\">The main entry point of the application. It initializes the GUI and starts the event loop.</Description>\n",
    "                <Path type=\"str\">./calculator_app/main.py</Path>\n",
    "                <Imports type=\"list[str]\">\n",
    "                    <ImportItem>tkinter</ImportItem>\n",
    "                    <ImportItem>calculator_app.calculator</ImportItem>\n",
    "                    <ImportItem>calculator_app.gui</ImportItem>\n",
    "                </Imports>\n",
    "                <Classes type=\"list[Class]\"/>\n",
    "                <Variables type=\"list[str]\"/>\n",
    "            </File>\n",
    "            <File>\n",
    "                <Name type=\"str\">requirements.txt</Name>\n",
    "                <Description type=\"str\">Lists the dependencies required to run the application.</Description>\n",
    "                <Path type=\"str\">./calculator_app/requirements.txt</Path>\n",
    "                <Imports type=\"list[str]\"/>\n",
    "                <Classes type=\"list[Class]\"/>\n",
    "                <Variables type=\"list[str]\"/>\n",
    "            </File>\n",
    "        </Files>\n",
    "        <Subfolders type=\"list[Folder]\">\n",
    "            <Folder>\n",
    "                <Name type=\"str\">calculator_app</Name>\n",
    "                <Files type=\"list[File]\">\n",
    "                    <File>\n",
    "                        <Name type=\"str\">__init__.py</Name>\n",
    "                        <Description type=\"str\">Marks the 'calculator_app' directory as a Python package.</Description>\n",
    "                        <Path type=\"str\">./calculator_app/calculator_app/__init__.py</Path>\n",
    "                        <Imports type=\"list[str]\"/>\n",
    "                        <Classes type=\"list[Class]\"/>\n",
    "                        <Variables type=\"list[str]\"/>\n",
    "                    </File>\n",
    "                </Files>\n",
    "                <Subfolders type=\"list[Folder]\">\n",
    "                    <Folder>\n",
    "                        <Name type=\"str\">calculator</Name>\n",
    "                        <Files type=\"list[File]\">\n",
    "                            <File>\n",
    "                                <Name type=\"str\">__init__.py</Name>\n",
    "                                <Description type=\"str\">Marks the 'calculator' directory as a Python package.</Description>\n",
    "                                <Path type=\"str\">./calculator_app/calculator_app/calculator/__init__.py</Path>\n",
    "                                <Imports type=\"list[str]\"/>\n",
    "                                <Classes type=\"list[Class]\"/>\n",
    "                                <Variables type=\"list[str]\"/>\n",
    "                            </File>\n",
    "                            <File>\n",
    "                                <Name type=\"str\">operations.py</Name>\n",
    "                                <Description type=\"str\">Implements the arithmetic operations (addition, subtraction, multiplication, division).</Description>\n",
    "                                <Path type=\"str\">./calculator_app/calculator_app/calculator/operations.py</Path>\n",
    "                                <Imports type=\"list[str]\"/>\n",
    "                                <Classes type=\"list[Class]\"/>\n",
    "                                <Variables type=\"list[str]\"/>\n",
    "                            </File>\n",
    "                            <File>\n",
    "                                <Name type=\"str\">calculator.py</Name>\n",
    "                                <Description type=\"str\">Contains the main calculator logic, handling input and calling the appropriate operations.</Description>\n",
    "                                <Path type=\"str\">./calculator_app/calculator_app/calculator/calculator.py</Path>\n",
    "                                <Imports type=\"list[str]\">\n",
    "                                    <ImportItem>calculator_app.calculator.operations</ImportItem>\n",
    "                                </Imports>\n",
    "                                <Classes type=\"list[Class]\">\n",
    "                                    <Class>\n",
    "                                        <Name type=\"str\">Calculator</Name>\n",
    "                                        <Properties type=\"list[str]\"/>\n",
    "                                        <Methods type=\"list[Method]\">\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">add</Name>\n",
    "                                                <Parameters type=\"list[str]\">\n",
    "                                                    <ParameterItem type=\"str\">x: float</ParameterItem>\n",
    "                                                    <ParameterItem type=\"str\">y: float</ParameterItem>\n",
    "                                                </Parameters>\n",
    "                                                <Description type=\"str\">Adds two numbers.</Description>\n",
    "                                                <ReturnType type=\"str\">float</ReturnType>\n",
    "                                            </Method>\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">subtract</Name>\n",
    "                                                <Parameters type=\"list[str]\">\n",
    "                                                    <ParameterItem type=\"str\">x: float</ParameterItem>\n",
    "                                                    <ParameterItem type=\"str\">y: float</ParameterItem>\n",
    "                                                </Parameters>\n",
    "                                                <Description type=\"str\">Subtracts two numbers.</Description>\n",
    "                                                <ReturnType type=\"str\">float</ReturnType>\n",
    "                                            </Method>\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">multiply</Name>\n",
    "                                                <Parameters type=\"list[str]\">\n",
    "                                                    <ParameterItem type=\"str\">x: float</ParameterItem>\n",
    "                                                    <ParameterItem type=\"str\">y: float</ParameterItem>\n",
    "                                                </Parameters>\n",
    "                                                <Description type=\"str\">Multiplies two numbers.</Description>\n",
    "                                                <ReturnType type=\"str\">float</ReturnType>\n",
    "                                            </Method>\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">divide</Name>\n",
    "                                                <Parameters type=\"list[str]\">\n",
    "                                                    <ParameterItem type=\"str\">x: float</ParameterItem>\n",
    "                                                    <ParameterItem type=\"str\">y: float</ParameterItem>\n",
    "                                                </Parameters>\n",
    "                                                <Description type=\"str\">Divides two numbers, handling division by zero.</Description>\n",
    "                                                <ReturnType type=\"str\">float</ReturnType>\n",
    "                                            </Method>\n",
    "                                        </Methods>\n",
    "                                    </Class>\n",
    "                                </Classes>\n",
    "                                <Variables type=\"list[str]\"/>\n",
    "                            </File>\n",
    "                        </Files>\n",
    "                        <Subfolders type=\"list[Folder]\"/>\n",
    "                    </Folder>\n",
    "                    <Folder>\n",
    "                        <Name type=\"str\">gui</Name>\n",
    "                        <Files type=\"list[File]\">\n",
    "                            <File>\n",
    "                                <Name type=\"str\">__init__.py</Name>\n",
    "                                <Description type=\"str\">Marks the 'gui' directory as a Python package.</Description>\n",
    "                                <Path type=\"str\">./calculator_app/calculator_app/gui/__init__.py</Path>\n",
    "                                <Imports type=\"list[str]\"/>\n",
    "                                <Classes type=\"list[Class]\"/>\n",
    "                                <Variables type=\"list[str]\"/>\n",
    "                            </File>\n",
    "                            <File>\n",
    "                                <Name type=\"str\">calculator_gui.py</Name>\n",
    "                                <Description type=\"str\">Defines the GUI elements and their layout using Tkinter. It also handles user input and displays the results.</Description>\n",
    "                                <Path type=\"str\">./calculator_app/calculator_app/gui/calculator_gui.py</Path>\n",
    "                                <Imports type=\"list[str]\">\n",
    "                                    <ImportItem>tkinter</ImportItem>\n",
    "                                    <ImportItem>calculator_app.calculator.calculator</ImportItem>\n",
    "                                </Imports>\n",
    "                                <Classes type=\"list[Class]\">\n",
    "                                    <Class>\n",
    "                                        <Name type=\"str\">CalculatorGUI</Name>\n",
    "                                        <Properties type=\"list[str]\">\n",
    "                                            <PropertyItem type=\"str\">calculator</PropertyItem>\n",
    "                                            <PropertyItem type=\"str\">root</PropertyItem>\n",
    "                                            <PropertyItem type=\"str\">entry</PropertyItem>\n",
    "                                        </Properties>\n",
    "                                        <Methods type=\"list[Method]\">\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">__init__</Name>\n",
    "                                                <Parameters type=\"list[str]\">\n",
    "                                                    <ParameterItem type=\"str\">root: tk.Tk</ParameterItem>\n",
    "                                                </Parameters>\n",
    "                                                <Description type=\"str\">Initializes the CalculatorGUI with a Tkinter root window.</Description>\n",
    "                                                <ReturnType type=\"str\">None</ReturnType>\n",
    "                                            </Method>\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">create_widgets</Name>\n",
    "                                                <Parameters type=\"list[str]\"/>\n",
    "                                                <Description type=\"str\">Creates and arranges the GUI widgets (buttons, entry field).</Description>\n",
    "                                                <ReturnType type=\"str\">None</ReturnType>\n",
    "                                            </Method>\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">button_click</Name>\n",
    "                                                <Parameters type=\"list[str]\">\n",
    "                                                    <ParameterItem type=\"str\">number: str</ParameterItem>\n",
    "                                                </Parameters>\n",
    "                                                <Description type=\"str\">Handles button clicks, appending the clicked number to the entry field.</Description>\n",
    "                                                <ReturnType type=\"str\">None</ReturnType>\n",
    "                                            </Method>\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">button_clear</Name>\n",
    "                                                <Parameters type=\"list[str]\"/>\n",
    "                                                <Description type=\"str\">Clears the entry field.</Description>\n",
    "                                                <ReturnType type=\"str\">None</ReturnType>\n",
    "                                            </Method>\n",
    "                                            <Method>\n",
    "                                                <Name type=\"str\">button_equal</Name>\n",
    "                                                <Parameters type=\"list[str]\"/>\n",
    "                                                <Description type=\"str\">Evaluates the expression in the entry field and displays the result.</Description>\n",
    "                                                <ReturnType type=\"str\">None</ReturnType>\n",
    "                                            </Method>\n",
    "                                        </Methods>\n",
    "                                    </Class>\n",
    "                                </Classes>\n",
    "                                <Variables type=\"list[str]\"/>\n",
    "                            </File>\n",
    "                        </Files>\n",
    "                        <Subfolders type=\"list[Folder]\"/>\n",
    "                    </Folder>\n",
    "                </Subfolders>\n",
    "            </Folder>\n",
    "        </Subfolders>\n",
    "    </Folder>\n",
    "</StructureContent>\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel, Field\n",
    "from typing import List, Optional\n",
    "\n",
    "class Method(BaseModel):\n",
    "    name: str\n",
    "    parameters: List[str] = Field(default_factory=list)\n",
    "    description: str\n",
    "    return_type: str\n",
    "\n",
    "class Class(BaseModel):\n",
    "    name: str\n",
    "    properties: List[str] = Field(default_factory=list)\n",
    "    methods: List[Method] = Field(default_factory=list)\n",
    "\n",
    "class File(BaseModel):\n",
    "    name: str\n",
    "    description: str\n",
    "    path: str\n",
    "    imports: List[str] = Field(default_factory=list)\n",
    "    classes: List[Class] = Field(default_factory=list)\n",
    "    variables: List[str] = Field(default_factory=list)\n",
    "\n",
    "class Folder(BaseModel):\n",
    "    name: str\n",
    "    files: List[File] = Field(default_factory=list)\n",
    "    subfolders: List[\"Folder\"] = Field(default_factory=list)\n",
    "\n",
    "    class Config:\n",
    "        arbitrary_types_allowed = True\n",
    "\n",
    "class Structure(BaseModel):\n",
    "    folder: Folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from xml.etree import ElementTree as ET\n",
    "\n",
    "def parse_method(method_element):\n",
    "    \"\"\"Parses a <Method> XML element into a Method Pydantic object.\"\"\"\n",
    "    return Method(\n",
    "        name=method_element.find(\"Name\").text,\n",
    "        parameters=[param.text for param in method_element.findall(\"Parameters/ParameterItem\")],\n",
    "        description=method_element.find(\"Description\").text,\n",
    "        return_type=method_element.find(\"ReturnType\").text\n",
    "    )\n",
    "\n",
    "def parse_class(class_element):\n",
    "    \"\"\"Parses a <Class> XML element into a Class Pydantic object.\"\"\"\n",
    "    return Class(\n",
    "        name=class_element.find(\"Name\").text,\n",
    "        properties=[prop.text for prop in class_element.findall(\"Properties/PropertyItem\")],\n",
    "        methods=[parse_method(method) for method in class_element.findall(\"Methods/Method\")]\n",
    "    )\n",
    "\n",
    "def parse_file(file_element):\n",
    "    \"\"\"Parses a <File> XML element into a File Pydantic object.\"\"\"\n",
    "    return File(\n",
    "        name=file_element.find(\"Name\").text,\n",
    "        description=file_element.find(\"Description\").text,\n",
    "        path=file_element.find(\"Path\").text,\n",
    "        imports=[imp.text for imp in file_element.findall(\"Imports/ImportItem\")],\n",
    "        classes=[parse_class(cls) for cls in file_element.findall(\"Classes/Class\")],\n",
    "        variables=[var.text for var in file_element.findall(\"Variables/VariableItem\")]\n",
    "    )\n",
    "\n",
    "def parse_folder(folder_element):\n",
    "    \"\"\"Parses a <Folder> XML element into a Folder Pydantic object.\"\"\"\n",
    "    return Folder(\n",
    "        name=folder_element.find(\"Name\").text,\n",
    "        files=[parse_file(file) for file in folder_element.findall(\"Files/File\")],\n",
    "        subfolders=[parse_folder(subfolder) for subfolder in folder_element.findall(\"Subfolders/Folder\")]\n",
    "    )\n",
    "\n",
    "def xml_to_pydantic(xml_string):\n",
    "    \"\"\"Converts XML string into a Pydantic Structure object.\"\"\"\n",
    "    root = ET.fromstring(xml_string)\n",
    "    folder = parse_folder(root.find(\"Folder\"))\n",
    "    return Structure(folder=folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"folder\": {\n",
      "    \"name\": \"calculator_app\",\n",
      "    \"files\": [\n",
      "      {\n",
      "        \"name\": \"main.py\",\n",
      "        \"description\": \"The main entry point of the application. It initializes the GUI and starts the event loop.\",\n",
      "        \"path\": \"./calculator_app/main.py\",\n",
      "        \"imports\": [\n",
      "          \"tkinter\",\n",
      "          \"calculator_app.calculator\",\n",
      "          \"calculator_app.gui\"\n",
      "        ],\n",
      "        \"classes\": [],\n",
      "        \"variables\": []\n",
      "      },\n",
      "      {\n",
      "        \"name\": \"requirements.txt\",\n",
      "        \"description\": \"Lists the dependencies required to run the application.\",\n",
      "        \"path\": \"./calculator_app/requirements.txt\",\n",
      "        \"imports\": [],\n",
      "        \"classes\": [],\n",
      "        \"variables\": []\n",
      "      }\n",
      "    ],\n",
      "    \"subfolders\": [\n",
      "      {\n",
      "        \"name\": \"calculator_app\",\n",
      "        \"files\": [\n",
      "          {\n",
      "            \"name\": \"__init__.py\",\n",
      "            \"description\": \"Marks the 'calculator_app' directory as a Python package.\",\n",
      "            \"path\": \"./calculator_app/calculator_app/__init__.py\",\n",
      "            \"imports\": [],\n",
      "            \"classes\": [],\n",
      "            \"variables\": []\n",
      "          }\n",
      "        ],\n",
      "        \"subfolders\": [\n",
      "          {\n",
      "            \"name\": \"calculator\",\n",
      "            \"files\": [\n",
      "              {\n",
      "                \"name\": \"__init__.py\",\n",
      "                \"description\": \"Marks the 'calculator' directory as a Python package.\",\n",
      "                \"path\": \"./calculator_app/calculator_app/calculator/__init__.py\",\n",
      "                \"imports\": [],\n",
      "                \"classes\": [],\n",
      "                \"variables\": []\n",
      "              },\n",
      "              {\n",
      "                \"name\": \"operations.py\",\n",
      "                \"description\": \"Implements the arithmetic operations (addition, subtraction, multiplication, division).\",\n",
      "                \"path\": \"./calculator_app/calculator_app/calculator/operations.py\",\n",
      "                \"imports\": [],\n",
      "                \"classes\": [],\n",
      "                \"variables\": []\n",
      "              },\n",
      "              {\n",
      "                \"name\": \"calculator.py\",\n",
      "                \"description\": \"Contains the main calculator logic, handling input and calling the appropriate operations.\",\n",
      "                \"path\": \"./calculator_app/calculator_app/calculator/calculator.py\",\n",
      "                \"imports\": [\n",
      "                  \"calculator_app.calculator.operations\"\n",
      "                ],\n",
      "                \"classes\": [\n",
      "                  {\n",
      "                    \"name\": \"Calculator\",\n",
      "                    \"properties\": [],\n",
      "                    \"methods\": [\n",
      "                      {\n",
      "                        \"name\": \"add\",\n",
      "                        \"parameters\": [\n",
      "                          \"x: float\",\n",
      "                          \"y: float\"\n",
      "                        ],\n",
      "                        \"description\": \"Adds two numbers.\",\n",
      "                        \"return_type\": \"float\"\n",
      "                      },\n",
      "                      {\n",
      "                        \"name\": \"subtract\",\n",
      "                        \"parameters\": [\n",
      "                          \"x: float\",\n",
      "                          \"y: float\"\n",
      "                        ],\n",
      "                        \"description\": \"Subtracts two numbers.\",\n",
      "                        \"return_type\": \"float\"\n",
      "                      },\n",
      "                      {\n",
      "                        \"name\": \"multiply\",\n",
      "                        \"parameters\": [\n",
      "                          \"x: float\",\n",
      "                          \"y: float\"\n",
      "                        ],\n",
      "                        \"description\": \"Multiplies two numbers.\",\n",
      "                        \"return_type\": \"float\"\n",
      "                      },\n",
      "                      {\n",
      "                        \"name\": \"divide\",\n",
      "                        \"parameters\": [\n",
      "                          \"x: float\",\n",
      "                          \"y: float\"\n",
      "                        ],\n",
      "                        \"description\": \"Divides two numbers, handling division by zero.\",\n",
      "                        \"return_type\": \"float\"\n",
      "                      }\n",
      "                    ]\n",
      "                  }\n",
      "                ],\n",
      "                \"variables\": []\n",
      "              }\n",
      "            ],\n",
      "            \"subfolders\": []\n",
      "          },\n",
      "          {\n",
      "            \"name\": \"gui\",\n",
      "            \"files\": [\n",
      "              {\n",
      "                \"name\": \"__init__.py\",\n",
      "                \"description\": \"Marks the 'gui' directory as a Python package.\",\n",
      "                \"path\": \"./calculator_app/calculator_app/gui/__init__.py\",\n",
      "                \"imports\": [],\n",
      "                \"classes\": [],\n",
      "                \"variables\": []\n",
      "              },\n",
      "              {\n",
      "                \"name\": \"calculator_gui.py\",\n",
      "                \"description\": \"Defines the GUI elements and their layout using Tkinter. It also handles user input and displays the results.\",\n",
      "                \"path\": \"./calculator_app/calculator_app/gui/calculator_gui.py\",\n",
      "                \"imports\": [\n",
      "                  \"tkinter\",\n",
      "                  \"calculator_app.calculator.calculator\"\n",
      "                ],\n",
      "                \"classes\": [\n",
      "                  {\n",
      "                    \"name\": \"CalculatorGUI\",\n",
      "                    \"properties\": [\n",
      "                      \"calculator\",\n",
      "                      \"root\",\n",
      "                      \"entry\"\n",
      "                    ],\n",
      "                    \"methods\": [\n",
      "                      {\n",
      "                        \"name\": \"__init__\",\n",
      "                        \"parameters\": [\n",
      "                          \"root: tk.Tk\"\n",
      "                        ],\n",
      "                        \"description\": \"Initializes the CalculatorGUI with a Tkinter root window.\",\n",
      "                        \"return_type\": \"None\"\n",
      "                      },\n",
      "                      {\n",
      "                        \"name\": \"create_widgets\",\n",
      "                        \"parameters\": [],\n",
      "                        \"description\": \"Creates and arranges the GUI widgets (buttons, entry field).\",\n",
      "                        \"return_type\": \"None\"\n",
      "                      },\n",
      "                      {\n",
      "                        \"name\": \"button_click\",\n",
      "                        \"parameters\": [\n",
      "                          \"number: str\"\n",
      "                        ],\n",
      "                        \"description\": \"Handles button clicks, appending the clicked number to the entry field.\",\n",
      "                        \"return_type\": \"None\"\n",
      "                      },\n",
      "                      {\n",
      "                        \"name\": \"button_clear\",\n",
      "                        \"parameters\": [],\n",
      "                        \"description\": \"Clears the entry field.\",\n",
      "                        \"return_type\": \"None\"\n",
      "                      },\n",
      "                      {\n",
      "                        \"name\": \"button_equal\",\n",
      "                        \"parameters\": [],\n",
      "                        \"description\": \"Evaluates the expression in the entry field and displays the result.\",\n",
      "                        \"return_type\": \"None\"\n",
      "                      }\n",
      "                    ]\n",
      "                  }\n",
      "                ],\n",
      "                \"variables\": []\n",
      "              }\n",
      "            ],\n",
      "            \"subfolders\": []\n",
      "          }\n",
      "        ]\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "print(xml_to_pydantic(content).model_dump_json(indent=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "📂 calculator_app\n",
      "   📄 main.py\n",
      "   📄 requirements.txt\n",
      "   📂 calculator_app\n",
      "      📄 __init__.py\n",
      "      📂 calculator\n",
      "         📄 __init__.py\n",
      "         📄 operations.py\n",
      "         📄 calculator.py\n",
      "      📂 gui\n",
      "         📄 __init__.py\n",
      "         📄 calculator_gui.py\n"
     ]
    }
   ],
   "source": [
    "from src.agent.engineer.structure.utils import show_tree\n",
    "folder_structure = {\n",
    "    \"folder\": {\n",
    "        \"name\": \"calculator_app\",\n",
    "        \"files\": [\n",
    "            {\"name\": \"main.py\"},\n",
    "            {\"name\": \"requirements.txt\"}\n",
    "        ],\n",
    "        \"subfolders\": [\n",
    "            {\n",
    "                \"name\": \"calculator_app\",\n",
    "                \"files\": [\n",
    "                    {\"name\": \"__init__.py\"}\n",
    "                ],\n",
    "                \"subfolders\": [\n",
    "                    {\n",
    "                        \"name\": \"calculator\",\n",
    "                        \"files\": [\n",
    "                            {\"name\": \"__init__.py\"},\n",
    "                            {\"name\": \"operations.py\"},\n",
    "                            {\"name\": \"calculator.py\"}\n",
    "                        ],\n",
    "                        \"subfolders\": []\n",
    "                    },\n",
    "                    {\n",
    "                        \"name\": \"gui\",\n",
    "                        \"files\": [\n",
    "                            {\"name\": \"__init__.py\"},\n",
    "                            {\"name\": \"calculator_gui.py\"}\n",
    "                        ],\n",
    "                        \"subfolders\": []\n",
    "                    }\n",
    "                ]\n",
    "            }\n",
    "        ]\n",
    "    }\n",
    "}\n",
    "\n",
    "# Call the function to display the structure\n",
    "show_tree(folder_structure)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CompletedProcess(args='python ant_colony_visualization/main.py', returncode=0, stdout='pygame 2.6.1 (SDL 2.28.4, Python 3.13.2)\\nHello from the pygame community. https://www.pygame.org/contribute.html\\n', stderr='')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from subprocess import run,PIPE\n",
    "\n",
    "run('python ant_colony_visualization/main.py',text=True,capture_output=True,shell=True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}