Update app.py

app.py

@@ -1,367 +1,192 @@
-from flask import Flask, render_template, request, send_file, jsonify
-from google import genai
-from google.genai import types
-from PIL import Image
-import subprocess
-import tempfile
+from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, send_from_directory
+from flask_sqlalchemy import SQLAlchemy
 import os
-import io
-import shutil
-import base64
+import requests
+from urllib.parse import urlparse
+import logging
 
-app = Flask(__name__)
-
-# --- Cognvstantes ---
-MODEL_SINGLE_GENERATION = "gemini-2.5-pro-exp-03-25"  # Modèle avec "thinking" pour la génération complète
-LATEX_MENTION = r"\vspace{1cm}\noindent\textit{Ce devoir a été généré par Mariam AI. \url{https://mariam-241.vercel.app}}"
-
-# --- Configuration des secrets ---
-# Dans un environnement de production, utilisez les variables d'environnement ou un fichier .env
-GOOGLE_API_KEY = os.environ.get('GOOGLE_API_KEY', '')
-
-# --- Fonctions Utilitaires ---
-
-def check_latex_installation():
-    """Vérifie si pdflatex est accessible dans le PATH système."""
-    try:
-        subprocess.run(['pdflatex', '--version'], capture_output=True, check=True, timeout=10)
-        return True, "✅ Installation LaTeX (pdflatex) trouvée."
-    except (subprocess.CalledProcessError, FileNotFoundError, TimeoutError) as e:
-        return False, f"❌ pdflatex introuvable ou ne répond pas. Veuillez installer une distribution LaTeX (comme TeX Live ou MiKTeX) et vous assurer qu'elle est dans le PATH système. Erreur: {e}"
-
-def initialize_genai_client():
-    """Initialise et retourne le client Google GenAI."""
-    try:
-        if not GOOGLE_API_KEY:
-            return None, "Clé API Google non trouvée dans les variables d'environnement."
-            
-        client = genai.Client(api_key=GOOGLE_API_KEY)
-        return client, "✅ Client Mariam AI initialisé."
-    except Exception as e:
-        return None, f"❌ Erreur lors de l'initialisation du client: {str(e)}"
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def clean_latex(raw_latex_text):
-    """Nettoie le code LaTeX brut potentiellement fourni par Gemini."""
-    if not isinstance(raw_latex_text, str):
-        return ""  # Retourne une chaîne vide si l'entrée n'est pas une chaîne
-
-    cleaned = raw_latex_text.strip()
+app = Flask(__name__)
+app.secret_key = os.environ.get('FLASK_SECRET_KEY', 'une_cle_secrete_par_defaut_pour_dev')
 
-    # Supprime les marqueurs de bloc de code (```latex ... ``` ou ``` ... ```)
-    if cleaned.startswith("```latex"):
-        cleaned = cleaned[8:]
-    elif cleaned.startswith("```"):
-        # Gère le cas où il y a un saut de ligne après ```
-        lines = cleaned.split('\n', 1)
-        if len(lines) > 1:
-            cleaned = lines[1]
-        else:
-            cleaned = cleaned[3:]  # Si pas de saut de ligne, juste enlever ```
+app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://Podcast_owner:npg_gFdMDLO9lVa0@ep-delicate-surf-a4v7wopn-pooler.us-east-1.aws.neon.tech/Podcast?sslmode=require'
 
-    # Supprime les marqueurs de fin de bloc de code
-    if cleaned.endswith("```"):
-        cleaned = cleaned[:-3].strip()  # Enlève ``` et les espaces potentiels avant
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 
-    # Assure que le document commence correctement
-    if not cleaned.startswith("\\documentclass"):
-        # On pourrait choisir de lever une erreur ou de tenter une correction
-        pass
+db = SQLAlchemy(app)
 
-    # Assure que le document se termine exactement par \end{document}
-    end_doc_tag = "\\end{document}"
-    if end_doc_tag in cleaned:
-        end_idx = cleaned.rfind(end_doc_tag) + len(end_doc_tag)
-        cleaned = cleaned[:end_idx]
-    else:
-        # Ajoute seulement si \documentclass est présent pour éviter de créer un doc invalide
-        if cleaned.strip().startswith("\\documentclass"):
-            cleaned += f"\n{end_doc_tag}"
+AUDIO_CACHE_DIR = '/tmp/audio_cache'
+try:
+    os.makedirs(AUDIO_CACHE_DIR, exist_ok=True)
+    logger.info(f"Répertoire de cache audio configuré sur : {AUDIO_CACHE_DIR}")
+except OSError as e:
+    logger.error(f"Impossible de créer le répertoire de cache audio à {AUDIO_CACHE_DIR}: {e}")
 
-    return cleaned.strip()  # Retourne le résultat nettoyé
+class Podcast(db.Model):
+    __tablename__ = 'podcast'
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(200), nullable=False)
+    url = db.Column(db.String(500), nullable=False, unique=True)
+    subject = db.Column(db.String(100), nullable=False)
+    filename_cache = db.Column(db.String(255), nullable=True)
 
-# --- Fonction Principale (API GenAI) ---
+    def __repr__(self):
+        return f'<Podcast {self.name}>'
 
-def generate_complete_latex(client, image_bytes):
-    """
-    Génère une solution complète en LaTeX à partir de l'image en une seule étape.
-    """
+@app.route('/')
+def index():
     try:
-        # Convertir les bytes en image PIL
-        image = Image.open(io.BytesIO(image_bytes))
-        
-        prompt =r"""
-
-
-# RÔLE & OBJECTIF
-
-Tu es un expert en mathématiques et un excellent professeur.
-Ton objectif est de créer la solution complète d'un exercice de mathématiques. Cette solution doit être rédigée de manière à produire un **document final très soigné, clair, et d'aspect professionnel (pense à un rendu LaTeX de haute qualité)**. Tu dois fournir le code source qui permettra de générer ce document.
-
-# CONTEXTE
-
-*   **Input :** L'énoncé de l'exercice de mathématiques (niveau Terminale, système français) sera fourni sous forme de texte, immédiatement après ce prompt.
-*   **Output Attendu :** **Uniquement** le code source nécessaire pour générer le document final. Pas d'explications en dehors de ce code, ni de marqueurs de code (comme ``` ```).
-
-# TÂCHE PRINCIPALE
-
-1.  **Analyse :** Lis et comprends parfaitement l'énoncé de l'exercice fourni.
-2.  **Résolution :** Résous l'exercice de manière exhaustive, en détaillant chaque étape de raisonnement et de calcul.
-3.  **Rédaction du Code Source :** Rédige la solution complète *directement* sous forme de code source. Ce code doit être structuré pour produire un document final qui respecte les standards de qualité décrits ci-dessous.
-
-# QUALITÉ ET PRÉSENTATION ATTENDUES DU DOCUMENT FINAL
-
-*   **Structure Professionnelle :**
-    *   Le document doit avoir une présentation initiale claire (titre de l'exercice, sous-titre, date).
-    *   Une table des matières doit être incluse si la solution est un peu longue.
-    *   Les titres des sections et sous-sections doivent être clairs et bien mis en forme.
-*   **Mise en Valeur Pédagogique :**
-    *   L'énoncé original de l'exercice doit être clairement rappelé au début.
-    *   Utilise des mises en forme distinctes (par exemple, des boîtes ou des styles spécifiques) pour :
-        *   Les définitions ou théorèmes importants.
-        *   Les résultats finaux ou les conclusions clés de chaque question.
-        *   Les remarques, astuces méthodologiques, ou points d'attention.
-        *   Les exemples illustratifs, si besoin.
-*   **Clarté Mathématique :**
-    *   Les formules mathématiques doivent être écrites correctement, alignées et faciles à lire.
-    *   Utilise des notations mathématiques standard et cohérentes (par exemple, pour les ensembles de nombres $\mathbb{R}, \mathbb{N}$, les limites, les dérivées, etc.).
-*   **Lisibilité Générale :**
-    *   Le texte doit être en français, clair et précis.
-    *   La mise en page doit être aérée (paragraphes distincts, espacements).
-*   **Graphiques (si pertinent) :**
-    *   Si l'exercice implique une étude de fonction ou de la géométrie, inclus des graphiques propres et bien légendés (axes, courbes, points importants, asymptotes). Les couleurs doivent être utilisées judicieusement pour améliorer la compréhension.
-
-# CONTENU PÉDAGOGIQUE DE LA SOLUTION
-
-1.  **Rigueur et Justification :** Justifie *chaque* étape de calcul ou de raisonnement.
-2.  **Clarté des Explications :** Explique les "pourquoi" derrière les méthodes utilisées. Utilise un langage mathématique précis.
-3.  **Complétude :** Traite toutes les questions de l'énoncé.
-4.  **Conclusion :** Si pertinent, conclus en résumant les points essentiels.
-
-# CONTRAINTES STRICTES
-
-*   Le seul output doit être le code source brut permettant de générer le document décrit.
-*   Aucun texte avant la première ligne du code source ou après la dernière ligne (sauf la mention spéciale ci-dessous).
-*   Inclus la ligne `{LATEX_MENTION}` juste avant la toute fin du code source.
-
-"""
-
-        response = client.models.generate_content(
-            model=MODEL_SINGLE_GENERATION,
-            contents=[image, prompt],
-            config=genai.types.GenerateContentConfig(
-                temperature=1,
-            ),
-    
-        )
-
-        latex_content_raw = None
-        thinking_content = None
-
-        # Extrait le contenu LaTeX et le raisonnement (thought)
-        if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
-            for part in response.candidates[0].content.parts:
-                if getattr(part, 'thought', None):
-                    thinking_content = part.text
-                else:
-                    latex_content_raw = part.text
-
-        if latex_content_raw:
-            latex_content_cleaned = clean_latex(latex_content_raw)
-            
-            # Vérification supplémentaire : est-ce que la mention obligatoire est présente ?
-            if LATEX_MENTION not in latex_content_cleaned:
-                # Tente de l'insérer avant \end{document}
-                end_doc_tag = "\\end{document}"
-                if end_doc_tag in latex_content_cleaned:
-                    latex_content_cleaned = latex_content_cleaned.replace(end_doc_tag, f"{LATEX_MENTION}\n{end_doc_tag}")
-                else:
-                    # Si \end{document} n'est pas là, ajoute les deux à la fin
-                    latex_content_cleaned += f"\n{LATEX_MENTION}\n{end_doc_tag}"
-                    
-            return latex_content_cleaned, thinking_content, None
+        podcasts = Podcast.query.order_by(Podcast.name).all()
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des podcasts: {e}")
+        flash("Erreur lors du chargement des podcasts depuis la base de données.", "error")
+        podcasts = []
+    return render_template('index.html', podcasts=podcasts)
+
+@app.route('/gestion', methods=['GET', 'POST'])
+def gestion():
+    if request.method == 'POST':
+        name = request.form.get('name')
+        url = request.form.get('url')
+        subject = request.form.get('subject')
+
+        if not name or not url or not subject:
+            flash('Tous les champs sont requis !', 'error')
         else:
-            return None, thinking_content, "Aucun contenu LaTeX n'a été généré par le modèle."
-
-    except genai.types.StopCandidateException as e:
-        return None, None, "❌ Génération stoppée (possible contenu inapproprié)"
+            existing_podcast = Podcast.query.filter_by(url=url).first()
+            if existing_podcast:
+                flash('Un podcast avec cette URL existe déjà.', 'warning')
+            else:
+                try:
+                    new_podcast = Podcast(name=name, url=url, subject=subject)
+                    db.session.add(new_podcast)
+                    db.session.commit()
+                    flash('Podcast ajouté avec succès !', 'success')
+                    return redirect(url_for('gestion'))
+                except Exception as e:
+                    db.session.rollback()
+                    logger.error(f"Erreur lors de l'ajout du podcast: {e}")
+                    flash(f"Erreur lors de l'ajout du podcast: {e}", 'error')
+    
+    try:
+        podcasts = Podcast.query.order_by(Podcast.name).all()
     except Exception as e:
