Delete app.py

app.py

@@ -1,548 +0,0 @@
-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, render_template_string
-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 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]
-            # No real file path, so return None and a lambda that always returns True for uptodate
-            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' # Change this!
-
-# --- 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:
-            # Use a temporary file for the service account credentials
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp_service_account:
-                tmp_service_account.write(service_account_content)
-                tmp_service_account_path = tmp_service_account.name
-
-            try:
-                # Check if a Firebase app is already initialized
-                if not firebase_admin._apps:
-                    cred = credentials.Certificate(tmp_service_account_path)
-                    firebase_admin.initialize_app(cred, {'databaseURL': database_url})
-                self.firebase_db = db
-                self.logger.info("Connected to Firebase successfully")
-            finally:
-                os.unlink(tmp_service_account_path)
-        except Exception as e:
-            self.logger.error(f"Failed to connect to Firebase: {e}")
-            raise
-
-    async def setup_telegram_client(self):
-        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):
-        """Initialize YouTube API client using provided secrets and token path"""
-        creds = None
-        # CORRECTED: Check if the token file exists AND is not empty
-        if os.path.exists(token_path) and os.path.getsize(token_path) > 0:
-            try:
-                creds = Credentials.from_authorized_user_file(token_path, self.SCOPES)
-            except json.JSONDecodeError:
-                # The file exists but is corrupted or empty. Treat as if it doesn't exist.
-                self.logger.warning(f"Token file at {token_path} is corrupted. Will generate a new one.")
-                creds = None
-
-        # If credentials are invalid or don't exist, get new ones
-        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. Starting OAuth flow...")
-                # Write client secrets to a temporary file for the flow
-                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp_secrets:
-                    tmp_secrets.write(client_secrets_content)
-                    tmp_secrets_path = tmp_secrets.name
-
-                try:
-                    flow = InstalledAppFlow.from_client_secrets_file(
-                        tmp_secrets_path,
-                        self.SCOPES
-                    )
-                    # This will print a URL to the console where you need to authenticate
-                    creds = flow.run_local_server(port=0)
-                finally:
-                    os.unlink(tmp_secrets_path) # Clean up temp secrets file
-
-            # Save the new or refreshed credentials for the next run
-            with open(token_path, 'w') as token:
-                token.write(creds.to_json())
-                self.logger.info(f"YouTube token saved to {token_path}")
-
-        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):
-    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)
-                asyncio.run(workflow.process_videos(limit=num_videos))
-                processing_status[run_id] = "Completed."
-            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')
-
-            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=f'token_{run_id}_')
-            os.close(token_fd) # Close descriptor, we only need the path
-
-            thread = threading.Thread(
-                target=run_workflow_in_thread,
-                args=(run_id, config_data, client_secrets_content, service_account_content, num_videos, token_path)
-            )
-            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; }
-        .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; }
-    </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">
-            <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>
-                <small>Download from Project Settings > Service accounts in Firebase.</small>
-            </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>
-                <small>Download from Google Cloud > APIs & Services > Credentials (OAuth 2.0 Client ID for <strong>Desktop App</strong>).</small>
-            </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 (International):</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">Number of Recent 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 originally 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">
-                <small><a href="https://developers.google.com/youtube/v3/docs/videoCategories/list" target="_blank">List of Category IDs</a></small>
-            </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: #fff3cd; border: 1px solid #ffeeba; color: #856404; }
-        .status-Completed { background-color: #d4edda; border: 1px solid #c3e6cb; color: #155724; }
-        .status-Failed, .status-Setup { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
-        .back-link { margin-top: 2em; display: inline-block; }
-        .refresh-info { font-size: 0.9em; color: #6c757d; margin-bottom: 2em; }
-    </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,
-})