Update app.py

app.py

@@ -1,217 +1,245 @@
-# Copyright 2024 Christopher Woodyard
-# Licensed under the Apache License, Version 2.0
-# [License details remain unchanged]
-
 import os
 import logging
 import gradio as gr
 from groq import Groq
-import requests
 from datetime import datetime
 import json
-from typing import Tuple, Optional
+from typing import List, Dict, Tuple
 
-# Configure logging with file output
+# --- Basic Configuration ---
+# Configure logging for better debugging in Hugging Face logs
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler(f'humantouch_{datetime.now().strftime("%Y%m%d")}.log'),
-        logging.StreamHandler()
-    ]
+    handlers=[logging.StreamHandler()]
 )
 
+# --- The Core Application Logic ---
 class HumanTouchApp:
     def __init__(self):
+        # Securely initialize Groq client using Hugging Face Secrets
         self.client = self._initialize_groq_client()
-        self.model = "llama-3.3-70b-versatile"
-        self.system_prompt = self._load_system_prompt()
-        self.history_file = "processing_history.json"
+        self.model = "llama-3.1-70b-versatile" # Using the latest powerful model
+        self.system_prompt_template = self._load_system_prompt()
         
     def _initialize_groq_client(self) -> Groq:
-        """Initialize Groq client with error handling"""
-        try:
-            client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-            logging.info("Groq client initialized successfully")
-            return client
-        except KeyError:
-            logging.error("GROQ_API_KEY not found in environment variables")
-            raise EnvironmentError("Please set the GROQ_API_KEY environment variable")
-        except Exception as e:
-            logging.error(f"Error initializing Groq client: {e}")
-            raise
+        """Initialize Groq client, pulling the API key from HF Secrets."""
+        api_key = os.environ.get("GROQ_API_KEY")
+        if not api_key:
+            logging.error("FATAL: GROQ_API_KEY secret not found in Hugging Face Space settings.")
+            # In a real app, this should raise an error or display a persistent message.
+            # For this demo, we'll allow it to fail gracefully in the API call.
+            return None
+        logging.info("Groq client initialized successfully.")
+        return Groq(api_key=api_key)
 
     def _load_system_prompt(self) -> str:
-        """Load and return the system prompt"""
+        """
+        Loads the foundational system prompt template.
+        This prompt is now dynamic and will be formatted with user controls.
+        """
+        # ⬇️ PASTE YOUR ORIGINAL SYSTEM PROMPT INSIDE THE TRIPLE QUOTES ⬇️
         return """
-        [Your existing SYSTEM_PROMPT remains unchanged]
+        You are HumanTouch, an AI specializing in transforming text into emotionally resonant communication.
+        Your persona is determined by the chosen 'Ink Resonance'.
+        Your output style is guided by two scores:
+        1.  **Style Score (0-100):** 0 is purely logical and precise. 100 is highly poetic, abstract, and metaphorical.
+        2.  **Tone Score (0-100):** 0 is formal and stoic. 100 is casual, emotional, and passionate.
+
+        You will receive a user's text and a set of parameters. Your task is to rewrite the text according to these parameters, embodying the specified persona. Do not explain your process; only provide the transformed text.
+
+        Here are the Ink Resonance personalities:
+        -   **Cosmic (Default):** Wise, expansive, slightly mysterious.
+        -   **Ember (Premium):** Passionate, fiery, bold, and direct.
+        -   **Crystal (Premium):** Sharp, analytical, precise, and elegant.
+        -   **Verdant (Premium):** Natural, organic, growing, and holistic.
+        """
+
+    def generate_response(self, user_text: str, chat_history: List[List[str]], style_level: float, tone_level: float, ink_resonance: str) -> Tuple[List[List[str]], str]:
+        """
+        Main function to generate the AI's co-creative response.
+        This is the new "heart" of the application.
         """
