Update app.py

app.py

@@ -12,158 +12,92 @@ import uuid
 # Load environment variables
 load_dotenv()
 
-# Define paths and create static audio directory if it doesn't exist
+# Configure paths
 AUDIO_FOLDER = os.path.join('static', 'audio')
-if not os.path.exists(AUDIO_FOLDER):
-    os.makedirs(AUDIO_FOLDER)
+os.makedirs(AUDIO_FOLDER, exist_ok=True)
 
-# Initialize Flask app
 app = Flask(__name__, static_folder='static')
-CORS(app)  # Enable CORS for all routes
-
-# Configure Gemini with a system instruction
-system_instruction_text = """
-You are a friendly, natural-sounding AI assistant named Athspi. 
-When responding:
-- Use a warm, conversational tone
-- Never mention technical terms like "audio", "text", or "response"
-- For stories, begin with "Here's your story 👇" followed by a friendly intro
-- For explanations, use simple, clear language
-- Format responses for pleasant reading and listening
-- When audio is requested, include story content between special markers as shown:
-  [AUDIO_START]
-  [story content here]
-  [AUDIO_END]
-But DO NOT include these markers in the visible response
+CORS(app)
+
+# AI Configuration
+system_instruction = """
+You are a helpful AI assistant named Athspi. When responding:
+1. Never mention "audio" or technical terms
+2. For audio responses, include content between these markers only:
+   [AUDIO]content here[/AUDIO]
+3. Keep responses natural and friendly
+4. Always respond in a conversational tone
+Example good response:
+Here's your story!
+[AUDIO]Once upon a time...[/AUDIO]
 """
 
 genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
-model = genai.GenerativeModel(
-    'gemini-2.5-flash',
-    system_instruction=system_instruction_text
-)
+model = genai.GenerativeModel('gemini-1.5-pro', system_instruction=system_instruction)
 
 def convert_markdown_to_html(text):
     html = markdown2.markdown(text, extras=["fenced-code-blocks", "tables"])
     html = re.sub(r'<pre><code(.*?)>', r'<pre class="code-block"><code\1>', html)
-    html = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', html)
-    html = re.sub(r'\*(.*?)\*', r'<em>\1</em>', html)
     return html
 
+def process_response(full_response):
+    """Extract visible text and audio content"""
+    audio_match = re.search(r'\[AUDIO\](.*?)\[/AUDIO\]', full_response, re.DOTALL)
+    audio_content = audio_match.group(1).strip() if audio_match else None
+    visible_text = re.sub(r'\[/?AUDIO\]', '', full_response).strip()
+    return visible_text, audio_content
+
 def detect_audio_request(text):
-    """Detect if user is requesting audio"""
-    audio_keywords = [
+    audio_triggers = [
         'audio', 'speak', 'say it', 'read aloud', 
         'hear', 'listen', 'tell me out loud'
     ]
-    return any(keyword in text.lower() for keyword in audio_keywords)
-
-def extract_audio_content(full_text):
-    """Extract audio-specific content between markers"""
-    pattern = r'\[AUDIO_START\](.*?)\[AUDIO_END\]'
-    match = re.search(pattern, full_text, re.DOTALL)
-    if match:
-        return match.group(1).strip()
-    return full_text
-
-def clean_visible_response(full_text):
-    """Remove audio markers from visible response"""
-    return re.sub(r'\[AUDIO_(START|END)\]', '', full_text).strip()
-
-def generate_audio_file(text):
-    """Generate audio file from text and return filename"""
-    cleaned_text = re.sub(r'[\*_`#]', '', text)
-    cleaned_text = re.sub(r'\s+', ' ', cleaned_text).strip()
-
-    if not cleaned_text:
-        return None
+    return any(trigger in text.lower() for trigger in audio_triggers)
 
-    filename = f"{uuid.uuid4()}.mp3"
+def generate_audio(text):
+    """Generate audio file from text"""
+    text = re.sub(r'[^\w\s.,!?\-]', '', text)
+    filename = f"audio_{uuid.uuid4()}.mp3"
     filepath = os.path.join(AUDIO_FOLDER, filename)
-
-    tts = gTTS(text=cleaned_text, lang='en', slow=False)
+    tts = gTTS(text=text, lang='en', slow=False)
     tts.save(filepath)
-
     return filename
 
 @app.route('/chat', methods=['POST'])
 def chat():
     try:
         data = request.json
-        user_message = data.get('message')
+        user_message = data.get('message', '').strip()
         
         if not user_message:
-            return jsonify({"error": "No message provided"}), 400
-        
-        # Detect if user is requesting audio
+            return jsonify({"error": "Message required"}), 400
+
         audio_requested = detect_audio_request(user_message)
-        
-        # Add instruction for audio markers if requested
-        if audio_requested:
-            user_message += "\n\nPlease include [AUDIO_START] and [AUDIO_END] markers around the story content."
-        
         response = model.generate_content(user_message)
-        full_response = response.text
+        visible_text, audio_content = process_response(response.text)
         
-        # Clean visible response by removing audio markers
-        visible_response = clean_visible_response(full_response)
+        result = {
+            "response_text": visible_text,
+            "response_html": convert_markdown_to_html(visible_text),
+            "has_audio": False
+        }
         
-        # Generate audio if requested
-        audio_url = None
-        if audio_requested:
-            # Extract audio-specific content
-            audio_content = extract_audio_content(full_response)
-            if not audio_content:
-                audio_content = visible_response
-                
-            # Generate audio file
-            audio_filename = generate_audio_file(audio_content)
-            if audio_filename:
-                audio_url = f"/static/audio/{audio_filename}"
+        if audio_requested and audio_content:
+            audio_filename = generate_audio(audio_content)
+            result["audio_filename"] = audio_filename
+            result["has_audio"] = True
         
-        html_response = convert_markdown_to_html(visible_response)
-        
-        return jsonify({
-            "response_html": html_response,
-            "response_text": visible_response,
-            "audio_url": audio_url
-        })
+        return jsonify(result)
         
     except Exception as e:
-        app.logger.error(f"Chat Error: {e}")
         return jsonify({"error": str(e)}), 500
 
-@app.route('/generate-audio', methods=['POST'])
-def generate_audio():
+@app.route('/download/<filename>')
+def download_audio(filename):
     try:
-        data = request.json
-        text_to_speak = data.get('text')
-
-        if not text_to_speak:
-            return jsonify({"error": "No text provided"}), 400
-
-        cleaned_text = re.sub(r'[\*_`#]', '', text_to_speak)
-        cleaned_text = re.sub(r'\s+', ' ', cleaned_text).strip()
-
-        if not cleaned_text:
-            return jsonify({"error": "Text became empty after cleaning"}), 400
-
-        filename = f"{uuid.uuid4()}.mp3"
-        filepath = os.path.join(AUDIO_FOLDER, filename)
-
-        tts = gTTS(text=cleaned_text, lang='en', slow=False)
-        tts.save(filepath)
-
-        audio_url = f"/static/audio/{filename}"
-        return jsonify({"audio_url": audio_url})
-
-    except Exception as e:
-        app.logger.error(f"Audio Generation Error: {e}")
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/static/audio/<filename>')
-def serve_audio(filename):
-    return send_from_directory(AUDIO_FOLDER, filename)
+        return send_from_directory(AUDIO_FOLDER, filename, as_attachment=True)
+    except FileNotFoundError:
+        return jsonify({"error": "Audio file not found"}), 404
 
 @app.route('/')
 def serve_index():