Upload 5 files

.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# Environment variables
+.env
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

README.md

@@ -0,0 +1,9 @@
+title: Advanced Prompt Generator
+emoji: 🚀
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 4.13.0
+app_file: app.py
+pinned: false
+license: mit

app.py

@@ -0,0 +1,175 @@
+import os
+import asyncio
+import gradio as gr
+from dotenv import load_dotenv
+import time
+from prompt_enhancer import PromptEnhancer, get_available_models
+
+# Load environment variables
+load_dotenv(encoding='utf-8')
+
+# Check if running on Hugging Face Spaces
+IS_HF_SPACE = os.environ.get("SPACE_ID") is not None
+
+# Configure API Key
+if IS_HF_SPACE:
+    # Use the Hugging Face Spaces secret
+    api_key = os.environ.get("OPENROUTER_API_KEY")
+else:
+    # Use local .env file
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    
+if not api_key:
+    print("Warning: OPENROUTER_API_KEY not found!")
+
+# Cache for available models
+available_models = []
+
+async def fetch_models():
+    """Fetch available models from OpenRouter"""
+    global available_models
+    try:
+        models = await get_available_models()
+        available_models = models
+        return [f"{model['id']} - {model.get('name', 'No name')}" for model in models]
+    except Exception as e:
+        print(f"Error fetching models: {e}")
+        # Fallback models if API call fails
+        return [
+            "anthropic/claude-3-haiku - Claude 3 Haiku",
+            "anthropic/claude-3-sonnet - Claude 3 Sonnet",
+            "anthropic/claude-3-opus - Claude 3 Opus",
+            "openai/gpt-4o - GPT-4o",
+            "openai/gpt-4o-mini - GPT-4o Mini"
+        ]
+
+def get_model_id(model_display_name):
+    """Extract model ID from display name"""
+    if " - " in model_display_name:
+        return model_display_name.split(" - ")[0]
+    return model_display_name
+
+async def enhance_prompt(prompt, model_choice):
+    """Enhance the prompt using the selected model"""
+    if not prompt.strip():
+        return "Please enter a prompt to enhance.", "", ""
+    
+    start_time = time.time()
+    
+    model_id = get_model_id(model_choice)
+    enhancer = PromptEnhancer(model_id)
+    
+    try:
+        # Process prompt
+        expanded_prompt = await enhancer.analyze_and_expand_input(prompt)
+        suggested_enhancements = await enhancer.suggest_enhancements(prompt)
+        decomposition_and_reasoning = await enhancer.decompose_and_add_reasoning(expanded_prompt)
+        
+        # Assemble components
+        components = {
+            "expanded_prompt": expanded_prompt,
+            "decomposition_and_reasoninng": decomposition_and_reasoning,
+            "suggested_enhancements": suggested_enhancements
+        }
+        
+        advanced_prompt = await enhancer.assemble_prompt(components)
+        
+        elapsed_time = time.time() - start_time
+        
+        # Generate summary
+        stats = f"""
+        Model: {model_id}
+        Processing Time: {elapsed_time:.2f} seconds
+        Prompt Tokens: {enhancer.prompt_tokens}
+        Completion Tokens: {enhancer.completion_tokens}
+        """
+        
+        return advanced_prompt, expanded_prompt, stats
+    except Exception as e:
+        return f"Error: {str(e)}", "", ""
+
+# Function to run async operations from Gradio
+def run_async(fn):
+    def wrapper(*args, **kwargs):
+        return asyncio.run(fn(*args, **kwargs))
+    return wrapper
+
+# Create the Gradio interface
+async def create_ui():
+    # Get initial model list
+    model_choices = await fetch_models()
+    default_model = model_choices[0] if model_choices else "anthropic/claude-3-haiku - Claude 3 Haiku"
+    
+    with gr.Blocks(title="Advanced Prompt Generator", theme=gr.themes.Soft()) as app:
+        gr.Markdown("""
+        # 🚀 Advanced Prompt Generator
+        
+        Transform your basic prompts into highly optimized, structured prompts for better AI responses.
+        
+        ## How it works:
+        1. Enter your basic prompt
+        2. Select an AI model
+        3. Get an enhanced, structured prompt with decomposition and reasoning
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                prompt_input = gr.Textbox(
+                    label="Enter Your Basic Prompt",
+                    placeholder="E.g. Explain quantum computing",
+                    lines=4
+                )
+                model_dropdown = gr.Dropdown(
+                    choices=model_choices,
+                    label="Select Model",
+                    value=default_model
+                )
+                refresh_button = gr.Button("🔄 Refresh Models")
+                
+                with gr.Row():
+                    submit_button = gr.Button("🔮 Enhance Prompt", variant="primary")
+                    clear_button = gr.Button("🧹 Clear")
+                
+            with gr.Column(scale=4):
+                with gr.Tabs():
+                    with gr.TabItem("Enhanced Prompt"):
+                        enhanced_output = gr.Textbox(
+                            label="Enhanced Prompt",
+                            placeholder="Your enhanced prompt will appear here...",
+                            lines=15
+                        )
+                    with gr.TabItem("Expanded Prompt Only"):
+                        expanded_output = gr.Textbox(
+                            label="Expanded Prompt",
+                            placeholder="Your expanded prompt will appear here...",
+                            lines=15
+                        )
+                    with gr.TabItem("Stats"):
+                        stats_output = gr.Textbox(
+                            label="Processing Stats",
+                            lines=5
+                        )
+        
+        # Define event handlers
+        refresh_button.click(
+            fn=run_async(fetch_models),
+            outputs=model_dropdown
+        )
+        
+        submit_button.click(
+            fn=run_async(enhance_prompt),
+            inputs=[prompt_input, model_dropdown],
+            outputs=[enhanced_output, expanded_output, stats_output]
+        )
+        
+        clear_button.click(
+            fn=lambda: ("", "", ""),
+            outputs=[enhanced_output, expanded_output, stats_output]
+        )
+    
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    app = asyncio.run(create_ui())
+    app.launch(debug=True)

prompt_enhancer.py

@@ -0,0 +1,314 @@
+import os
+import time
+import asyncio
+import aiohttp
+import json
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv(encoding='utf-8')
+
+# Check if running on Hugging Face Spaces
+IS_HF_SPACE = os.environ.get("SPACE_ID") is not None
+
+async def get_available_models():
+    """Get a list of available models from OpenRouter"""
+    if IS_HF_SPACE:
+        api_key = os.environ.get("OPENROUTER_API_KEY")
+    else:
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        
+    if not api_key:
+        raise Exception("OPENROUTER_API_KEY not found in environment variables")
+        
+    url = "https://openrouter.ai/api/v1/models"
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers) as response:
+            if response.status != 200:
+                error_text = await response.text()
+                raise Exception(f"OpenRouter API error: {response.status}, {error_text}")
+            
+            data = await response.json()
+            return data["data"]
+
+
+# Defining the PromptEnhancer class
+class PromptEnhancer:
+    def __init__(self, model="anthropic/claude-3-haiku", tools_dict={}):
+        self.model = model
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.tools_dict = tools_dict
+        
+        # Get API key based on environment
+        if IS_HF_SPACE:
+            self.api_key = os.environ.get("OPENROUTER_API_KEY")
+        else:
+            self.api_key = os.getenv("OPENROUTER_API_KEY")
+            
+        self.base_url = "https://openrouter.ai/api/v1"
+        
+        if not self.api_key:
+            print("Error: API Key is not loaded!")
+        else:
+            print(f"API Key Loaded: {self.api_key[:5]}********")
+
+    async def call_llm(self, prompt):
+        """Call the LLM with the given prompt using OpenRouter"""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://huggingface.co" if IS_HF_SPACE else "http://localhost:3000"
+        }
+        
+        data = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", 
+                 "content": 
+                     "You are a highly intelligent AI assistant. Your task is to analyze, and comprehend the provided prompt,\
+                        then provide clear, and concise response based strictly on the given instructions.\
+                        Do not include any additional explanations or context beyond the required output."
+                 },
+                {"role": "user", 
+                 "content": prompt
+                 } 
+            ],
+            "temperature": 0.0,  # from 0 (precise) to 2 (creative)
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(f"{self.base_url}/chat/completions", headers=headers, json=data) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    raise Exception(f"OpenRouter API error: {response.status}, {error_text}")
+                
+                response_data = await response.json()
+                
+                # Update token counts if available in the response
+                if "usage" in response_data:
+                    self.prompt_tokens += response_data["usage"].get("prompt_tokens", 0)
+                    self.completion_tokens += response_data["usage"].get("completion_tokens", 0)
+                
+                return response_data["choices"][0]["message"]["content"]
+
+
+    async def analyze_and_expand_input(self, input_prompt):
+        analysis_and_expansion_prompt = f"""
+        You are a highly intelligent assistant. 
+        Analyze the provided {{prompt}} and generate concise answers for the following key aspects:
+
+        - **Main goal of the prompt:** Identify the core subject or request within the provided prompt.
+        - **Persona:** Recommend the most relevant persona for the AI model to adopt (e.g., expert, teacher, conversational, etc.)
+        - **Optimal output length:** Suggest an optimal output length (short, brief, medium, long) based on the task, and give an approximate number of words if it is suitable for the case.
+        - **Most convenient output format:** Recommend the optimal format for the result (e.g., list, paragraph, code snippet, table, JSON, etc.).
+        - **Specific requirements:** Highlight any special conditions, rules, or expectations stated or implied within the prompt.
+        - **Suggested improvements:** Offer recommendations on how to modify or enhance the prompt for more precise or efficient output generation.
+        - **One-shot prompting:** Create one related examples to guide the output generation.
+        
+        Then use them to reformulate and expand the provided {{prompt}}.
+        Return the expanded prompt as output in text format. Refrain from explaining the generation process.
+
+        Example 1:
+        {{prompt}}: "Explain quantum entanglement to a 10-year-old."
+        
+        *thought_process*:
+        - **Main goal of the prompt:** Simplify complex quantum physics concept for children.
+        - **Persona:** Patient, friendly teacher
+        - **Optimal output length:** Brief (100-150 words)
+        - **Most convenient output format:** Narrative with analogy
+        - **Specific requirements:** Age-appropriate explanation (10-year-old).
+        - **Suggested improvements:** 
+            - Request specific analogies
+            - Include interactive elements
+            - Add follow-up questions
+            - Suggest visual aids
+        - **One-shot prompting:**
+        Output example:
+            "Imagine you have two special pairs of socks. When you put one sock in your room and the other sock in the kitchen, 
+            something magical happens! Whatever happens to one sock instantly affects the other sock. 
+            If you turn one sock inside out, the other sock automatically turns inside out too, no matter how far apart they are!" 
+        
+        *output*:
+        As a friendly science teacher, please explain quantum entanglement to a 10-year-old student using these guidelines:
+
+        Start with a relatable analogy using everyday objects
+        Use simple, clear language avoiding technical terms
+        Include 2-3 interactive examples that demonstrate the concept
+        Add fun facts that will spark curiosity
+        End with simple questions to check understanding
+        Keep the explanation brief (100-150 words)
+
+        Structure your explanation as:
+        
+        Opening analogy
+        Main explanation with examples
+        Interactive "What if?" scenarios
+        Fun facts about quantum entanglement
+        Check-for-understanding questions
+
+        Remember to maintain an enthusiastic and encouraging tone throughout the explanation.
+        
+        Output example:
+        Imagine you have two special pairs of socks. When you put one sock in your room and the other sock in the kitchen, 
+        something magical happens! Whatever happens to one sock instantly affects the other sock. 
+        If you turn one sock inside out, the other sock automatically turns inside out too, no matter how far apart they are!
+
+        Example 2:
+        {{prompt}}: "Write a function to calculate the Fibonacci sequence up to n terms."
+        
+        *thought_process*:
+        - **Main goal of the prompt:** Create a programming function that generates Fibonacci numbers
+        - **Persona:** Programming expert
+        - **Optimal output length:** Medium (150-200 words including code)
+        - **Most convenient output format:** Code snippet with explanatory comments
+        - **Specific requirements:** Function must accept parameter n for sequence length
+        - **Suggested improvements:** 
+            - Specify programming language
+            - Clarify if 0 should be included as first term
+            - Define expected handling of negative inputs
+        - **One-shot prompting:** 
+        
+        *output*:
+        As an expert programmer, please create a well-documented function to generate the Fibonacci sequence. 
+        
+        Requirements:
+        Accept a parameter 'n' specifying the number of terms to generate
+        Handle edge cases (n <= 0, n == 1)
+        Return the sequence as a list/array
+        Include proper error handling
+        Add comments explaining the logic
+
+        Provide the implementation in Python, including:
+        Function definition with docstring
+        Input validation
+        Core algorithm
+        Example usage with outputs for n=5, n=1, and n=0
+
+        For reference, the sequence should start with [0, 1, ...] where each subsequent number is the sum of the previous two numbers.
+        
+        
+        Now, analyze the following prompt then return only the generated *output*:
+        {{prompt}}: {input_prompt}
+        """
+
+        return await self.call_llm(analysis_and_expansion_prompt)
+
+    
+    async def decompose_and_add_reasoning(self, expanded_prompt):
+        decomposition_and_reasoning_prompt = f"""
+        You are a highly capable AI assistant tasked with improving complex task execution. 
+        Analyze the provided {{prompt}}, and use it to generate the following output:
+        
+        - **Subtasks decomposition:** Break down the task described in the prompt into manageable and specific subtasks that the AI model needs to address.
+        - **Chain-of-thought reasoning:** For subtasks that involve critical thinking or complex steps, add reasoning using a step-by-step approach to improve decision-making and output quality.
+        - **Success criteria:** Define what constitutes a successful completion for each subtask, ensuring clear guidance for expected results.
+
+        Return the following structured output for each subtask:
+
+        1. **Subtask description**: Describe a specific subtask.
+        2. **Reasoning**: Provide reasoning or explanation for why this subtask is essential or how it should be approached.
+        3. **Success criteria**: Define what successful completion looks like for this subtask.
+
+        Example 1:
+        {{Prompt}}: "Explain how machine learning models are evaluated using cross-validation."
+
+        ##THOUGHT PROCESS##
+        *Subtask 1*:
+        - **Description**: Define cross-validation and its purpose.
+        - **Reasoning**: Clarifying the concept ensures the reader understands the basic mechanism behind model evaluation.
+        - **Success criteria**: The explanation should include a clear definition of cross-validation and its role in assessing model performance.
+        *Subtask 2*:
+        - **Description**: Describe how cross-validation splits data into training and validation sets.
+        - **Reasoning**: Explaining the split is crucial to understanding how models are validated and tested for generalization.
+        - **Success criteria**: A proper explanation of k-fold cross-validation with an illustration of how data is split.
+        *Subtask 3*:
+        - **Description**: Discuss how cross-validation results are averaged to provide a final evaluation metric.
+        - **Reasoning**: Averaging results helps mitigate the variance in performance due to different training/validation splits.
+        - **Success criteria**: The output should clearly explain how the final model evaluation is derived from multiple iterations of cross-validation.
+
+        Now, analyze the following expanded prompt and return the subtasks, reasoning, and success criteria.
+        Prompt: {expanded_prompt}
+        """
+        return await self.call_llm(decomposition_and_reasoning_prompt)
+
+    
+    
+    async def suggest_enhancements(self, input_prompt, tools_dict={}):
+        enhancement_suggestion_prompt = f"""
+        You are a highly intelligent assistant specialized in reference suggestion and tool integration.
+        Analyze the provided {{input_prompt}} and the available {{tools_dict}} to recommend enhancements:
+
+        - **Reference necessity:** Determine if additional reference materials would benefit the task execution (e.g., websites, documentations, books, articles, etc.)
+        - **Tool applicability:** Evaluate if any available tools could enhance efficiency or accuracy
+        - **Integration complexity:** Assess the effort required to incorporate suggested resources
+        - **Expected impact:** Estimate the potential improvement in output quality
+        
+        If enhancements are warranted, provide structured recommendations in this format:
+        
+        ##REFERENCE SUGGESTIONS##
+        (Only if applicable, maximum 3)
+        - Reference name/type
+        - Purpose: How it enhances the output
+        - Integration: How to incorporate it
+        
+        ##TOOL SUGGESTIONS##
+        (Only if applicable, maximum 3)
+        - Tool name from tools_dict
+        - Purpose: How it improves the task
+        - Integration: How to implement it
+        
+        If no enhancements would significantly improve the output, return an empty string ""
+
+        Example 1:
+        {{input_prompt}}: "Write a Python function to detect faces in images using computer vision."
+        {{tools_dict}}: {{}}
+        *output*:
+        ##REFERENCE SUGGESTIONS##
+        - OpenCV Face Detection Documentation
+          Purpose: Provides implementation details and best practices
+          Integration: Reference for optimal parameter settings and cascade classifier usage        
+        
+        Now, analyze the following prompt and tools, then return only the generated *output*:
+        {{input_prompt}}: {input_prompt}
+        {{tools_dict}}: {tools_dict}
+        """
+        return await self.call_llm(enhancement_suggestion_prompt)
+    
+    
+    async def assemble_prompt(self, components):
+        expanded_prompt = components.get("expanded_prompt", "")
+        decomposition_and_reasoninng = components.get("decomposition_and_reasoninng", "")
+        suggested_enhancements = components.get("suggested_enhancements", "")
+        
+        output_prompt = (
+            f"{expanded_prompt}\n\n"
+            f"{suggested_enhancements}\n\n"
+            f"{decomposition_and_reasoninng}"
+        )
+        return output_prompt
+    
+    
+    async def enhance_prompt(self, input_prompt):
+        """Main method to enhance a prompt"""
+        tools_dict = {}
+        
+        expanded_prompt = await self.analyze_and_expand_input(input_prompt)
+        suggested_enhancements = await self.suggest_enhancements(input_prompt, tools_dict)
+        decomposition_and_reasoning = await self.decompose_and_add_reasoning(expanded_prompt)
+        
+        components = {
+            "expanded_prompt": expanded_prompt,
+            "decomposition_and_reasoninng": decomposition_and_reasoning,
+            "suggested_enhancements": suggested_enhancements
+        }
+        
+        output_prompt = await self.assemble_prompt(components)
+        
+        return output_prompt

requirements.txt

@@ -0,0 +1,62 @@
+aiohttp==3.9.5
+aiosignal==1.3.1
+annotated-types==0.7.0
+anyio==4.4.0
+attrs==23.2.0
+certifi==2024.7.4
+charset-normalizer==3.3.2
+click==8.1.7
+distro==1.9.0
+dnspython==2.6.1
+email_validator==2.2.0
+fastapi==0.111.1
+fastapi-cli==0.0.4
+frozenlist==1.4.1
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+idna==3.7
+Jinja2==3.1.4
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==0.2.10
+langchain-core==0.2.22
+langchain-openai==0.1.17
+langchain-text-splitters==0.2.2
+langsmith==0.1.93
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+multidict==6.0.5
+numpy==1.26.4
+openai==1.35.15
+orjson==3.10.6
+packaging==24.1
+pydantic==2.8.2
+pydantic_core==2.20.1
+Pygments==2.18.0
+python-dotenv==1.0.1
+python-multipart==0.0.9
+PyYAML==6.0.1
+regex==2024.5.15
+requests==2.32.3
+rich==13.7.1
+shellingham==1.5.4
+sniffio==1.3.1
+SQLAlchemy==2.0.31
+starlette==0.37.2
+tenacity==8.5.0
+tiktoken==0.7.0
+tqdm==4.66.4
+typer==0.12.3
+typing_extensions==4.12.2
+urllib3==2.2.2
+uvicorn==0.30.3
+uvloop==0.19.0
+watchfiles==0.22.0
+websockets==12.0
+yarl==1.9.4
+gradio>=4.13.0
+aiohttp>=3.9.1
+python-dotenv>=1.0.0