+        if not self.client:
+            # Display error in chat if the API key is missing
+            chat_history.append([user_text, "Error: The GROQ_API_KEY is not configured on the server. Please contact the administrator."])
+            return chat_history, ""
+        
+        if not user_text.strip():
+            # Don't respond to empty input
+            return chat_history, ""
+
+        # Check for premium features
+        if ink_resonance in ["Ember", "Crystal", "Verdant"]:
+            # In a real app, you'd have user authentication. Here, we simulate the paywall.
+            chat_history.append([user_text, f"The '{ink_resonance}' Ink Resonance is a premium feature. To unlock new AI personalities and support our work, please upgrade! For now, I'll use the default Cosmic ink."])
+            ink_resonance = "Cosmic"
+
+        # Format the dynamic system prompt
+        dynamic_system_prompt = self.system_prompt_template.format(
+            ink_personality=ink_resonance,
+            style_score=style_level,
+            tone_score=tone_level
+        )
 
-    def humanize_text(self, ai_text: str, creativity_level: float) -> str:
-        """Process text through Groq API for humanization"""
         try:
-            logging.info(f"Humanizing text with creativity level: {creativity_level}")
+            logging.info(f"Generating response for '{user_text[:30]}...' with Style: {style_level}, Tone: {tone_level}, Ink: {ink_resonance}")
+            
+            messages = [{"role": "system", "content": dynamic_system_prompt}]
+            # Optional: include some history for context, but for this tool, it's often better to be stateless.
+            # for human, ai in chat_history[-2:]: # last 2 turns
+            #     messages.append({"role": "user", "content": human})
+            #     messages.append({"role": "assistant", "content": ai})
+            messages.append({"role": "user", "content": user_text})
+
             response = self.client.chat.completions.create(
                 model=self.model,
-                temperature=min(1.0, 0.4 + (creativity_level * 0.1)),
-                max_tokens=4000,  # Increased for longer texts
-                messages=[
-                    {"role": "system", "content": self.system_prompt},
-                    {"role": "user", "content": f"""
-                    Please humanize the following text, applying the guidelines provided:
-                    Original text:
-                    {ai_text}
-                    Humanized version:
-                    """}
-                ]
+                messages=messages,
+                temperature=0.5 + (style_level / 200) + (tone_level / 200), # Map 0-100 sliders to a sensible temp range
+                max_tokens=4096,
             )
-            result = response.choices[0].message.content.strip()
-            self._save_to_history(ai_text, result)
-            logging.info("Text humanization completed")
-            return result
-        except requests.exceptions.RequestException as e:
-            logging.error(f"Network error: {e}")
-            return f"Network error: {str(e)}. Please try again."
-        except Exception as e:
-            logging.error(f"Processing error: {e}")
-            return f"Error: {str(e)}"
-
-    def _save_to_history(self, input_text: str, output_text: str) -> None:
-        """Save processing history to JSON file"""
-        history_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "input": input_text[:100],  # Truncate for storage efficiency
-            "output": output_text[:100],
-            "input_length": len(input_text.split())
-        }
-        
-        try:
-            history = []
-            if os.path.exists(self.history_file):
-                with open(self.history_file, 'r') as f:
-                    history = json.load(f)
-            history.append(history_entry)
-            with open(self.history_file, 'w') as f:
-                json.dump(history[-100:], f)  # Keep last 100 entries
+            ai_response = response.choices[0].message.content.strip()
+            
+            chat_history.append([user_text, ai_response])
+            logging.info("Successfully generated response.")
+
         except Exception as e:
-            logging.warning(f"Failed to save history: {e}")
+            logging.error(f"Error during Groq API call: {e}")
+            ai_response = f"An error occurred while connecting to the AI. Details: {str(e)}"
+            chat_history.append([user_text, ai_response])
 
