Update app.py

app.py

@@ -192,29 +192,81 @@ class GradioInterface:
         self.rag_system = RAGSystem()
         self.preview_manager = PreviewManager()
 
-    # ... (other GradioInterface methods remain largely the same,  but you may want to improve error handling) ...
+    def _extract_components(self, code: str) -> List[str]:
+        """Extract components from the code."""
+        # This logic should analyze the code and extract components.
+        # For example, you might look for function definitions, classes, etc.
+        components = []
+        # Simple regex to find function definitions
+        function_matches = re.findall(r'def (\w+)', code)
+        components.extend(function_matches)
+
+        # Simple regex to find class definitions
+        class_matches = re.findall(r'class (\w+)', code)
+        components.extend(class_matches)
+
+        # You can add more sophisticated logic here as needed
+        return components
+
+    def _get_template_choices(self) -> List[str]:
+        """Get available template choices."""
+        return list(self.template_manager.templates.keys())
 
-    def _save_as_template(self, code: str, name: str, description: str) -> Tuple[List[str], str]:
-        """Save current code as template and add to database"""
+    def launch(self, **kwargs):
+        with gr.Blocks() as interface:
+            gr.Markdown("## Code Generation Interface")
+            description_input = gr.Textbox(label="Description", placeholder="Enter a description for the code you want to generate.")
+            code_output = gr.Textbox(label="Generated Code", interactive=False)
+            generate_button = gr.Button("Generate Code")
+            template_choice = gr.Dropdown(label="Select Template", choices=self._get_template_choices(), value=None)
+            save_button = gr.Button("Save as Template")
+
+            # Generate code button action
+            generate_button.click(
+                fn=self.generate_code,
+                inputs=description_input,
+                outputs=code_output
+            )
+
+            # Save template button action
+            save_button.click(
+                fn=self.save_template,
+                inputs=[code_output, template_choice, description_input],
+                outputs=code_output
+            )
+
+            # Additional UI elements can be added here
+            gr.Markdown("### Preview")
+            preview_output = gr.Textbox(label="Preview", interactive=False)
+            self.preview_manager.update_preview(code_output)  # Update preview with generated code
+
+            # Update preview when code is generated
+            generate_button.click(
+                fn=lambda code: self.preview_manager.update_preview(code),
+                inputs=code_output,
+                outputs=preview_output
+            )
+
+        interface.launch(**kwargs)
+
+    def generate_code(self, description: str) -> str:
+        """Generate code based on the description."""
+        template_code = ""  # Placeholder for template code
+        return self.rag_system.generate_code(description, template_code)
+
+    def save_template(self, code: str, name: str, description: str) -> str:
+        """Save the generated code as a template."""
         try:
             components = self._extract_components(code)
             template = Template(code=code, description=description, components=components)
             if self.template_manager.save_template(name, template):
-              self.rag_system.add_to_database(code) #add code to the database
-              return self._get_template_choices(), f"✅ Template saved as {name}"
+                self.rag_system.add_to_database(code)  # Add code to the database
+                return f"✅ Template '{name}' saved successfully."
             else:
-                raise Exception("Failed to save template")
+                return "❌ Failed to save template."
         except Exception as e:
-            error_msg = f"❌ Error saving template: {str(e)}"
-            logger.error(error_msg)
-            return self._get_template_choices(), error_msg
-
-
-    def launch(self, **kwargs):
-        with gr.Blocks() as interface:
-            # ... (Interface remains largely the same) ...
-
-        interface.launch(**kwargs)
+            logger.error(f"Error saving template: {e}")
+            return f"❌ Error saving template: {str(e)}"
 
 
 def main():