diff --git "a/app.py" "b/app.py" --- "a/app.py" +++ "b/app.py" @@ -472,7 +472,1022 @@ class TemplateManager: self.template_dir.mkdir(exist_ok=True) self.templates: Dict[str, Template] = {} self.load_templates() + +def _get_builtin_templates(self) -> Dict[str, Template]: + """Get built-in templates""" + templates = { + "image_classifier": Template( + code=""" + import gradio as gr + import numpy as np + from PIL import Image + + def classify_image(image): + if image is None: + return {"error": 1.0} + return {"class1": 0.8, "class2": 0.2} + + with gr.Blocks(theme=gr.themes.Soft()) as demo: + gr.Markdown("# Image Classifier") + with gr.Row(): + with gr.Column(): + input_image = gr.Image(type="pil") + classify_btn = gr.Button("Classify") + with gr.Column(): + output_labels = gr.Label() + + classify_btn.click( + fn=classify_image, + inputs=input_image, + outputs=output_labels + ) + + if __name__ == "__main__": + demo.launch() + """, + description="Basic image classification interface", + components=["Image", "Button", "Label"], + metadata={"category": "computer_vision"} + ), + "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 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("# Audio Processor") + with gr.Row(): + with gr.Column(): + 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" + ) + visualize_btn = gr.Button("Visualize") + with gr.Column(): + 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"} + ), + "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"} + ), + ```python + "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_sentiment, + inputs=input_text, + outputs=sentiment_output + ) + + if __name__ == "__main__": + demo.launch() + """, + 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 + ```python + ) + 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 ```python + 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;") + query_btn = gr.Button("Run Query") + with gr.Column(): + query_output = gr.JSON(label="Query Results") + + query_btn.click( + fn=query_database, + inputs=[db_input, query_input], + outputs=query_output + ) + + if __name__ == "__main__": + demo.launch() + """, + description="Run SQL queries on a SQLite database", + components=["File", "Textbox", "Button", "JSON"], + metadata={"category": "database"} + ) + "code_generator" : Template( + code=""" pipeline("text-generation", model="Salesforce/codegen-2B-multi") + + def generate_code(prompt): + response = code_generator(prompt, max_length=150, num_return_sequences=1) + return response[0]['generated_text'] + + with gr.Blocks(theme=gr.themes.Soft()) as demo: + gr.Markdown("# Code Generator") + with gr.Row(): + with gr.Column(): + prompt_input = gr.Textbox(label="Enter Code Prompt", placeholder="Write a Python function to reverse a string") + generate_btn = gr.Button("Generate Code") + with gr.Column(): + generated_code = gr.Textbox(label="Generated Code", lines=10) + + generate_btn.click( + fn=generate_code, + inputs=prompt_input, + outputs=generated_code + ) + + if __name__ == "__main__": + demo.launch() + """, + description="Generate code snippets based on natural language prompts", + components=["Textbox", "Button"], + metadata={"category": "development"} + ), + + "code_debugger": Template( + code=""" + import gradio as gr + import subprocess + + def debug_code(code): + try: + with open("temp_code.py", "w") as f: + f.write(code) + result = subprocess.run(["python3", "temp_code.py"], capture_output=True, text=True) + return {"stdout": result.stdout, "stderr": result.stderr} + except Exception as e: + return {"error": str(e)} + + with gr.Blocks(theme=gr.themes.Soft()) as demo: + gr.Markdown("# Code Debugger") + with gr.Row(): + with gr.Column(): + code_input = gr.Textbox(label="Code to Debug", lines=10, placeholder="Paste your Python code here...") + debug_btn = gr.Button("Run Debug") + with gr.Column(): + debug_output = gr.JSON(label="Debug Output") + + debug_btn.click( + fn=debug_code, + inputs=code_input, + outputs=debug_output + ) + + if __name__ == "__main__": + demo.launch() + """, + description="Run and debug Python code by capturing stdout and stderr", + components=["Textbox", "Button", "JSON"], + metadata={"category": "development"} + ), + + "multi_agent_task_manager": Template( + code=""" + import gradio as gr + from concurrent.futures import ThreadPoolExecutor + import time + + agent_pool = ThreadPoolExecutor(max_workers=5) + agent_status = {} + + def agent_task(agent_name, task): + agent_status[agent_name] = "Running" + time.sleep(5) # Simulate task duration + agent_status[agent_name] = "Completed" + return f"Agent {agent_name} has completed the task: {task}" + + def trigger_agents(agents, task): + results = [] + for agent in agents: + future = agent_pool.submit(agent_task, agent, task) + results.append(f"Agent {agent} triggered") + return results + + def get_agent_status(): + return agent_status + + with gr.Blocks(theme=gr.themes.Soft()) as demo: + gr.Markdown("# Multi-Agent Task Manager") + with gr.Row(): + with gr.Column(): + agents = gr.CheckboxGroup(choices=["Agent1", "Agent2", "Agent3", "Agent4", "Agent5"], label="Select Agents") + task_input = gr.Textbox(label="Task to Perform", placeholder="Describe the task...") + trigger_btn = gr.Button("Trigger Agents") + with gr.Column(): + task_output = gr.JSON(label="Agent Responses") + + with gr.Row(): + status_btn = gr.Button("Get Agent Status") + status_output = gr.JSON(label="Current Agent Status") + + trigger_btn.click( + fn=trigger_agents, + inputs=[agents, task_input], + outputs=task_output + ) + + status_btn.click( + fn=get_agent_status, + inputs=[], + outputs=status_output + ) + + if __name__ == "__main__": + demo.launch() + """, + description="Manage and trigger tasks for multiple autonomous agents", + components=["CheckboxGroup", "Textbox", "Button", "JSON"], + metadata={"category": "task_automation"} + ), + + "auto_code_refactor": Template( + code=""" + import gradio as gr + from transformers import pipeline + + code_refactor = pipeline("text2text-generation", model="facebook/bart-large-cnn") + + def refactor_code(code): + result = code_refactor(f"Refactor the following Python code: {code}", max_length=150) + return result[0]['generated_text'] + + with gr.Blocks(theme=gr.themes.Soft()) as demo: + gr.Markdown("# Auto Code Refactor") + with gr.Row(): + with gr.Column(): + code_input = gr.Textbox(label="Code to Refactor", lines=10, placeholder="Paste your Python code here...") + refactor_btn = gr.Button("Refactor Code") + with gr.Column(): + refactored_code = gr.Textbox(label="Refactored Code", lines=10) + + refactor_btn.click( + fn=refactor_code, + inputs=code_input, + outputs=refactored_code + ) + + if __name__ == "__main__": + demo.launch() + """, + description="Automatically refactor Python code for better efficiency or readability", + components=["Textbox", "Button"], + metadata={"category": "development"} + ), + + "agent_cluster_deployer": Template( + code=""" + import gradio as gr + import random + + cluster_status = {} + + def deploy_agent_cluster(agent_count, task): + cluster_id = random.randint(1000, 9999) + cluster_status[cluster_id] = { + "status": "Deploying", + "agents": agent_count, + "task": task + } + return f"Cluster {cluster_id} is deploying with {agent_count} agents for task: {task}" + + def get_cluster_status(): + return cluster_status + + with gr.Blocks(theme=gr.themes.Soft()) as demo: + gr.Markdown("# Agent Cluster Deployer") + with gr.Row(): + with gr.Column(): + agent_count = gr.Slider(label="Number of Agents", minimum=1, maximum=10, step=1, value=3) + task_input = gr.Textbox(label="Cluster Task", placeholder="Describe the task for the cluster...") + deploy_btn = gr.Button("Deploy Cluster") + with gr.Column(): + deploy_output = gr.Textbox(label="Cluster Deployment Status") + + with gr.Row(): + status_btn = gr.Button("Get Cluster Status") + status_output = gr.JSON(label="Current Cluster Status") + + deploy_btn.click( + fn=deploy_agent_cluster, + inputs=[agent_count, task_input], + outputs=deploy_output + ) + + status_btn.click( + fn=get_cluster_status, + inputs=[], + outputs=status_output + ) + + if __name__ == "__main__": + demo.launch() + """, + description="Deploy an autonomous agent cluster for task execution", + components=["Slider", "Textbox", "Button", "JSON"], + metadata={"category": "task_automation"} + ) + } + return templates + def load_templates(self): """Load all templates from directory""" try: @@ -492,222 +1507,8 @@ class TemplateManager: except Exception as e: logger.error(f"Error loading templates: {e}") - def _get_builtin_templates(self) -> Dict[str, Template]: - """Get built-in templates""" - return { - "image_classifier": Template( - code=""" - import gradio as gr - import numpy as np - from PIL import Image - - def classify_image(image): - if image is None: - return {"error": 1.0} - return {"class1": 0.8, "class2": 0.2} - - with gr.Blocks(theme=gr.themes.Soft()) as demo: - gr.Markdown("# Image Classifier") - with gr.Row(): - with gr.Column(): - input_image = gr.Image(type="pil") - classify_btn = gr.Button("Classify") - with gr.Column(): - output_labels = gr.Label() - - classify_btn.click( - fn=classify_image, - inputs=input_image, - outputs=output_labels - ) - - if __name__ == "__main__": - demo.launch() - """, - description="Basic image classification interface", - components=["Image", "Button", "Label"], - metadata={"category": "computer_vision"} - ), - "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 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("# Audio Processor") - with gr.Row(): - with gr.Column(): - 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" - ) - visualize_btn = gr.Button("Visualize") - with gr.Column(): - 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() @@ -882,837 +1683,6 @@ if __name__ == "__main__": 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_sentiment, - inputs=input_text, - outputs=sentiment_output - ) - - if __name__ == "__main__": - demo.launch() - """, - 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 requests -from bs4 import BeautifulSoup -import time -import os - -def get_website_content(url): - try: - response = requests.get(url) - response.raise_for_status() # Raise an exception for HTTP errors - return response.text - except requests.exceptions.RequestException as e: - print(f"Error fetching website content: {e}") - return None - -def parse_website_content(html): - try: - soup = BeautifulSoup(html, 'html.parser') - return soup - except Exception as e: - print(f"Error parsing website content: {e}") - return None - -def extract_data(soup): - try: - # Implement data extraction logic here - # For example, let's assume we want to extract the title of the webpage - title = soup.find('title').text - return title - except Exception as e: - print(f"Error extracting data: {e}") - return None - -def monitor_website(url, output_file): - while True: - html = get_website_content(url) - if html: - soup = parse_website_content(html) - if soup: - data = extract_data(soup) - if data: - with open(output_file, 'a') as f: - f.write(data + '\n') - print(f"Data extracted and written to {output_file}") - time.sleep(60) # Monitor the website every 60 seconds - -def main(): - url = input("Enter the website URL to monitor: ") - output_file = input("Enter the output file path: ") - monitor_website(url, output_file) - -if __name__ == "__main__": - main() - """, - 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;") - query_btn = gr.Button("Run Query") - with gr.Column(): - query_output = gr.JSON(label="Query Results") - - query_btn.click( - fn=query_database, - inputs=[db_input, query_input], - outputs=query_output - ) - - if __name__ == "__main__": - demo.launch() - """, - description="Run SQL queries on a SQLite database", - components=["File", "Textbox", "Button", "JSON"], - metadata={"category": "database"} - ) - -"code_generator": Template( - code=""" - import gradio as gr - from transformers import pipeline - - code_generator = pipeline("text-generation", model="Salesforce/codegen-2B-multi") - - def generate_code(prompt): - response = code_generator(prompt, max_length=150, num_return_sequences=1) - return response[0]['generated_text'] - - with gr.Blocks(theme=gr.themes.Soft()) as demo: - gr.Markdown("# Code Generator") - with gr.Row(): - with gr.Column(): - prompt_input = gr.Textbox(label="Enter Code Prompt", placeholder="Write a Python function to reverse a string") - generate_btn = gr.Button("Generate Code") - with gr.Column(): - generated_code = gr.Textbox(label="Generated Code", lines=10) - - generate_btn.click( - fn=generate_code, - inputs=prompt_input, - outputs=generated_code - ) - - if __name__ == "__main__": - demo.launch() - """, - description="Generate code snippets based on natural language prompts", - components=["Textbox", "Button"], - metadata={"category": "development"} - ), - - "code_debugger": Template( - code=""" - import gradio as gr - import subprocess - - def debug_code(code): - try: - with open("temp_code.py", "w") as f: - f.write(code) - result = subprocess.run(["python3", "temp_code.py"], capture_output=True, text=True) - return {"stdout": result.stdout, "stderr": result.stderr} - except Exception as e: - return {"error": str(e)} - - with gr.Blocks(theme=gr.themes.Soft()) as demo: - gr.Markdown("# Code Debugger") - with gr.Row(): - with gr.Column(): - code_input = gr.Textbox(label="Code to Debug", lines=10, placeholder="Paste your Python code here...") - debug_btn = gr.Button("Run Debug") - with gr.Column(): - debug_output = gr.JSON(label="Debug Output") - - debug_btn.click( - fn=debug_code, - inputs=code_input, - outputs=debug_output - ) - - if __name__ == "__main__": - demo.launch() - """, - description="Run and debug Python code by capturing stdout and stderr", - components=["Textbox", "Button", "JSON"], - metadata={"category": "development"} - ), - - "multi_agent_task_manager": Template( - code=""" - import gradio as gr - from concurrent.futures import ThreadPoolExecutor - import time - - agent_pool = ThreadPoolExecutor(max_workers=5) - agent_status = {} - - def agent_task(agent_name, task): - agent_status[agent_name] = "Running" - time.sleep(5) # Simulate task duration - agent_status[agent_name] = "Completed" - return f"Agent {agent_name} has completed the task: {task}" - - def trigger_agents(agents, task): - results = [] - for agent in agents: - future = agent_pool.submit(agent_task, agent, task) - results.append(f"Agent {agent} triggered") - return results - - def get_agent_status(): - return agent_status - - with gr.Blocks(theme=gr.themes.Soft()) as demo: - gr.Markdown("# Multi-Agent Task Manager") - with gr.Row(): - with gr.Column(): - agents = gr.CheckboxGroup(choices=["Agent1", "Agent2", "Agent3", "Agent4", "Agent5"], label="Select Agents") - task_input = gr.Textbox(label="Task to Perform", placeholder="Describe the task...") - trigger_btn = gr.Button("Trigger Agents") - with gr.Column(): - task_output = gr.JSON(label="Agent Responses") - - with gr.Row(): - status_btn = gr.Button("Get Agent Status") - status_output = gr.JSON(label="Current Agent Status") - - trigger_btn.click( - fn=trigger_agents, - inputs=[agents, task_input], - outputs=task_output - ) - - status_btn.click( - fn=get_agent_status, - inputs=[], - outputs=status_output - ) - - if __name__ == "__main__": - demo.launch() - """, - description="Manage and trigger tasks for multiple autonomous agents", - components=["CheckboxGroup", "Textbox", "Button", "JSON"], - metadata={"category": "task_automation"} - ), - - "auto_code_refactor": Template( - code=""" - import gradio as gr - from transformers import pipeline - - code_refactor = pipeline("text2text-generation", model="facebook/bart-large-cnn") - - def refactor_code(code): - result = code_refactor(f"Refactor the following Python code: {code}", max_length=150) - return result[0]['generated_text'] - - with gr.Blocks(theme=gr.themes.Soft()) as demo: - gr.Markdown("# Auto Code Refactor") - with gr.Row(): - with gr.Column(): - code_input = gr.Textbox(label="Code to Refactor", lines=10, placeholder="Paste your Python code here...") - refactor_btn = gr.Button("Refactor Code") - with gr.Column(): - refactored_code = gr.Textbox(label="Refactored Code", lines=10) - - refactor_btn.click( - fn=refactor_code, - inputs=code_input, - outputs=refactored_code - ) - - if __name__ == "__main__": - demo.launch() - """, - description="Automatically refactor Python code for better efficiency or readability", - components=["Textbox", "Button"], - metadata={"category": "development"} - ), - - "agent_cluster_deployer": Template( - code=""" - import gradio as gr - import random - - cluster_status = {} - - def deploy_agent_cluster(agent_count, task): - cluster_id = random.randint(1000, 9999) - cluster_status[cluster_id] = { - "status": "Deploying", - "agents": agent_count, - "task": task - } - return f"Cluster {cluster_id} is deploying with {agent_count} agents for task: {task}" - - def get_cluster_status(): - return cluster_status - - with gr.Blocks(theme=gr.themes.Soft()) as demo: - gr.Markdown("# Agent Cluster Deployer") - with gr.Row(): - with gr.Column(): - agent_count = gr.Slider(label="Number of Agents", minimum=1, maximum=10, step=1, value=3) - task_input = gr.Textbox(label="Cluster Task", placeholder="Describe the task for the cluster...") - deploy_btn = gr.Button("Deploy Cluster") - with gr.Column(): - deploy_output = gr.Textbox(label="Cluster Deployment Status") - - with gr.Row(): - status_btn = gr.Button("Get Cluster Status") - status_output = gr.JSON(label="Current Cluster Status") - - deploy_btn.click( - fn=deploy_agent_cluster, - inputs=[agent_count, task_input], - outputs=deploy_output - ) - - status_btn.click( - fn=get_cluster_status, - inputs=[], - outputs=status_output - ) - - if __name__ == "__main__": - demo.launch() - """, - description="Deploy an autonomous agent cluster for task execution", - components=["Slider", "Textbox", "Button", "JSON"], - metadata={"category": "task_automation"} - ) - } self.component_index = self._build_component_index() self.category_index = self._build_category_index() @@ -1866,608 +1836,7 @@ if __name__ == "__main__": 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_sentiment, - inputs=input_text, - outputs=sentiment_output - ) - - if __name__ == "__main__": - demo.launch() - """, - 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: """Save new template"""