-    def process_text(self, ai_text: str, creativity_level: float) -> Tuple[str, str]:
-        """Main processing function with validation"""
-        if not ai_text.strip():
-            return "Please provide text to humanize.", "Input word count: 0"
-        
-        humanized = self.humanize_text(ai_text, creativity_level)
-        input_count = len(ai_text.split())
-        output_count = len(humanized.split())
-        
-        stats = (f"Input words: {input_count} | Output words: {output_count} | "
-                f"Change: {((output_count - input_count) / input_count * 100):.1f}%")
-        return humanized, stats
-
-# Enhanced CSS with better responsiveness
-custom_css = """
-body {
-    background: linear-gradient(135deg, #6DD5FA, #FF758C);
-    font-family: 'Arial', sans-serif;
-    min-height: 100vh;
-}
-.container {
-    max-width: 900px;
-    margin: 2rem auto;
-    padding: 2rem;
-    background: rgba(255, 255, 255, 0.9);
-    border-radius: 20px;
-    box-shadow: 0 8px 32px rgba(31, 38, 135, 0.37);
-}
-.title { font-size: 2.5rem; color: #2D3748; }
-.description { color: #4A5568; }
-.input-box, .output-box {
-    border: 2px solid #63B3ED;
-    border-radius: 12px;
-    padding: 1rem;
-    background: white;
-    transition: border-color 0.3s ease;
-}
-.input-box:focus, .output-box:focus {
-    border-color: #3182CE;
-    box-shadow: 0 0 8px rgba(49, 130, 206, 0.3);
-}
-@media (max-width: 768px) {
-    .container { margin: 1rem; padding: 1rem; }
-    .title { font-size: 2rem; }
-}
-button.primary {
-    background: linear-gradient(45deg, #ED64A6, #4299E1);
-    padding: 12px 24px;
-    border-radius: 9999px;
-}
-button.primary:hover {
-    background: linear-gradient(45deg, #F687B3, #5A67D8);
-}
-.stats { color: #718096; font-size: 0.9rem; }
-"""
+        # Return updated history and clear the input box
+        return chat_history, ""
 
+
+# --- The Gradio User Interface ---
 def create_interface():
     app = HumanTouchApp()
