Update app.py

app.py

@@ -504,7 +504,6 @@ class TemplateManager:
                 def classify_image(image):
                     if image is None:
                         return {"error": 1.0}
-                    # Add classification logic here
                     return {"class1": 0.8, "class2": 0.2}
 
                 with gr.Blocks(theme=gr.themes.Soft()) as demo:
@@ -515,7 +514,7 @@ class TemplateManager:
                             classify_btn = gr.Button("Classify")
                         with gr.Column():
                             output_labels = gr.Label()
-                    
+
                     classify_btn.click(
                         fn=classify_image,
                         inputs=input_image,
@@ -529,61 +528,939 @@ class TemplateManager:
                 components=["Image", "Button", "Label"],
                 metadata={"category": "computer_vision"}
             ),
-            
-            "text_analyzer": Template(
+            "chatbot": Template(
+                code="""
+                import gradio as gr
+
+                def respond(message, history):
+                    return f"You said: {message}"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# AI Chatbot")
+                    chatbot = gr.Chatbot()
+                    msg = gr.Textbox(label="Message")
+                    clear = gr.Button("Clear")
+
+                    msg.submit(respond, [msg, chatbot], [chatbot])
+                    clear.click(lambda: None, None, chatbot, queue=False)
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Interactive chatbot interface",
+                components=["Chatbot", "Textbox", "Button"],
+                metadata={"category": "nlp"}
+            ),
+            "audio_processor": Template(
                 code="""
                 import gradio as gr
                 import numpy as np
 
-                def analyze_text(text, options):
-                    if not text:
-                        return "Please enter some text"
-                    
-                    results = []
-                    if "word_count" in options:
-                        results.append(f"Word count: {len(text.split())}")
-                    if "char_count" in options:
-                        results.append(f"Character count: {len(text)}")
-                    if "sentiment" in options:
-                        # Add sentiment analysis logic here
-                        results.append("Sentiment: Neutral")
-                    
-                    return "\\n".join(results)
+                def process_audio(audio, volume_factor=1.0):
+                    if audio is None:
+                        return None
+                    sr, data = audio
+                    return (sr, data * volume_factor)
 
                 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-                    gr.Markdown("# Text Analysis Tool")
+                    gr.Markdown("# Audio Processor")
                     with gr.Row():
                         with gr.Column():
-                            input_text = gr.Textbox(
-                                label="Input Text",
-                                placeholder="Enter text to analyze...",
-                                lines=5
-                            )
-                            options = gr.CheckboxGroup(
-                                choices=["word_count", "char_count", "sentiment"],
-                                label="Analysis Options",
-                                value=["word_count"]
+                            input_audio = gr.Audio(source="microphone", type="numpy")
+                            volume = gr.Slider(minimum=0, maximum=2, value=1, label="Volume")
+                            process_btn = gr.Button("Process")
+                        with gr.Column():
+                            output_audio = gr.Audio(type="numpy")
+
+                    process_btn.click(
+                        fn=process_audio,
+                        inputs=[input_audio, volume],
+                        outputs=output_audio
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Audio processing interface",
+                components=["Audio", "Slider", "Button"],
+                metadata={"category": "audio"}
+            ),
+            "file_processor": Template(
+                code="""
+                import gradio as gr
+
+                def process_file(file):
+                    if file is None:
+                        return "No file uploaded"
+                    return f"Processed file: {file.name}"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# File Processor")
+                    with gr.Row():
+                        with gr.Column():
+                            file_input = gr.File(label="Upload File")
+                            process_btn = gr.Button("Process")
+                        with gr.Column():
+                            output = gr.Textbox(label="Results")
+                            json_output = gr.JSON(label="Detailed Results")
+
+                    process_btn.click(
+                        fn=process_file,
+                        inputs=file_input,
+                        outputs=[output, json_output]
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="File processing interface",
+                components=["File", "Button", "Textbox", "JSON"],
+                metadata={"category": "utility"}
+            ),
+            "data_visualization": Template(
+                code="""
+                import gradio as gr
+                import pandas as pd
+                import plotly.express as px
+
+                def visualize_data(data, plot_type):
+                    if data is None:
+                        return None
+
+                    df = pd.read_csv(data.name)
+                    if plot_type == "scatter":
+                        fig = px.scatter(df, x=df.columns[0], y=df.columns[1])
+                    elif plot_type == "line":
+                        fig = px.line(df, x=df.columns[0], y=df.columns[1])
+                    else:
+                        fig = px.bar(df, x=df.columns[0], y=df.columns[1])
+
+                    return fig
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Data Visualizer")
+                    with gr.Row():
+                        with gr.Column():
+                            file_input = gr.File(label="Upload CSV")
+                            plot_type = gr.Radio(
+                                choices=["scatter", "line", "bar"],
+                                label="Plot Type",
+                                value="scatter"
                             )
-                            analyze_btn = gr.Button("Analyze")
+                            visualize_btn = gr.Button("Visualize")
                         with gr.Column():
-                            output_text = gr.Textbox(
-                                label="Analysis Results",
-                                lines=5
+                            plot_output = gr.Plot(label="Visualization")
+
+                    visualize_btn.click(
+                        fn=visualize_data,
+                        inputs=[file_input, plot_type],
+                        outputs=plot_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Data visualization interface",
+                components=["File", "Radio", "Button", "Plot"],
+                metadata={"category": "data_science"}
+            ),
+            "form_builder": Template(
+                code="""
+                import gradio as gr
+                import json
+
+                def submit_form(name, email, age, interests, subscribe):
+                    return json.dumps({
+                        "name": name,
+                        "email": email,
+                        "age": age,
+                        "interests": interests,
+                        "subscribe": subscribe
+                    }, indent=2)
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Form Builder")
+                    with gr.Row():
+                        with gr.Column():
+                            name = gr.Textbox(label="Name")
+                            email = gr.Textbox(label="Email")
+                            age = gr.Number(label="Age")
+                            interests = gr.CheckboxGroup(
+                                choices=["Sports", "Music", "Art", "Technology"],
+                                label="Interests"
                             )
-                    
+                            subscribe = gr.Checkbox(label="Subscribe to newsletter")
+                            submit_btn = gr.Button("Submit")
+                        with gr.Column():
+                            output = gr.JSON(label="Form Data")
+
+                    submit_btn.click(
+                        fn=submit_form,
+                        inputs=[name, email, age, interests, subscribe],
+                        outputs=output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Form builder interface",
+                components=["Textbox", "Number", "CheckboxGroup", "Checkbox", "Button", "JSON"],
+                metadata={"category": "utility"}
+            )
+        }
+        
+        self.component_index = self._build_component_index()
+        self.category_index = self._build_category_index()
+
+    def _build_component_index(self) -> Dict[str, List[str]]:
+        """Build index of templates by component"""
+        index = {}
+        for name, template in self.templates.items():
+            for component in template.components:
+                if component not in index:
+                    index[component] = []
+                index[component].append(name)
+        return index
+
+    def _build_category_index(self) -> Dict[str, List[str]]:
+        """Build index of templates by category"""
+        index = {}
+        for name, template in self.templates.items():
+            category = template.metadata.get("category", "other")
+            if category not in index:
+                index[category] = []
+            index[category].append(name)
+        return index
+
+    def search(self, query: str, limit: int = 5) -> List[Dict]:
+        """Search templates by description or metadata"""
+        try:
+            results = []
+            for name, template in self.templates.items():
+                desc_score = difflib.SequenceMatcher(
+                    None, 
+                    query.lower(), 
+                    template.description.lower()
+                ).ratio()
+
+                category_score = difflib.SequenceMatcher(
+                    None,
+                    query.lower(),
+                    template.metadata.get("category", "").lower()
+                ).ratio()
+
+                comp_score = sum(0.2 for component in template.components if component.lower() in query.lower())
+
+                final_score = max(desc_score, category_score) + comp_score
+
+                results.append({
+                    "name": name,
+                    "template": template,
+                    "score": final_score
+                })
+
+            results.sort(key=lambda x: x["score"], reverse=True)
+            return results[:limit]
+
+        except Exception as e:
+            logger.error(f"Error searching templates: {str(e)}")
+            return []
+
+    def search_by_components(self, components: List[str], limit: int = 5) -> List[Dict]:
+        """Search templates by required components"""
+        try:
+            results = []
+            for name, template in self.templates.items():
+                matches = sum(1 for c in components if c in template.components)
+                if matches > 0:
+                    score = matches / len(components)
+                    results.append({
+                        "name": name,
+                        "template": template,
+                        "score": score
+                    })
+
+            results.sort(key=lambda x: x["score"], reverse=True)
+            return results[:limit]
+
+        except Exception as e:
+            logger.error(f"Error searching by components: {str(e)}")
+            return []
+
+    def search_by_category(self, category: str) -> List[Dict]:
+        """Get all templates in a category"""
+        try:
+            return [
+                {
+                    "name": name,
+                    "template": self.templates[name]
+                }
+                for name in self.category_index.get(category, [])
+            ]
+        except Exception as e:
+            logger.error(f"Error searching by category: {str(e)}")
+            return []
+
+    def get_template(self, name: str) -> Optional[Template]:
+        """Get specific template by name"""
+        return self.templates.get(name)
+
+    def get_categories(self) -> List[str]:
+        """Get list of all categories"""
+        return list(self.category_index.keys())
+
+    def get_components(self) -> List[str]:
+        """Get list of all components"""
+        return list(self.component_index.keys())
+
+    def export_templates(self, path: str):
+        """Export templates to JSON file"""
+        try:
+            data = {
+                name: {
+                    "description": template.description,
+                    "components": template.components,
+                    "metadata": template.metadata,
+                    "example": template.example
+                }
+                for name, template in self.templates.items()
+            }
+
+            with open(path, 'w') as f:
+                json.dump(data, f, indent=2)
+
+            logger.info(f"Templates exported to {path}")
+
+        except Exception as e:
+            logger.error(f"Error exporting templates: {str(e)}")
+            raise
+
+    def import_templates(self, path: str):
+        """Import templates from JSON file"""
+        try:
+            with open(path, 'r') as f:
+                data = json.load(f)
+
+            for name, template_data in data.items():
+                self.templates[name] = Template(
+                    code="",  # Code should be loaded separately
+                    description=template_data["description"],
+                    components=template_data["components"],
+                    metadata=template_data["metadata"],
+                    example=template_data.get("example")
+                )
+
+            # Rebuild indexes
+            self.component_index = self._build_component_index()
+            self.category_index = self._build_category_index()
+
+            logger.info(f"Templates imported from {path}")
+
+        except Exception as e:
+            logger.error(f"Error importing templates: {str(e)}")
+            raise
+
+
+# Usage example:
+if __name__ == "__main__":
+    # Initialize template manager
+    manager = TemplateManager()
+
+    # Search examples
+    print("\nSearching for 'machine learning':")
+    results = manager.search("machine learning")
+    for result in results:
+        print(f"{result['name']}: {result['score']:.2f}")
+
+    print("\nSearching for components ['Image', 'Slider']:")
+    results = manager.search_by_components(['Image', 'Slider'])
+    for result in results:
+        print(f"{result['name']}: {result['score']:.2f}")
+
+    print("\nCategories available:")
+    print(manager.get_categories())
+
+    print("\nComponents available:")
+    print(manager.get_components())
+
+"text_summarizer": Template(
+                code="""
+                import gradio as gr
+                from transformers import pipeline
+
+                summarizer = pipeline("summarization")
+
+                def summarize_text(text):
+                    summary = summarizer(text, max_length=150, min_length=40, do_sample=False)
+                    return summary[0]['summary_text']
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Text Summarizer")
+                    with gr.Row():
+                        with gr.Column():
+                            input_text = gr.Textbox(label="Input Text", lines=10, placeholder="Enter text to summarize...")
+                            summarize_btn = gr.Button("Summarize")
+                        with gr.Column():
+                            summary_output = gr.Textbox(label="Summary", lines=5)
+
+                    summarize_btn.click(
+                        fn=summarize_text,
+                        inputs=input_text,
+                        outputs=summary_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Text summarization interface using a transformer model",
+                components=["Textbox", "Button"],
+                metadata={"category": "nlp"}
+            ),
+
+            "image_captioner": Template(
+                code="""
+                import gradio as gr
+                from transformers import BlipProcessor, BlipForConditionalGeneration
+                from PIL import Image
+
+                processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+                model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+
+                def generate_caption(image):
+                    inputs = processor(image, return_tensors="pt")
+                    out = model.generate(**inputs)
+                    caption = processor.decode(out[0], skip_special_tokens=True)
+                    return caption
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Image Caption Generator")
+                    with gr.Row():
+                        with gr.Column():
+                            input_image = gr.Image(type="pil", label="Upload Image")
+                            caption_btn = gr.Button("Generate Caption")
+                        with gr.Column():
+                            caption_output = gr.Textbox(label="Generated Caption")
+
+                    caption_btn.click(
+                        fn=generate_caption,
+                        inputs=input_image,
+                        outputs=caption_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Image captioning interface using a transformer model",
+                components=["Image", "Button", "Textbox"],
+                metadata={"category": "computer_vision"}
+            ),
+
+            "style_transfer": Template(
+                code="""
+                import gradio as gr
+                import tensorflow as tf
+                import tensorflow_hub as hub
+
+                hub_model = hub.load('https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2')
+
+                def apply_style(content_image, style_image):
+                    content_image = tf.image.convert_image_dtype(content_image, tf.float32)[tf.newaxis, ...]
+                    style_image = tf.image.convert_image_dtype(style_image, tf.float32)[tf.newaxis, ...]
+                    stylized_image = hub_model(content_image, style_image)[0]
+                    return tf.squeeze(stylized_image).numpy()
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Neural Style Transfer")
+                    with gr.Row():
+                        with gr.Column():
+                            content_image = gr.Image(label="Content Image")
+                            style_image = gr.Image(label="Style Image")
+                            transfer_btn = gr.Button("Transfer Style")
+                        with gr.Column():
+                            output_image = gr.Image(label="Stylized Image")
+
+                    transfer_btn.click(
+                        fn=apply_style,
+                        inputs=[content_image, style_image],
+                        outputs=output_image
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Neural style transfer between two images",
+                components=["Image", "Button"],
+                metadata={"category": "computer_vision"}
+            ),
+
+            "sentiment_analysis": Template(
+                code="""
+                import gradio as gr
+                from transformers import pipeline
+
+                sentiment_pipeline = pipeline("sentiment-analysis")
+
+                def analyze_sentiment(text):
+                    result = sentiment_pipeline(text)[0]
+                    return f"{result['label']} ({result['score']:.2f})"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Sentiment Analysis")
+                    with gr.Row():
+                        with gr.Column():
+                            input_text = gr.Textbox(label="Input Text", lines=5, placeholder="Enter text to analyze sentiment...")
+                            analyze_btn = gr.Button("Analyze Sentiment")
+                        with gr.Column():
+                            sentiment_output = gr.Textbox(label="Sentiment Result")
+
                     analyze_btn.click(
-                        fn=analyze_text,
-                        inputs=[input_text, options],
-                        outputs=output_text
+                        fn=analyze_sentiment,
+                        inputs=input_text,
+                        outputs=sentiment_output
                     )
 
                 if __name__ == "__main__":
                     demo.launch()
                 """,
-                description="Text analysis interface with multiple options",
-                components=["Textbox", "CheckboxGroup", "Button"],
+                description="Sentiment analysis using transformer model",
+                components=["Textbox", "Button"],
                 metadata={"category": "nlp"}
+            ),
+
+            "pdf_to_text": Template(
+                code="""
+                import gradio as gr
+                import PyPDF2
+
+                def extract_text_from_pdf(pdf):
+                    reader = PyPDF2.PdfFileReader(pdf)
+                    text = ''
+                    for page_num in range(reader.numPages):
+                        page = reader.getPage(page_num)
+                        text += page.extract_text()
+                    return text
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# PDF to Text Extractor")
+                    with gr.Row():
+                        with gr.Column():
+                            pdf_file = gr.File(label="Upload PDF")
+                            extract_btn = gr.Button("Extract Text")
+                        with gr.Column():
+                            output_text = gr.Textbox(label="Extracted Text", lines=10)
+
+                    extract_btn.click(
+                        fn=extract_text_from_pdf,
+                        inputs=pdf_file,
+                        outputs=output_text
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Extract text from PDF files",
+                components=["File", "Button", "Textbox"],
+                metadata={"category": "utility"}
+            )
+
+"website_monitor": Template(
+                code="""
+                import gradio as gr
+                import requests
+                from datetime import datetime
+
+                def monitor_website(url):
+                    try:
+                        response = requests.get(url)
+                        status_code = response.status_code
+                        status = "Up" if status_code == 200 else "Down"
+                        return {
+                            "url": url,
+                            "status": status,
+                            "response_time": response.elapsed.total_seconds(),
+                            "last_checked": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        }
+                    except Exception as e:
+                        return {"error": str(e)}
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Website Uptime Monitor")
+                    with gr.Row():
+                        with gr.Column():
+                            url_input = gr.Textbox(label="Website URL", placeholder="https://example.com")
+                            check_btn = gr.Button("Check Website")
+                        with gr.Column():
+                            result_output = gr.JSON(label="Monitoring Result")
+
+                    check_btn.click(
+                        fn=monitor_website,
+                        inputs=url_input,
+                        outputs=result_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Monitor the uptime and response time of a website",
+                components=["Textbox", "Button", "JSON"],
+                metadata={"category": "web_monitoring"}
+            ),
+
+            "rss_feed_fetcher": Template(
+                code="""
+                import gradio as gr
+                import feedparser
+
+                def fetch_rss_feed(url):
+                    feed = feedparser.parse(url)
+                    if feed.bozo:
+                        return {"error": "Invalid RSS feed URL"}
+                    
+                    return [{"title": entry.title, "link": entry.link} for entry in feed.entries[:5]]
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# RSS Feed Fetcher")
+                    with gr.Row():
+                        with gr.Column():
+                            feed_url = gr.Textbox(label="RSS Feed URL", placeholder="https://example.com/feed")
+                            fetch_btn = gr.Button("Fetch Latest Posts")
+                        with gr.Column():
+                            feed_output = gr.JSON(label="Latest Feed Entries")
+
+                    fetch_btn.click(
+                        fn=fetch_rss_feed,
+                        inputs=feed_url,
+                        outputs=feed_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Fetch the latest entries from an RSS feed",
+                components=["Textbox", "Button", "JSON"],
+                metadata={"category": "web_scraping"}
+            ),
+
+            "web_scraper": Template(
+                code="""
+                import gradio as gr
+                from bs4 import BeautifulSoup
+                import requests
+
+                def scrape_website(url, tag):
+                    try:
+                        response = requests.get(url)
+                        soup = BeautifulSoup(response.text, "html.parser")
+                        elements = soup.find_all(tag)
+                        return [element.get_text() for element in elements][:5]  # Limit to 5 elements
+                    except Exception as e:
+                        return f"Error: {str(e)}"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Web Scraper")
+                    with gr.Row():
+                        with gr.Column():
+                            url_input = gr.Textbox(label="Website URL", placeholder="https://example.com")
+                            tag_input = gr.Textbox(label="HTML Tag to Scrape", placeholder="h1, p, div, etc.")
+                            scrape_btn = gr.Button("Scrape Website")
+                        with gr.Column():
+                            result_output = gr.JSON(label="Scraped Results")
+
+                    scrape_btn.click(
+                        fn=scrape_website,
+                        inputs=[url_input, tag_input],
+                        outputs=result_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Scrape text from a website based on the specified HTML tag",
+                components=["Textbox", "Button", "JSON"],
+                metadata={"category": "web_scraping"}
+            ),
+
+            "api_tester": Template(
+                code="""
+                import gradio as gr
+                import requests
+
+                def test_api(endpoint, method, payload):
+                    try:
+                        if method == "GET":
+                            response = requests.get(endpoint)
+                        elif method == "POST":
+                            response = requests.post(endpoint, json=payload)
+                        else:
+                            return "Unsupported method"
+
+                        return {
+                            "status_code": response.status_code,
+                            "response_body": response.json() if response.headers.get("Content-Type") == "application/json" else response.text
+                        }
+                    except Exception as e:
+                        return {"error": str(e)}
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# API Tester")
+                    with gr.Row():
+                        with gr.Column():
+                            endpoint = gr.Textbox(label="API Endpoint", placeholder="https://api.example.com/endpoint")
+                            method = gr.Radio(choices=["GET", "POST"], label="HTTP Method", value="GET")
+                            payload = gr.JSON(label="Payload (for POST)", value={})
+                            test_btn = gr.Button("Test API")
+                        with gr.Column():
+                            result_output = gr.JSON(label="API Response")
+
+                    test_btn.click(
+                        fn=test_api,
+                        inputs=[endpoint, method, payload],
+                        outputs=result_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Test API endpoints with GET and POST requests",
+                components=["Textbox", "Radio", "JSON", "Button"],
+                metadata={"category": "api_testing"}
+            ),
+
+            "email_scheduler": Template(
+                code="""
+                import gradio as gr
+                import smtplib
+                from email.mime.text import MIMEText
+                from email.mime.multipart import MIMEMultipart
+                from apscheduler.schedulers.background import BackgroundScheduler
+
+                scheduler = BackgroundScheduler()
+                scheduler.start()
+
+                def send_email(to_email, subject, body):
+                    try:
+                        sender_email = "your_email@example.com"
+                        password = "your_password"
+
+                        msg = MIMEMultipart()
+                        msg['From'] = sender_email
+                        msg['To'] = to_email
+                        msg['Subject'] = subject
+
+                        msg.attach(MIMEText(body, 'plain'))
+
+                        server = smtplib.SMTP('smtp.example.com', 587)
+                        server.starttls()
+                        server.login(sender_email, password)
+                        text = msg.as_string()
+                        server.sendmail(sender_email, to_email, text)
+                        server.quit()
+
+                        return "Email sent successfully"
+                    except Exception as e:
+                        return f"Error: {str(e)}"
+
+                def schedule_email(to_email, subject, body, delay):
+                    scheduler.add_job(send_email, 'interval', seconds=delay, args=[to_email, subject, body])
+                    return f"Email scheduled to be sent in {delay} seconds"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Email Scheduler")
+                    with gr.Row():
+                        with gr.Column():
+                            to_email = gr.Textbox(label="Recipient Email")
+                            subject = gr.Textbox(label="Subject")
+                            body = gr.Textbox(label="Email Body", lines=5)
+                            delay = gr.Slider(label="Delay (seconds)", minimum=10, maximum=300, step=10, value=60)
+                            schedule_btn = gr.Button("Schedule Email")
+                        with gr.Column():
+                            result_output = gr.Textbox(label="Result")
+
+                    schedule_btn.click(
+                        fn=schedule_email,
+                        inputs=[to_email, subject, body, delay],
+                        outputs=result_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Schedule emails to be sent after a delay",
+                components=["Textbox", "Slider", "Button"],
+                metadata={"category": "task_automation"}
             )
+
+"log_file_analyzer": Template(
+                code="""
+                import gradio as gr
+                import re
+
+                def analyze_logs(log_file, filter_text):
+                    try:
+                        logs = log_file.read().decode("utf-8")
+                        if filter_text:
+                            filtered_logs = "\n".join([line for line in logs.splitlines() if re.search(filter_text, line)])
+                        else:
+                            filtered_logs = logs
+                        return filtered_logs
+                    except Exception as e:
+                        return f"Error: {str(e)}"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Log File Analyzer")
+                    with gr.Row():
+                        with gr.Column():
+                            log_input = gr.File(label="Upload Log File")
+                            filter_input = gr.Textbox(label="Filter (Regex)", placeholder="Error|Warning")
+                            analyze_btn = gr.Button("Analyze Logs")
+                        with gr.Column():
+                            output_logs = gr.Textbox(label="Filtered Logs", lines=20)
+
+                    analyze_btn.click(
+                        fn=analyze_logs,
+                        inputs=[log_input, filter_input],
+                        outputs=output_logs
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Analyze and filter log files using regex",
+                components=["File", "Textbox", "Button"],
+                metadata={"category": "log_analysis"}
+            ),
+
+            "file_encryption_tool": Template(
+                code="""
+                import gradio as gr
+                from cryptography.fernet import Fernet
+
+                def encrypt_file(file, password):
+                    try:
+                        key = password.ljust(32, '0').encode()[:32]  # Basic password -> key mapping
+                        cipher = Fernet(Fernet.generate_key())
+                        file_data = file.read()
+                        encrypted_data = cipher.encrypt(file_data)
+                        return encrypted_data.decode("utf-8")
+                    except Exception as e:
+                        return f"Error: {str(e)}"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# File Encryption Tool")
+                    with gr.Row():
+                        with gr.Column():
+                            file_input = gr.File(label="Upload File")
+                            password_input = gr.Textbox(label="Password", type="password")
+                            encrypt_btn = gr.Button("Encrypt File")
+                        with gr.Column():
+                            encrypted_output = gr.Textbox(label="Encrypted Data", lines=20)
+
+                    encrypt_btn.click(
+                        fn=encrypt_file,
+                        inputs=[file_input, password_input],
+                        outputs=encrypted_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Encrypt a file using a password-based key",
+                components=["File", "Textbox", "Button"],
+                metadata={"category": "security"}
+            ),
+
+            "task_scheduler": Template(
+                code="""
+                import gradio as gr
+                from apscheduler.schedulers.background import BackgroundScheduler
+                from datetime import datetime
+
+                scheduler = BackgroundScheduler()
+                scheduler.start()
+
+                def schedule_task(task_name, interval):
+                    scheduler.add_job(lambda: print(f"Running task: {task_name} at {datetime.now()}"), 'interval', seconds=interval)
+                    return f"Task '{task_name}' scheduled to run every {interval} seconds."
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Task Scheduler")
+                    with gr.Row():
+                        with gr.Column():
+                            task_input = gr.Textbox(label="Task Name", placeholder="Example Task")
+                            interval_input = gr.Slider(minimum=1, maximum=60, label="Interval (Seconds)", value=10)
+                            schedule_btn = gr.Button("Schedule Task")
+                        with gr.Column():
+                            result_output = gr.Textbox(label="Result")
+
+                    schedule_btn.click(
+                        fn=schedule_task,
+                        inputs=[task_input, interval_input],
+                        outputs=result_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Schedule tasks to run at regular intervals",
+                components=["Textbox", "Slider", "Button"],
+                metadata={"category": "task_automation"}
+            ),
+
+            "code_comparator": Template(
+                code="""
+                import gradio as gr
+                import difflib
+
+                def compare_code(code1, code2):
+                    diff = difflib.unified_diff(code1.splitlines(), code2.splitlines(), lineterm='', fromfile='code1', tofile='code2')
+                    return '\n'.join(diff)
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Code Comparator")
+                    with gr.Row():
+                        with gr.Column():
+                            code1_input = gr.Textbox(label="Code 1", lines=15, placeholder="Paste the first code snippet here...")
+                            code2_input = gr.Textbox(label="Code 2", lines=15, placeholder="Paste the second code snippet here...")
+                            compare_btn = gr.Button("Compare Codes")
+                        with gr.Column():
+                            diff_output = gr.Textbox(label="Difference", lines=20)
+
+                    compare_btn.click(
+                        fn=compare_code,
+                        inputs=[code1_input, code2_input],
+                        outputs=diff_output
+                    )
+
+                if __name__ == "__main__":
+                    demo.launch()
+                """,
+                description="Compare two code snippets and show the differences",
+                components=["Textbox", "Button"],
+                metadata={"category": "development"}
+            ),
+
+            "database_query_tool": Template(
+                code="""
+                import gradio as gr
+                import sqlite3
+
+                def query_database(db_file, query):
+                    try:
+                        conn = sqlite3.connect(db_file.name)
+                        cursor = conn.cursor()
+                        cursor.execute(query)
+                        results = cursor.fetchall()
+                        conn.close()
+                        return results
+                    except Exception as e:
+                        return f"Error: {str(e)}"
+
+                with gr.Blocks(theme=gr.themes.Soft()) as demo:
+                    gr.Markdown("# Database Query Tool")
+                    with gr.Row():
+                        with gr.Column():
+                            db_input = gr.File(label="Upload SQLite DB File")
+                            query_input = gr.Textbox(label="SQL Query", placeholder="SELECT * FROM table_name;")
         }
 
     def save_template(self, name: str, template: Template) -> bool: