Create app.py

app.py

@@ -0,0 +1,564 @@
+import os
+import asyncio
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+import tempfile
+import threading
+import uuid
+from io import StringIO
+
+# --- Flask and Jinja Imports ---
+from flask import Flask, render_template, request, redirect, url_for, flash
+from jinja2 import BaseLoader, TemplateNotFound
+
+# --- Core Workflow Imports (Embedded) ---
+from telethon import TelegramClient
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from googleapiclient.http import MediaFileUpload
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+import firebase_admin
+from firebase_admin import credentials, db
+
+# --- Custom Exception for Auth Flow ---
+class GoogleAuthError(Exception):
+    pass
+
+# --- Custom Jinja Loader for Embedded Templates ---
+class StringLoader(BaseLoader):
+    """A Jinja loader that loads templates from a dictionary."""
+    def __init__(self, templates):
+        self.templates = templates
+
+    def get_source(self, environment, template):
+        if template in self.templates:
+            source = self.templates[template]
+            return source, None, lambda: True
+        raise TemplateNotFound(template)
+
+# --- Flask App Setup ---
+app = Flask(__name__)
+app.secret_key = 'your_strong_secret_key_change_this_for_production'
+
+# --- In-Memory Storage for Logs & Status ---
+global_logs = {}
+processing_status = {}
+
+# --- Custom Logging Handler for Web Capture ---
+class InMemoryHandler(logging.Handler):
+    """Custom logging handler to capture logs in memory for a specific run."""
+    def __init__(self, run_id):
+        super().__init__()
+        self.run_id = run_id
+
+    def emit(self, record):
+        log_entry = self.format(record)
+        if self.run_id not in global_logs:
+            global_logs[self.run_id] = []
+        global_logs[self.run_id].append(log_entry)
+
+# --- Embedded Core Workflow Code ---
+workflow_logger = logging.getLogger('workflow_logger')
+workflow_logger.setLevel(logging.INFO)
+if not workflow_logger.handlers:
+    workflow_logger.addHandler(logging.StreamHandler())
+
+class TelegramYouTubeWorkflow:
+    def __init__(self, config_dict, logger_instance=None):
+        self.config = config_dict
+        self.logger = logger_instance if logger_instance else workflow_logger
+        self.telegram_client = None
+        self.youtube_service = None
+        self.firebase_db = None
+        self.download_dir = Path(self.config.get('download_directory', 'downloads'))
+        self.download_dir.mkdir(exist_ok=True)
+        self.SCOPES = ['https://www.googleapis.com/auth/youtube.upload']
+
+    def setup_firebase(self, service_account_content, database_url):
+        try:
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+                tmp.write(service_account_content)
+                tmp_path = tmp.name
+            try:
+                if not firebase_admin._apps:
+                    cred = credentials.Certificate(tmp_path)
+                    firebase_admin.initialize_app(cred, {'databaseURL': database_url})
+                self.firebase_db = db
+                self.logger.info("Connected to Firebase successfully")
+            finally:
+                os.unlink(tmp_path)
+        except Exception as e:
+            self.logger.error(f"Failed to connect to Firebase: {e}")
+            raise
+
+    async def setup_telegram_client(self):
+        # ... (rest of the class methods are unchanged)
+        telegram_config = self.config['telegram']
+        self.telegram_client = TelegramClient(
+            'session',
+            telegram_config['api_id'],
+            telegram_config['api_hash']
+        )
+        await self.telegram_client.start(phone=telegram_config['phone_number'])
+        self.logger.info("Connected to Telegram successfully")
+
+    def setup_youtube_client(self, client_secrets_content, token_path, auth_code=None):
+        """Initialize YouTube API client using console flow for headless environments."""
+        creds = None
+        if os.path.exists(token_path) and os.path.getsize(token_path) > 0:
+            creds = Credentials.from_authorized_user_file(token_path, self.SCOPES)
+
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                self.logger.info("Refreshing expired YouTube token...")
+                creds.refresh(Request())
+            else:
+                self.logger.info("No valid YouTube token found. Attempting console auth flow.")
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
+                    tmp.write(client_secrets_content)
+                    secrets_path = tmp.name
+                
+                try:
+                    # Use the out-of-band (oob) redirect URI for the copy-paste flow
+                    flow = InstalledAppFlow.from_client_secrets_file(
+                        secrets_path, self.SCOPES, redirect_uri='urn:ietf:wg:oauth:2.0:oob'
+                    )
+                    
+                    if not auth_code:
+                        # If no code is provided, generate URL and stop
+                        auth_url, _ = flow.authorization_url(prompt='consent')
+                        self.logger.error("="*80)
+                        self.logger.error("USER ACTION REQUIRED FOR AUTHENTICATION:")
+                        self.logger.error(f"\n1. Open this URL in your browser:\n\n{auth_url}\n")
+                        self.logger.error("2. Authenticate and grant permissions.")
+                        self.logger.error("3. Copy the authorization code Google provides.")
+                        self.logger.error("4. Paste the code into the 'Google Auth Code' field on the main page and resubmit.")
+                        self.logger.error("="*80)
+                        raise GoogleAuthError("Authorization code required.")
+                    else:
+                        # If code is provided, fetch the token
+                        self.logger.info("Authorization code provided. Fetching token...")
+                        flow.fetch_token(code=auth_code)
+                        creds = flow.credentials
+                finally:
+                    os.unlink(secrets_path)
+            
+            # Save the new credentials
+            with open(token_path, 'w') as token:
+                token.write(creds.to_json())
+            self.logger.info("YouTube token saved successfully.")
+
+        self.youtube_service = build('youtube', 'v3', credentials=creds)
+        self.logger.info("YouTube API client initialized successfully")
+
+    def is_video_processed(self, telegram_video_id, channel_username):
+        try:
+            ref = self.firebase_db.reference(f'processed_videos/{channel_username}/{telegram_video_id}')
+            return ref.get() is not None
+        except Exception as e:
+            self.logger.error(f"Error checking processed video: {e}")
+            return False
+
+    def save_processed_video(self, telegram_video_id, channel_username, youtube_video_id=None, video_info=None):
+        try:
+            telegram_url = f"https://t.me/{channel_username.lstrip('@')}/{telegram_video_id}"
+            document = {
+                "telegram_video_id": telegram_video_id,
+                "channel_username": channel_username,
+                "telegram_url": telegram_url,
+                "youtube_video_id": youtube_video_id,
+                "processed_at": datetime.utcnow().isoformat(),
+                "status": "uploaded" if youtube_video_id else "failed"
+            }
+            if video_info:
+                document.update({
+                    "video_title": video_info.get('caption', '')[:100],
+                    "video_date": video_info.get('date').isoformat(),
+                    "video_size": getattr(video_info.get('video'), 'size', None),
+                    "video_duration": getattr(video_info.get('video'), 'duration', None)
+                })
+            ref = self.firebase_db.reference(f'processed_videos/{channel_username}/{telegram_video_id}')
+            ref.set(document)
+            self.logger.info(f"Saved processed video info to Firebase: {telegram_url}")
+        except Exception as e:
+            self.logger.error(f"Error saving processed video info: {e}")
+
+    def get_processed_videos_stats(self):
+        try:
+            ref = self.firebase_db.reference('processed_videos')
+            all_videos = ref.get()
+            if not all_videos: return {"total": 0, "uploaded": 0, "failed": 0}
+            total = 0
+            uploaded = 0
+            for channel in all_videos.values():
+                for video in channel.values():
+                    total += 1
+                    if video.get("status") == "uploaded":
+                        uploaded += 1
+            failed = total - uploaded
+            self.logger.info(f"DB stats - Total: {total}, Uploaded: {uploaded}, Failed: {failed}")
+            return {"total": total, "uploaded": uploaded, "failed": failed}
+        except Exception as e:
+            self.logger.error(f"Error getting stats: {e}")
+            return None
+
+    async def get_channel_videos(self, limit=10):
+        channel_username = self.config['telegram']['channel_username']
+        try:
+            entity = await self.telegram_client.get_entity(channel_username)
+            videos = []
+            async for message in self.telegram_client.iter_messages(entity, limit=limit):
+                if message.video and not self.is_video_processed(message.id, channel_username):
+                    videos.append({
+                        'id': message.id, 'message': message, 'video': message.video,
+                        'caption': message.text or '', 'date': message.date,
+                        'telegram_url': f"https://t.me/{channel_username.lstrip('@')}/{message.id}"
+                    })
+            self.logger.info(f"Found {len(videos)} new videos to process.")
+            return videos
+        except Exception as e:
+            self.logger.error(f"Error getting channel videos: {e}")
+            return []
+
+    async def download_video(self, video_info):
+        try:
+            filename = f"video_{video_info['id']}.mp4"
+            filepath = self.download_dir / filename
+            self.logger.info(f"Downloading video {video_info['id']}...")
+            await video_info['message'].download_media(file=str(filepath))
+            self.logger.info(f"Downloaded to: {filepath}")
+            return str(filepath)
+        except Exception as e:
+            self.logger.error(f"Error downloading video {video_info['id']}: {e}")
+            return None
+
+    def upload_to_youtube(self, video_path, video_info):
+        try:
+            video_settings = self.config['video_settings']
+            title = f"{video_settings.get('title_prefix', '')}{video_info['caption'][:100]}" or f"Video from Telegram {video_info['date'].strftime('%Y-%m-%d')}"
+            body = {
+                'snippet': {
+                    'title': title,
+                    'description': f"{video_settings.get('description_template', '')}\n\n{video_info['caption']}",
+                    'tags': video_settings.get('tags', []),
+                    'categoryId': video_settings.get('category_id', '22')
+                },
+                'status': {'privacyStatus': video_settings.get('privacy_status', 'private')}
+            }
+            media = MediaFileUpload(video_path, chunksize=-1, resumable=True)
+            request = self.youtube_service.videos().insert(part=','.join(body.keys()), body=body, media_body=media)
+            
+            self.logger.info(f"Uploading {os.path.basename(video_path)} to YouTube...")
+            response = None
+            while response is None:
+                status, response = request.next_chunk()
+                if status:
+                    self.logger.info(f"Upload progress: {int(status.progress() * 100)}%")
+            
+            self.logger.info(f"Video uploaded successfully! YouTube ID: {response['id']}")
+            return response['id']
+        except HttpError as e:
+            self.logger.error(f"HTTP error during upload: {e.content}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error uploading to YouTube: {e}")
+            return None
+
+    def cleanup_video(self, video_path):
+        try:
+            os.remove(video_path)
+            self.logger.info(f"Cleaned up: {video_path}")
+        except Exception as e:
+            self.logger.error(f"Error cleaning up {video_path}: {e}")
+
+    async def process_videos(self, limit=5):
+        self.logger.info("Starting video processing workflow...")
+        try:
+            await self.setup_telegram_client()
+            self.get_processed_videos_stats()
+            videos = await self.get_channel_videos(limit)
+            if not videos:
+                self.logger.info("No new videos found.")
+                return
+
+            for video_info in videos:
+                video_path = None
+                youtube_id = None
+                try:
+                    self.logger.info(f"Processing video: {video_info['telegram_url']}")
+                    video_path = await self.download_video(video_info)
+                    if video_path:
+                        youtube_id = self.upload_to_youtube(video_path, video_info)
+                except Exception as e:
+                    self.logger.error(f"Unhandled error processing video {video_info['id']}: {e}")
+                finally:
+                    self.save_processed_video(
+                        video_info['id'], self.config['telegram']['channel_username'],
+                        youtube_video_id=youtube_id, video_info=video_info
+                    )
+                    if video_path:
+                        self.cleanup_video(video_path)
+        except Exception as e:
+            self.logger.error(f"Core workflow error: {e}", exc_info=True)
+        finally:
+            if self.telegram_client and self.telegram_client.is_connected():
+                await self.telegram_client.disconnect()
+            self.logger.info("Workflow finished.")
+
+# --- Flask Threading Function ---
+
+def run_workflow_in_thread(run_id, config_data, client_secrets_content, service_account_content, num_videos, token_path, auth_code):
+    log_handler = InMemoryHandler(run_id)
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    log_handler.setFormatter(formatter)
+    workflow_logger.addHandler(log_handler)
+
+    try:
+        processing_status[run_id] = "Running..."
+        with tempfile.TemporaryDirectory() as temp_dir:
+            config_data['download_directory'] = os.path.join(temp_dir, 'downloads')
+            os.makedirs(config_data['download_directory'], exist_ok=True)
+            
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                workflow = TelegramYouTubeWorkflow(config_dict=config_data, logger_instance=workflow_logger)
+                workflow.setup_firebase(service_account_content, config_data['firebase']['database_url'])
+                workflow.setup_youtube_client(client_secrets_content, token_path, auth_code)
+                asyncio.run(workflow.process_videos(limit=num_videos))
+                processing_status[run_id] = "Completed."
+            except GoogleAuthError as e:
+                processing_status[run_id] = f"Authentication Required: {e}"
+                workflow_logger.error(f"Workflow stopped for user authentication.")
+            except Exception as e:
+                processing_status[run_id] = f"Failed: {str(e)}"
+                workflow_logger.error(f"Workflow thread failed: {e}", exc_info=True)
+            finally:
+                os.chdir(original_cwd)
+    except Exception as e:
+        processing_status[run_id] = f"Setup Failed: {str(e)}"
+        workflow_logger.error(f"Thread setup failed: {e}", exc_info=True)
+    finally:
+        workflow_logger.removeHandler(log_handler)
+        log_handler.close()
+
+# --- Flask Routes ---
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        try:
+            # --- Firebase ---
+            firebase_database_url = request.form['firebase_database_url']
+            firebase_service_account_file = request.files['firebase_service_account']
+            if not firebase_service_account_file or firebase_service_account_file.filename == '':
+                flash('Firebase service account file is required.', 'error')
+                return redirect(request.url)
+            service_account_content = firebase_service_account_file.read().decode('utf-8')
+
+            # --- YouTube ---
+            client_secrets_file = request.files['youtube_client_secrets']
+            if not client_secrets_file or client_secrets_file.filename == '':
+                flash('YouTube client secrets file is required.', 'error')
+                return redirect(request.url)
+            client_secrets_content = client_secrets_file.read().decode('utf-8')
+            
+            # --- Google Auth Code (for first run) ---
+            google_auth_code = request.form.get('google_auth_code', '').strip()
+
+            config_data = {
+                "telegram": {
+                    "api_id": int(request.form['telegram_api_id']),
+                    "api_hash": request.form['telegram_api_hash'],
+                    "phone_number": request.form['telegram_phone_number'],
+                    "channel_username": request.form['telegram_channel_username']
+                },
+                "firebase": { "database_url": firebase_database_url },
+                "video_settings": {
+                    "title_prefix": request.form.get('title_prefix', ''),
+                    "description_template": request.form.get('description_template', 'Video from Telegram'),
+                    "tags": [tag.strip() for tag in request.form.get('tags', 'telegram,video').split(',') if tag.strip()],
+                    "category_id": request.form.get('category_id', '22'),
+                    "privacy_status": request.form.get('privacy_status', 'private')
+                }
+            }
+            num_videos = int(request.form.get('num_videos', 5))
+            run_id = str(uuid.uuid4())
+            global_logs[run_id] = []
+            processing_status[run_id] = "Starting..."
+
+            token_fd, token_path = tempfile.mkstemp(suffix='.json', prefix='token_')
+            os.close(token_fd) 
+
+            thread = threading.Thread(
+                target=run_workflow_in_thread,
+                args=(run_id, config_data, client_secrets_content, service_account_content, num_videos, token_path, google_auth_code)
+            )
+            thread.start()
+
+            flash(f'Workflow started with ID: {run_id}', 'info')
+            return redirect(url_for('results', run_id=run_id))
+
+        except ValueError as e:
+            flash(f'Invalid input data: {e}', 'error')
+            return redirect(request.url)
+        except Exception as e:
+            flash(f'Error starting workflow: {e}', 'error')
+            app.logger.error(f"Form processing error: {e}", exc_info=True)
+            return redirect(request.url)
+
+    return render_template('index.html')
+
+@app.route('/results/<run_id>')
+def results(run_id):
+    logs = global_logs.get(run_id, [])
+    status = processing_status.get(run_id, "Not Found")
+    return render_template('results.html', run_id=run_id, logs=logs, status=status)
+
+# --- HTML Templates as Strings ---
+
+index_template_content = '''<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Telegram to YouTube Uploader</title>
+    <style>
+        
+        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; margin: 2em; background-color: #f8f9fa; color: #212529; }
+        .container { max-width: 800px; margin: auto; background: #fff; padding: 2em; border-radius: 0.5em; box-shadow: 0 0 1em rgba(0,0,0,0.1); }
+        h1, h2 { color: #007bff; }
+        h2.auth-header { color: #dc3545; }
+        .form-group { margin-bottom: 1.5em; }
+        label { display: block; margin-bottom: 0.5em; font-weight: bold; }
+        input[type="text"], input[type="number"], input[type="password"], textarea, select {
+            width: 100%; padding: 0.75em; box-sizing: border-box; border: 1px solid #ced4da; border-radius: 0.25em;
+        }
+        button { background-color: #007bff; color: white; padding: 0.75em 1.5em; border: none; cursor: pointer; border-radius: 0.25em; font-size: 1em; }
+        button:hover { background-color: #0056b3; }
+        .flash-messages { margin-bottom: 1.5em; }
+        .flash-message { padding: 1em; margin-bottom: 1em; border-radius: 0.25em; }
+        .flash-message-info { background-color: #d1ecf1; border: 1px solid #bee5eb; color: #0c5460; }
+        .flash-message-error { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
+        small { color: #6c757d; }
+        .auth-box { border: 2px solid #fd7e14; padding: 1em; border-radius: 0.5em; margin-bottom: 1.5em; background-color: #fff3cd; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Telegram to YouTube Uploader</h1>
+        <div class="flash-messages">
+            {% with messages = get_flashed_messages(with_categories=true) %}
+              {% if messages %}
+                {% for category, message in messages %}
+                  <div class="flash-message flash-message-{{ category }}">{{ message }}</div>
+                {% endfor %}
+              {% endif %}
+            {% endwith %}
+        </div>
+        <form method="post" enctype="multipart/form-data">
+            <div class="auth-box">
+                <h2 class="auth-header">Google Authentication</h2>
+                <div class="form-group">
+                    <label for="google_auth_code">Google Auth Code (only needed for first time setup)</label>
+                    <input type="text" id="google_auth_code" name="google_auth_code" placeholder="Paste code here if requested in logs">
+                    <small>If the logs ask for an auth code, paste it here and resubmit the form.</small>
+                </div>
+            </div>
+            
+            <h2>Cloud Settings</h2>
+            <div class="form-group">
+                <label for="firebase_database_url">Firebase Realtime Database URL:</label>
+                <input type="text" id="firebase_database_url" name="firebase_database_url" required placeholder="https://your-project-id-default-rtdb.firebaseio.com">
+            </div>
+            <div class="form-group">
+                <label for="firebase_service_account">Firebase Service Account File (JSON):</label>
+                <input type="file" id="firebase_service_account" name="firebase_service_account" accept=".json" required>
+            </div>
+            <div class="form-group">
+                <label for="youtube_client_secrets">YouTube Client Secrets File (JSON):</label>
+                <input type="file" id="youtube_client_secrets" name="youtube_client_secrets" accept=".json" required>
+            </div>
+
+            <h2>Telegram Settings</h2>
+            <div class="form-group"><label for="telegram_api_id">API ID:</label><input type="number" id="telegram_api_id" name="telegram_api_id" required></div>
+            <div class="form-group"><label for="telegram_api_hash">API Hash:</label><input type="text" id="telegram_api_hash" name="telegram_api_hash" required></div>
+            <div class="form-group"><label for="telegram_phone_number">Phone Number:</label><input type="text" id="telegram_phone_number" name="telegram_phone_number" placeholder="+1234567890" required></div>
+            <div class="form-group"><label for="telegram_channel_username">Channel Username:</label><input type="text" id="telegram_channel_username" name="telegram_channel_username" placeholder="@channelname" required></div>
+            
+            <h2>Processing Settings</h2>
+            <div class="form-group"><label for="num_videos">Videos to Check:</label><input type="number" id="num_videos" name="num_videos" value="5" min="1"></div>
+            <div class="form-group"><label for="title_prefix">YouTube Title Prefix:</label><input type="text" id="title_prefix" name="title_prefix"></div>
+            <div class="form-group"><label for="description_template">Description Template:</label><textarea id="description_template" name="description_template">Video from Telegram.</textarea></div>
+            <div class="form-group"><label for="tags">Tags (comma-separated):</label><input type="text" id="tags" name="tags" value="telegram,video,archive"></div>
+            <div class="form-group">
+                <label for="category_id">Category ID:</label><input type="text" id="category_id" name="category_id" value="22">
+            </div>
+            <div class="form-group">
+                <label for="privacy_status">Privacy Status:</label>
+                <select id="privacy_status" name="privacy_status"><option value="private" selected>Private</option><option value="public">Public</option><option value="unlisted">Unlisted</option></select>
+            </div>
+            <button type="submit">Start Workflow</button>
+        </form>
+    </div>
+</body>
+</html>
+'''
+
+results_template_content = '''<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Workflow Results - {{ run_id }}</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; margin: 2em; background-color: #f8f9fa; color: #212529; }
+        .container { max-width: 900px; margin: auto; background: #fff; padding: 2em; border-radius: 0.5em; box-shadow: 0 0 1em rgba(0,0,0,0.1); }
+        h1, h2 { color: #007bff; }
+        pre { background-color: #e9ecef; padding: 1em; border: 1px solid #ced4da; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word; border-radius: 0.25em; }
+        .status { margin-bottom: 1.5em; padding: 1em; border-radius: 0.25em; font-weight: bold; }
+        .status-Running { background-color: #d1ecf1; border: 1px solid #bee5eb; color: #0c5460; }
+        .status-Completed { background-color: #d4edda; border: 1px solid #c3e6cb; color: #155724; }
+        .status-Failed, .status-Setup, .status-Authentication { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
+        .back-link { margin-top: 2em; display: inline-block; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Workflow Results</h1>
+        <p><strong>Run ID:</strong> {{ run_id }}</p>
+        <div class="status status-{{ status.split(':')[0] }}">
+            <strong>Status:</strong> {{ status }}
+        </div>
+        <div class="refresh-info">
+            <p>Page will auto-refresh every 5 seconds if the job is running.</p>
+        </div>
+        <h2>Logs:</h2>
+        {% if logs %}
+            <pre>{{ logs | join('\\n') }}</pre>
+        {% else %}
+            <p>No logs available yet. The process might be starting up.</p>
+        {% endif %}
+        <a href="{{ url_for('index') }}" class="back-link">Back to Start</a>
+    </div>
+    <script>
+        (function() {
+            const status = "{{ status }}";
+            if (status.includes("Running") || status.includes("Starting")) {
+                setTimeout(function() { location.reload(); }, 5000);
+            }
+        })();
+    </script>
+</body>
+</html>
+'''
+
+# --- Use the custom StringLoader for our embedded templates ---
+app.jinja_loader = StringLoader({
+    'index.html': index_template_content,
+    'results.html': results_template_content,
+})