+
+    # The new CSS for our "Symbiotic Canvas" vision
+    custom_css = """
+    /* --- Main Layout & Background --- */
+    #main_container { background: #111827; }
+    #header { text-align: center; margin: 20px auto; color: #E5E7EB; }
+    #header h1 { font-size: 2.5rem; font-weight: 600; }
+    #header p { font-size: 1.1rem; color: #9CA3AF; }
+
+    /* --- The Unified Canvas (achieved with gr.Chatbot) --- */
+    #symbiotic_canvas {
+        background: #1F2937;
+        border-radius: 20px;
+        box-shadow: inset 0 2px 4px 0 rgba(0,0,0,0.5);
+        height: 60vh !important;
+        border: 1px solid #374151;
+    }
+    /* Style the user's message (Seed Text) */
+    #symbiotic_canvas .user { background-color: transparent !important; color: #F9FAFB; }
+    /* Style the AI's message (Bloomed Text) and add the animation */
+    #symbiotic_canvas .bot { background-color: transparent !important; color: #A7F3D0; animation: bloom 0.7s ease-in-out; }
+    @keyframes bloom {
+        0% { opacity: 0; transform: translateY(10px) scale(0.98); }
+        100% { opacity: 1; transform: translateY(0) scale(1); }
+    }
+
+    /* --- The Control Deck --- */
+    #control_deck {
+        background: #1F2937;
+        padding: 20px;
+        border-radius: 20px;
+        border: 1px solid #374151;
+    }
+    #control_deck .gradio-slider label span { color: #D1D5DB; } /* Slider labels */
     
-    with gr.Blocks(css=custom_css, title="HumanTouch") as interface:
-        gr.Markdown("""
-        <div class="container">
-            <h1 class="title">🧙‍♂️ HumanTouch</h1>
-            <p class="description">Breathe life into AI text with human-like finesse! Powered by Vers3Dynamics</p>
-        </div>
-        """)
-        
-        with gr.Row(equal_height=False):
-            with gr.Column(scale=1):
-                input_text = gr.Textbox(
-                    label="AI-Generated Text",
-                    lines=12,
-                    placeholder="Paste your AI text here...",
-                    elem_classes="input-box"
-                )
-                creativity = gr.Slider(
-                    0, 6, 3, step=1,
-                    label="Creativity Level",
-                    info="Higher values increase creative liberty (0-6)"
-                )
-                btn = gr.Button("Start ✨", variant="primary")
-            
-            with gr.Column(scale=1):
-                output_text = gr.Textbox(
-                    label="Humanized Result",
-                    lines=12,
-                    interactive=False,
-                    elem_classes="output-box"
-                )
-                stats = gr.Markdown(elem_classes="stats")
-        
-        gr.Examples(
-            examples=[
-                ["The system analyzed the dataset and determined optimal parameters.", 3],
-                ["The AI assistant completed its task sequence efficiently.", 4]
-            ],
-            inputs=[input_text, creativity]
-        )
-        
-        btn.click(app.process_text, [input_text, creativity], [output_text, stats])
-        input_text.change(
-            lambda x: f"Input words: {len(x.split())}",
-            inputs=[input_text],
-            outputs=[stats]
+    /* --- Ink Resonances (Radio Buttons styled as icons) --- */
+    #ink_selector { gap: 1rem; }
+    #ink_selector .gradio-radio label {
+        background: #374151 !important; color: #E5E7EB !important;
+        padding: 10px 15px !important; border-radius: 12px !important;
+        border: 2px solid transparent !important; transition: all 0.2s ease-in-out;
+    }
+    #ink_selector .gradio-radio input:checked + label {
+        border-color: #34D399 !important; background: #10B981 !important;
+        box-shadow: 0 0 15px rgba(16, 185, 129, 0.5);
+    }
+    /* Style for premium/locked inks */
+    #ink_selector .gradio-radio:nth-child(n+2) label:after {
+        content: '🔒'; /* lock emoji */
+        margin-left: 8px; font-size: 0.8em;
+    }
+    #ink_selector .gradio-radio:nth-child(1) label:after {
+        content: '✨'; /* default emoji */
+        margin-left: 8px; font-size: 0.8em;
+    }
+    
+    /* --- The Input Bar --- */
+    #chat_input textarea {
+        background-color: #374151; color: #F9FAFB;
+        border: 1px solid #4B5563; border-radius: 15px !important;
+    }
+    """
+
+    with gr.Blocks(css=custom_css, theme=gr.themes.Base(), title="HumanTouch") as interface:
+        with gr.Column(elem_id="main_container"):
+            # Header
+            with gr.Row(elem_id="header"):
+                gr.Markdown("""
+                # ✨ HumanTouch
+                <p>A Symbiotic Canvas for Co-Creative Writing</p>
+                """)
+
+            # The main UI: Canvas on the left, Controls on the right
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(
+                        [],
+                        label="Symbiotic Canvas",
+                        elem_id="symbiotic_canvas",
+                        bubble_full_width=True,
+                        avatar_images=(None, "https://i.imgur.com/Q6Zz3Jz.png") # User has none, Bot has a simple avatar
+                    )
+                    chat_input = gr.Textbox(
+                        placeholder="Start your thought here... (Press Enter to submit)",
+                        elem_id="chat_input",
+                        show_label=False,
+                        container=False
+                    )
+
+                with gr.Column(scale=1, elem_id="control_deck"):
+                    gr.Markdown("### Resonance Controls")
+                    style_slider = gr.Slider(
+                        0, 100, 50, step=1,
+                        label="Style",
+                        info="Logical (0) <-> Poetic (100)"
+                    )
+                    tone_slider = gr.Slider(
+                        0, 100, 50, step=1,
+                        label="Tone",
+                        info="Formal (0) <-> Passionate (100)"
+                    )
+                    
+                    gr.Markdown("### Ink Resonance")
+                    ink_choice = gr.Radio(
+                        ["Cosmic", "Ember", "Crystal", "Verdant"],
+                        value="Cosmic",
+                        label="Select AI Personality",
+                        show_label=False,
+                        elem_id="ink_selector"
+                    )
+
+        # Event Handling Logic
+        chat_input.submit(
+            app.generate_response,
+            [chat_input, chatbot, style_slider, tone_slider, ink_choice],
+            [chatbot, chat_input] # Update chatbot and clear input
         )
 
     return interface
 
+
 if __name__ == "__main__":
-    logging.info("Launching HumanTouch App")
+    logging.info("Launching HumanTouch App with new Symbiotic UI...")
     try:
         interface = create_interface()
-        interface.launch(
-            debug=True,
-            server_name="0.0.0.0",
-            share=True  # Enable public sharing option
-        )
+        interface.launch(debug=True) # Share=True is not recommended for local dev with secrets
     except Exception as e:
-        logging.error(f"Application launch failed: {e}")
+        logging.critical(f"Application launch failed: {e}", exc_info=True)