-        return None, None, f"❌ Erreur lors de la génération du LaTeX: {str(e)}"
-
-# --- Fonction de Compilation LaTeX ---
-
-def compile_latex_to_pdf(latex_content):
-    """
-    Compile une chaîne de caractères contenant du code LaTeX en fichier PDF.
-    Utilise un répertoire temporaire pour les fichiers intermédiaires.
-    """
-    if not latex_content:
-        return None, "Impossible de compiler : contenu LaTeX vide."
-
-    # Utilise un répertoire temporaire sécurisé qui sera nettoyé automatiquement
-    with tempfile.TemporaryDirectory() as temp_dir:
-        tex_filename = "solution.tex"
-        pdf_filename = "solution.pdf"
-        tex_filepath = os.path.join(temp_dir, tex_filename)
-        pdf_filepath = os.path.join(temp_dir, pdf_filename)
-        log_filepath = os.path.join(temp_dir, "solution.log")  # Pour le débogage
-
-        # Écrit le contenu LaTeX dans le fichier .tex avec encodage UTF-8
-        try:
-            with open(tex_filepath, "w", encoding="utf-8") as f:
-                f.write(latex_content)
-        except IOError as e:
-            return None, f"❌ Erreur lors de l'écriture du fichier .tex temporaire: {str(e)}"
-
-        # Exécute pdflatex
-        command = [
-            "pdflatex",
-            "-interaction=nonstopmode",
-            f"-output-directory={temp_dir}",
-            f"-jobname={os.path.splitext(pdf_filename)[0]}",  # Nom sans extension
-            tex_filepath
-        ]
-
-        pdf_generated = False
-        compilation_output = ""
+        logger.error(f"Erreur lors de la récupération des podcasts pour la gestion: {e}")
+        flash("Erreur lors du chargement des podcasts pour la gestion.", "error")
+        podcasts = []
         
-        for pass_num in range(1, 3):  # Lance jusqu'à 2 passes
-            try:
-                # Augmentation du timeout pour les compilations potentiellement longues
-                result = subprocess.run(command, capture_output=True, check=True, text=True, encoding='utf-8', errors='replace', timeout=60)
-                compilation_output += f"Passe {pass_num}: Succès\n"
-                
-                # Vérifie si le PDF a été créé après la première passe (au moins)
-                if os.path.exists(pdf_filepath):
-                    pdf_generated = True
+    return render_template('gestion.html', podcasts=podcasts)
 
-            except subprocess.CalledProcessError as e:
-                error_message = f"❌ Erreur lors de la compilation LaTeX (Passe {pass_num}).\n"
-                error_message += f"Code de retour: {e.returncode}\n"
-                error_message += f"Sortie: {e.stdout}\n"
-                error_message += f"Erreurs: {e.stderr}\n"
-                
-                # Essayer de lire le fichier .log pour plus d'infos
+@app.route('/delete_podcast/<int:podcast_id>', methods=['POST'])
+def delete_podcast(podcast_id):
+    try:
+        podcast_to_delete = db.session.get(Podcast, podcast_id)
+        if not podcast_to_delete:
+            flash('Podcast non trouvé.', 'error')
+            return redirect(url_for('gestion'))
+
+        if podcast_to_delete.filename_cache:
+            cached_file_path = os.path.join(AUDIO_CACHE_DIR, podcast_to_delete.filename_cache)
+            if os.path.exists(cached_file_path):
                 try:
-                    with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                        error_message += f"Extrait du fichier log (solution.log):\n{log_file.read()[-2000:]}"
-                except IOError:
-                    error_message += "Impossible de lire le fichier log de LaTeX."
-                
-                return None, error_message
-
-            except subprocess.TimeoutExpired:
-                return None, "❌ La compilation LaTeX a dépassé le délai imparti. Le document est peut-être trop complexe ou contient une boucle infinie."
-            
-            except Exception as e:
-                return None, f"❌ Une erreur inattendue est survenue lors de l'exécution de pdflatex: {str(e)}"
-
-        # Vérifie si le fichier PDF existe après les passes
-        if pdf_generated and os.path.exists(pdf_filepath):
-            try:
-                # Lit le contenu binaire du PDF généré
-                with open(pdf_filepath, "rb") as f:
-                    pdf_data = f.read()
-                return pdf_data, "✅ PDF généré avec succès !"
-            except IOError as e:
-                return None, f"❌ Erreur lors de la lecture du fichier PDF généré: {str(e)}"
+                    os.remove(cached_file_path)
+                    logger.info(f"Fichier cache {podcast_to_delete.filename_cache} supprimé.")
+                except OSError as e:
+                    logger.error(f"Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}: {e}")
+                    flash(f'Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}.', 'error')
+
+        db.session.delete(podcast_to_delete)
+        db.session.commit()
+        flash('Podcast supprimé avec succès.', 'success')
+    except Exception as e:
+        db.session.rollback()
+        logger.error(f"Erreur lors de la suppression du podcast ID {podcast_id}: {e}")
+        flash(f"Erreur lors de la suppression du podcast: {e}", 'error')
+    return redirect(url_for('gestion'))
+
+@app.route('/play/<int:podcast_id>')
+def play_podcast_route(podcast_id):
+    podcast = db.session.get(Podcast, podcast_id)
+
+    if not podcast:
+        logger.warning(f"Tentative de lecture d'un podcast non trouvé: ID {podcast_id}")
+        return jsonify({'error': 'Podcast non trouvé'}), 404
+
+    if podcast.filename_cache:
+        cached_filepath = os.path.join(AUDIO_CACHE_DIR, podcast.filename_cache)
+        if os.path.exists(cached_filepath):
+            logger.info(f"Service du podcast {podcast.id} depuis le cache: {podcast.filename_cache}")
+            audio_url = url_for('serve_cached_audio', filename=podcast.filename_cache)
+            return jsonify({'audio_url': audio_url})
         else:
-            error_message = "❌ Le fichier PDF n'a pas été généré après la compilation LaTeX.\n"
-            # Tenter de lire le log
-            try:
-                with open(log_filepath, "r", encoding="utf-8", errors='replace') as log_file:
-                    error_message += f"Extrait du fichier log (solution.log) après échec de génération PDF:\n{log_file.read()[-2000:]}"
-            except IOError:
-                error_message += "Impossible de lire le fichier log de LaTeX."
-            return None, error_message
-
-# --- Routes Flask ---
+            logger.warning(f"Fichier cache {podcast.filename_cache} pour podcast {podcast.id} non trouvé. Re-téléchargement.")
+            podcast.filename_cache = None
 
-@app.route('/')
-def index():
-    return render_template('index.html')
-
-@app.route('/check-latex', methods=['GET'])
-def check_latex():
-    latex_installed, message = check_latex_installation()
-    return jsonify({
-        'success': latex_installed,
-        'message': message
-    })
-
-@app.route('/check-api', methods=['GET'])
-def check_api():
-    client, message = initialize_genai_client()
-    return jsonify({
-        'success': client is not None,
-        'message': message
-    })
-
-@app.route('/process', methods=['POST'])
-def process():
-    if 'image' not in request.files:
-        return jsonify({'success': False, 'message': 'Aucune image téléchargée'})
-        
-    file = request.files['image']
-    if file.filename == '':
-        return jsonify({'success': False, 'message': 'Aucun fichier sélectionné'})
-    
-    # Lire l'image
-    image_bytes = file.read()
-    
-    # Initialiser le client
-    client, message = initialize_genai_client()
-    if client is None:
-        return jsonify({'success': False, 'message': message})
-    
-    # Générer le LaTeX
-    latex_content, thinking_content, error = generate_complete_latex(client, image_bytes)
-    if error:
-        return jsonify({'success': False, 'message': error})
-        
-    # Compiler en PDF
-    pdf_data, message = compile_latex_to_pdf(latex_content)
-    if pdf_data is None:
-        return jsonify({
-            'success': False, 
-            'message': message,
-            'latex': latex_content,
-            'thinking': thinking_content
-        })
-    
-    # Encoder le PDF en base64 pour le retourner au front-end
-    pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
-    
-    # Retourner les données
-    return jsonify({
-        'success': True,
-        'message': 'PDF généré avec succès',
-        'latex': latex_content,
-        'thinking': thinking_content,
-        'pdf_base64': pdf_base64
-    })
-
-@app.route('/download-pdf', methods=['POST'])
-def download_pdf():
-    if 'pdf_data' not in request.json:
-        return jsonify({'success': False, 'message': 'Données PDF manquantes'})
-    
+    final_cached_filepath = None
     try:
-        pdf_data = base64.b64decode(request.json['pdf_data'])
+        parsed_url = urlparse(podcast.url)
+        path_parts = os.path.splitext(parsed_url.path)
+        extension = path_parts[1] if path_parts[1] else '.audio'
         
-        # Créer un fichier temporaire pour le PDF
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:
-            temp_file.write(pdf_data)
-            temp_path = temp_file.name
+        base_filename = str(podcast.id)
         
-        # Envoyer le fichier
-        return send_file(
-            temp_path,
-            mimetype='application/pdf',
-            as_attachment=True,
-            download_name='solution_mariam_ai.pdf'
-        )
+        logger.info(f"Téléchargement de {podcast.url} pour le podcast ID {podcast.id}")
+        response = requests.get(podcast.url, stream=True, timeout=(10, 60))
+        response.raise_for_status()
+
+        content_type = response.headers.get('Content-Type')
+        if content_type:
+            if 'mpeg' in content_type: extension = '.mp3'
+            elif 'ogg' in content_type: extension = '.ogg'
+            elif 'wav' in content_type: extension = '.wav'
+            elif 'aac' in content_type: extension = '.aac'
+            elif 'mp4' in content_type: extension = '.m4a'
+
+        cached_filename_with_ext = f"{base_filename}{extension}"
+        final_cached_filepath = os.path.join(AUDIO_CACHE_DIR, cached_filename_with_ext)
+
+        with open(final_cached_filepath, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        logger.info(f"Téléchargement terminé: {final_cached_filepath}")
+
+        podcast.filename_cache = cached_filename_with_ext
+        db.session.commit()
+        
+        audio_url = url_for('serve_cached_audio', filename=cached_filename_with_ext)
+        return jsonify({'audio_url': audio_url})
+
+    except requests.exceptions.Timeout:
+        logger.error(f"Timeout lors du téléchargement de {podcast.url}")
+        return jsonify({'error': 'Le téléchargement du podcast a pris trop de temps.'}), 504
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Erreur de téléchargement pour {podcast.url}: {e}")
+        return jsonify({'error': f'Impossible de télécharger le podcast: {e}'}), 500
     except Exception as e:
-        return jsonify({'success': False, 'message': f'Erreur lors du téléchargement: {str(e)}'})
-
-if __name__ == "__main__":
-    app.run(debug=True)
+        db.session.rollback()
+        logger.error(f"Erreur inattendue lors du traitement du podcast {podcast.id}: {e}")
+        return jsonify({'error': f'Erreur inattendue: {e}'}), 500
+    finally:
+        if final_cached_filepath and os.path.exists(final_cached_filepath) and (not podcast or podcast.filename_cache != os.path.basename(final_cached_filepath)):
+            try:
+                os.remove(final_cached_filepath)
+                logger.info(f"Fichier partiel nettoyé : {final_cached_filepath}")
+            except OSError as e_clean:
+                logger.error(f"Erreur lors du nettoyage du fichier partiel {final_cached_filepath}: {e_clean}")
+
+@app.route('/audio_cache/<path:filename>')
+def serve_cached_audio(filename):
+    logger.debug(f"Service du fichier cache: {filename} depuis {AUDIO_CACHE_DIR}")
+    return send_from_directory(AUDIO_CACHE_DIR, filename)
+
+if __name__ == '__main__':
+    with app.app_context():
+        try:
+            db.create_all()
+            logger.info("Tables de base de données vérifiées/créées (si elles n'existaient pas).")
+        except Exception as e:
+            logger.error(f"Erreur lors de la création des tables de la base de données: {e}")
+            logger.error("Assurez-vous que votre serveur PostgreSQL est en cours d'exécution et que la base de données existe.")
+    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))