Bug fixes

flask_app.py

@@ -1,625 +1,62 @@
-# from flask import Flask, render_template, jsonify, request, send_from_directory, send_file, redirect, url_for, session
-# import os, json, threading, time, signal, sys
-# from datetime import datetime
-# from extract_signed_segments_from_annotations import ClipExtractor, VideoClip
-# import logging
-# from dotenv import load_dotenv
-
-# # Load environment variables
-# load_dotenv()
-
-# # Add this near the top with other environment variables
-# bypass_auth = os.getenv('BYPASS_AUTH', 'false').lower() == 'true'
-
-# # Configure logging first
-# logging.basicConfig(
-#     level=logging.INFO,
-#     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-# )
-# logger = logging.getLogger(__name__)
-
-# # Hugging Face specific configuration
-# is_hf_space = os.getenv('SPACE_ID') is not None
-# if is_hf_space:
-#     logger.info("Running in Hugging Face Spaces environment")
-#     # Allow insecure transport for development in HF
-#     os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
-#     # Ensure port is set correctly
-#     os.environ['PORT'] = '7860'
-
-    
-
-# app = Flask(__name__)
-# app.secret_key = os.getenv('SECRET_KEY', 'dev_key_for_testing')
-
-# # Configure session for HF
-# if is_hf_space:
-#     app.config['SESSION_COOKIE_SECURE'] = False
-#     app.config['SESSION_COOKIE_HTTPONLY'] = True
-#     app.config['SESSION_COOKIE_SAMESITE'] = None  # Add this line
-#     app.config['PERMANENT_SESSION_LIFETIME'] = 86400  # 24 hours
-
-# # Directory paths
-# VIDEO_DIR = os.path.abspath("data/videos")
-# ANNOTATIONS_DIR = os.path.abspath("data/annotations")
-# TEMP_DIR = os.path.abspath("data/temp")
-# WORD_TIMESTAMPS_DIR = os.path.abspath("data/word_timestamps")
-# ALIGNMENTS_DIR = os.path.abspath("data/alignments")
-# TRANSCRIPTS_DIR = os.path.abspath("data/transcripts")
-
-# # Ensure all required directories exist
-# for directory in [VIDEO_DIR, ANNOTATIONS_DIR, TEMP_DIR, WORD_TIMESTAMPS_DIR, ALIGNMENTS_DIR, TRANSCRIPTS_DIR]:
-#     os.makedirs(directory, exist_ok=True)
-
-# # Global dictionaries for progress tracking
-# clip_extraction_status = {}
-# transcription_progress_status = {}
-
-# # Graceful shutdown handler
-# def graceful_shutdown(signum, frame):
-#     """Handle graceful shutdown on signals."""
-#     logger.info(f"Received signal {signum}, shutting down gracefully...")
-#     # Clean up as needed here
-#     sys.exit(0)
-
-# # Register signal handlers
-# signal.signal(signal.SIGTERM, graceful_shutdown)
-# signal.signal(signal.SIGINT, graceful_shutdown)
-
-# # Login required decorator
-# def login_required(f):
-#     from functools import wraps
-#     @wraps(f)
-#     def decorated_function(*args, **kwargs):
-#         if 'user' not in session:
-#             logger.info(f"User not in session, redirecting to login")
-#             return redirect(url_for('login'))
-#         return f(*args, **kwargs)
-#     return decorated_function
-
-# # Allow specific users (for testing)
-# def is_allowed_user(username):
-#     allowed_users_env = os.getenv('ALLOWED_USERS', 'Perilon')  # Default to your username
-#     allowed_users = [user.strip() for user in allowed_users_env.split(',')]
-#     return username in allowed_users or not is_hf_space  # Allow all users in local dev
-
-# def update_extraction_progress(video_id, current, total):
-#     percent = int((current / total) * 100)
-#     clip_extraction_status[video_id] = {"current": current, "total": total, "percent": percent}
-
-# def run_clip_extraction(video_id):
-#     try:
-#         base_dir = app.root_path
-#         extractor = ClipExtractor(base_dir)
-#         extractor.extract_clips_from_annotations(
-#             video_id,
-#             progress_callback=lambda current, total: update_extraction_progress(video_id, current, total)
-#         )
-#         if video_id in clip_extraction_status:
-#             status = clip_extraction_status[video_id]
-#             if status.get("percent", 0) < 100:
-#                 update_extraction_progress(video_id, status["total"], status["total"])
-#         else:
-#             update_extraction_progress(video_id, 1, 1)
-#     except Exception as e:
-#         logger.error(f"Error during clip extraction for {video_id}: {str(e)}")
-#         clip_extraction_status[video_id] = {"error": str(e)}
-
-# def run_transcription(video_id):
-#     try:
-#         base_dir = app.root_path
-#         output_path = os.path.join(WORD_TIMESTAMPS_DIR, f"{video_id}_word_timestamps.json")
-
-#         # Check if transcription already exists and is valid.
-#         if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
-#             logger.info(f"Using cached transcription for video {video_id}.")
-#             transcription_progress_status[video_id] = {"status": "completed", "percent": 100}
-#             return
-
-#         video_path = os.path.join(base_dir, "data", "videos", f"{video_id}.mp4")
-#         transcription_progress_status[video_id] = {"status": "started", "percent": 10}
-
-#         # Check if AWS credentials are available
-#         if not os.environ.get('AWS_ACCESS_KEY_ID') or not os.environ.get('AWS_SECRET_ACCESS_KEY'):
-#             logger.warning("AWS credentials not found. Transcription will not work properly.")
-#             transcription_progress_status[video_id] = {
-#                 "status": "error", 
-#                 "percent": 0, 
-#                 "message": "AWS credentials missing"
-#             }
-#             return
-
-#         # Run transcription via the imported function from get_transcription_with_amazon.py
-#         from get_transcription_with_amazon import get_word_timestamps
-#         word_timestamps = get_word_timestamps(video_path)
-
-#         with open(output_path, "w") as f:
-#             json.dump(word_timestamps, f, indent=4)
-
-#         transcription_progress_status[video_id] = {"status": "completed", "percent": 100}
-#     except Exception as e:
-#         logger.error(f"Error during transcription for {video_id}: {str(e)}")
-#         transcription_progress_status[video_id] = {"status": "error", "percent": 0, "message": str(e)}
-
-# # Authentication routes
-# @app.route('/login')
-# def login():
-#     """Handle login for both local and HF environments."""
-#     logger.info(f"Login route called. Headers: {dict(request.headers)}")
-    
-#     if is_hf_space:
-#         username = request.headers.get('X-Spaces-Username')
-#         logger.info(f"Username from headers in login: {username}")
-        
-#         if username and is_allowed_user(username):
-#             session['user'] = {'name': username, 'is_hf': True}
-#             return redirect(url_for('index'))
-#         else:
-#             # Redirect to the HF auth endpoint
-#             return redirect('/auth')
-#     else:
-#         # For local development
-#         session['user'] = {'name': 'LocalDeveloper', 'is_mock': True}
-#         return redirect(url_for('index'))
-
-# @app.route('/auth/callback')
-# def auth_callback():
-#     """This route will be called by Hugging Face after successful authentication."""
-#     logger.info(f"Auth callback called. Headers: {dict(request.headers)}")
-    
-#     if is_hf_space:
-#         # In Hugging Face Spaces, the user info is available in the request headers
-#         username = request.headers.get('X-Spaces-Username')
-#         if username:
-#             session['user'] = {'name': username, 'is_hf': True}
-#             return redirect(url_for('index'))
-#         else:
-#             return render_template('error.html', message="Authentication failed. No username provided.")
-#     return redirect(url_for('login'))
-
-# # Replace the health check route with this improved version
-# @app.route('/health')
-# def health_check():
-#     """Health check endpoint for container verification."""
-#     # Log environment variables for debugging
-#     env_vars = {
-#         "FLASK_ENV": os.environ.get('FLASK_ENV', 'production'),
-#         "DEBUG": os.environ.get('DEBUG', 'Not set'),
-#         "SPACE_ID": os.environ.get('SPACE_ID', 'Not set'),
-#         "BYPASS_AUTH": os.environ.get('BYPASS_AUTH', 'Not set'),
-#         "SECRET_KEY": os.environ.get('SECRET_KEY', 'Not set')[:5] + '...' if os.environ.get('SECRET_KEY') else 'Not set'
-#     }
-    
-#     logger.info(f"Health check called. Environment: {env_vars}")
-    
-#     # Get session information for debugging
-#     session_info = dict(session) if session else None
-#     session_keys = list(session.keys()) if session else []
-    
-#     return jsonify({
-#         "status": "healthy",
-#         "environment": env_vars,
-#         "session_keys": session_keys,
-#         "is_hf_space": is_hf_space,
-#         "bypass_auth": bypass_auth,
-#         "directories": {
-#             "videos": os.path.exists(VIDEO_DIR),
-#             "annotations": os.path.exists(ANNOTATIONS_DIR),
-#             "temp": os.path.exists(TEMP_DIR)
-#         }
-#     })
-
-# @app.route('/auth')
-# def auth():
-#     """This route handles HF authentication."""
-#     logger.info(f"Auth route called. Headers: {dict(request.headers)}")
-    
-#     # Force bypass auth to be true for debugging
-#     bypass_auth = True
-    
-#     # If bypass is enabled, authenticate immediately
-#     if bypass_auth:
-#         logger.info("Auth bypass enabled, setting default user")
-#         session['user'] = {'name': 'Perilon', 'is_hf': True}
-#         return redirect(url_for('index'))
-        
-#     # Normal authentication logic
-#     username = request.headers.get('X-Spaces-Username')
-#     logger.info(f"Username from headers in auth: {username}")
-    
-#     if is_hf_space and username and is_allowed_user(username):
-#         logger.info(f"Setting user in session: {username}")
-#         session['user'] = {'name': username, 'is_hf': True}
-#         return redirect(url_for('index'))
-#     elif not is_hf_space:
-#         # For local development
-#         session['user'] = {'name': 'LocalDeveloper', 'is_mock': True}
-#         return redirect(url_for('index'))
-#     else:
-#         # For HF with no valid username yet
-#         return render_template('error.html', message=
-#             "Waiting for Hugging Face authentication. If you continue to see this message, "
-#             "please make sure you're logged into Hugging Face and your username is allowed.")
-
-# @app.before_request
-# def check_auth():
-#     """Check authentication before processing requests."""
-#     # Skip authentication for certain routes and static files
-#     if request.path in ['/login', '/logout', '/auth', '/auth/callback', '/debug', '/health'] or request.path.startswith('/static/'):
-#         return
-
-#     # Force bypass auth to be true for debugging
-#     bypass_auth = True
-    
-#     # Log all request paths to help troubleshoot
-#     logger.debug(f"Request path: {request.path}, User in session: {'user' in session}")
-    
-#     if bypass_auth:
-#         # Set default user for bypass mode if not already set
-#         if 'user' not in session:
-#             session['user'] = {'name': 'Perilon', 'is_hf': True}
-#         return
-    
-#     if is_hf_space:
-#         # Check for HF username header
-#         username = request.headers.get('X-Spaces-Username')
-        
-#         if 'user' in session:
-#             logger.debug(f"User in session: {session['user']}")
-#             return
-            
-#         if username and is_allowed_user(username):
-#             logger.info(f"Setting user from headers: {username}")
-#             session['user'] = {'name': username, 'is_hf': True}
-#             return
-            
-#         # No valid user in session or headers
-#         logger.info(f"No authenticated user, redirecting to /auth")
-#         return redirect('/auth')
-#     elif 'user' not in session:
-#         return redirect(url_for('login'))
-
-# @app.route('/logout')
-# def logout():
-#     """Clear session and redirect to login."""
-#     session.clear()  # Clear the entire session
-#     if is_hf_space:
-#         return redirect('/auth/logout')
-#     return redirect(url_for('login'))
-
-# @app.route('/debug')
-# def debug_info():
-#     """Return debug information."""
-#     cookies = {key: request.cookies.get(key) for key in request.cookies.keys()}
-    
-#     info = {
-#         "session": dict(session) if session else None,
-#         "headers": dict(request.headers),
-#         "cookies": cookies,
-#         "is_hf_space": is_hf_space,
-#         "allowed_users": os.getenv('ALLOWED_USERS', 'Perilon'),
-#         "app_config": {k: str(v) for k, v in app.config.items() if k in 
-#                       ['SESSION_COOKIE_SECURE', 'SESSION_COOKIE_HTTPONLY', 
-#                        'SESSION_COOKIE_SAMESITE', 'PERMANENT_SESSION_LIFETIME']},
-#     }
-#     return jsonify(info)
-
-# # Main application routes
-# @app.route('/')
-# @login_required
-# def index():
-#     """Main entry point, redirects to video selection."""
-#     return redirect(url_for('select_video'))
-
-# @app.route('/select_video')
-# @login_required
-# def select_video():
-#     """Page to select a video for annotation."""
-#     if not os.path.exists(VIDEO_DIR):
-#         return render_template('error.html', message="Video directory not found.")
-#     videos = [f for f in os.listdir(VIDEO_DIR) if f.endswith('.mp4')]
-#     video_ids = [os.path.splitext(v)[0] for v in videos]
-#     return render_template('select_video.html', video_ids=video_ids, user=session.get('user'))
-
-# @app.route('/player/<video_id>')
-# @login_required
-# def player(video_id):
-#     """Video player page for annotation."""
-#     return render_template('player.html', video_id=video_id, user=session.get('user'))
-
-# @app.route('/videos')
-# @login_required
-# def get_videos():
-#     """API endpoint to get available videos."""
-#     if not os.path.exists(VIDEO_DIR):
-#         return jsonify({'error': 'Video directory not found'}), 404
-#     videos = [f for f in os.listdir(VIDEO_DIR) if f.endswith(('.mp4', '.avi', '.mov'))]
-#     if not videos:
-#         return jsonify({'error': 'No videos found'}), 404
-#     return jsonify(videos)
-
-# @app.route('/video/<path:filename>')
-# @login_required
-# def serve_video(filename):
-#     """Serve a video file."""
-#     if not os.path.exists(os.path.join(VIDEO_DIR, filename)):
-#         return jsonify({'error': 'Video not found'}), 404
-#     return send_from_directory(VIDEO_DIR, filename)
-
-# @app.route('/save_annotations', methods=['POST'])
-# @login_required
-# def save_annotations():
-#     """Save annotation data."""
-#     data = request.json
-#     if not data or 'video' not in data or 'timestamps' not in data:
-#         return jsonify({'success': False, 'message': 'Invalid data'}), 400
-
-#     annotation_file = os.path.join(ANNOTATIONS_DIR, f"{data['video']}_annotations.json")
-#     annotation_data = {
-#         "video_name": data['video'] + ".mp4",
-#         "timestamps": sorted(data['timestamps']),
-#         "annotation_date": datetime.now().isoformat(),
-#         "annotated_by": session.get('user', {}).get('name', 'unknown')
-#     }
-#     with open(annotation_file, 'w') as f:
-#         json.dump(annotation_data, f, indent=4)
-#     return jsonify({'success': True, 'message': 'Annotations saved successfully'})
-
-# @app.route('/get_annotations/<path:video_name>')
-# @login_required
-# def get_annotations(video_name):
-#     """Get annotations for a video."""
-#     annotation_file = os.path.join(ANNOTATIONS_DIR, f"{video_name}_annotations.json")
-#     if not os.path.exists(annotation_file):
-#         return jsonify({'error': 'No annotations found'}), 404
-#     with open(annotation_file, 'r') as f:
-#         annotations = json.load(f)
-#     return jsonify(annotations)
-
-# @app.route("/alignment/<video_id>")
-# @login_required
-# def alignment_mode(video_id):
-#     """Page for aligning sign language with transcribed text."""
-#     annotation_file = os.path.join(ANNOTATIONS_DIR, f"{video_id}_annotations.json")
-#     if not os.path.exists(annotation_file):
-#         return render_template("error.html", message="No annotations found for this video. Please annotate the video first.")
-#     with open(annotation_file, 'r') as f:
-#         annotations = json.load(f)
-#     return render_template(
-#         "alignment.html",
-#         video_id=video_id,
-#         total_clips=len(annotations['timestamps']) - 1,
-#         user=session.get('user')
-#     )
-
-# @app.route("/api/transcript/<video_id>")
-# @login_required
-# def get_transcript(video_id):
-#     """Get transcript for a video."""
-#     timestamps_file = os.path.join(WORD_TIMESTAMPS_DIR, f"{video_id}_word_timestamps.json")
-#     logger.info(f"Attempting to load word timestamps from: {timestamps_file}")
-#     if not os.path.exists(timestamps_file):
-#         logger.warning(f"Word timestamps file not found: {timestamps_file}")
-#         return jsonify({
-#             "status": "error",
-#             "message": "No word timestamps found for this video"
-#         }), 404
-#     try:
-#         with open(timestamps_file, 'r') as f:
-#             word_data = json.load(f)
-#         full_text = " ".join(item["punctuated_word"] for item in word_data)
-#         words_with_times = [{
-#             "word": item["punctuated_word"],
-#             "start": float(item["start_time"]),
-#             "end": float(item["end_time"])
-#         } for item in word_data]
-#         logger.info(f"Successfully created transcript ({len(full_text)} characters)")
-#         return jsonify({
-#             "status": "success",
-#             "text": full_text,
-#             "words": words_with_times
-#         })
-#     except Exception as e:
-#         logger.error(f"Error processing word timestamps: {str(e)}")
-#         return jsonify({
-#             "status": "error",
-#             "message": f"Error processing word timestamps: {str(e)}"
-#         }), 500
-
-# @app.route("/api/word_timestamps/<video_id>")
-# @login_required
-# def get_word_timestamps(video_id):
-#     """Get word-level timestamps for a video."""
-#     timestamps_file = os.path.join(WORD_TIMESTAMPS_DIR, f"{video_id}_word_timestamps.json")
-#     logger.info(f"Attempting to load word timestamps from: {timestamps_file}")
-#     if not os.path.exists(timestamps_file):
-#         logger.warning(f"Word timestamps file not found: {timestamps_file}")
-#         return jsonify({
-#             "status": "error",
-#             "message": "No word timestamps found for this video"
-#         }), 404
-#     try:
-#         with open(timestamps_file, 'r') as f:
-#             word_data = json.load(f)
-#         logger.info(f"Successfully loaded {len(word_data)} word timestamps")
-#         return jsonify({
-#             "status": "success",
-#             "words": word_data
-#         })
-#     except Exception as e:
-#         logger.error(f"Error processing word timestamps: {str(e)}")
-#         return jsonify({
-#             "status": "error",
-#             "message": f"Error processing word timestamps: {str(e)}"
-#         }), 500
-
-# @app.route("/api/clips/<video_id>")
-# @login_required
-# def get_video_clips(video_id):
-#     """Get clips for a video."""
-#     try:
-#         annotation_file = os.path.join(ANNOTATIONS_DIR, f"{video_id}_annotations.json")
-#         if not os.path.exists(annotation_file):
-#             raise FileNotFoundError("Annotations not found")
-#         with open(annotation_file, 'r') as f:
-#             annotations = json.load(f)
-#         timestamps = annotations['timestamps']
-#         clips = []
-#         for i in range(len(timestamps)-1):
-#             clips.append({
-#                 "index": i,
-#                 "start": timestamps[i],
-#                 "end": timestamps[i+1],
-#                 "path": f"/clip/{video_id}/{i}"
-#             })
-#         return jsonify({
-#             "status": "success",
-#             "clips": clips
-#         })
-#     except Exception as e:
-#         logger.error(f"Error getting clips: {str(e)}")
-#         return jsonify({
-#             "status": "error",
-#             "message": str(e)
-#         }), 500
-
-# @app.route("/clip/<video_id>/<int:clip_index>")
-# @login_required
-# def serve_clip(video_id, clip_index):
-#     """Serve a specific clip."""
-#     clip_path = os.path.join(
-#         TEMP_DIR,
-#         f"{video_id}_clip_{clip_index:03d}.mp4"
-#     )
-#     logger.info(f"Attempting to serve clip: {clip_path}")
-#     if not os.path.exists(clip_path):
-#         logger.error(f"Clip not found: {clip_path}")
-#         return jsonify({
-#             "status": "error",
-#             "message": "Clip not found"
-#         }), 404
-#     return send_file(clip_path, mimetype="video/mp4")
-
-# @app.route("/api/save_alignments", methods=["POST"])
-# @login_required
-# def save_alignments():
-#     """Save alignment data."""
-#     try:
-#         data = request.json
-#         if not data or 'video_id' not in data or 'alignments' not in data:
-#             return jsonify({'success': False, 'message': 'Invalid data'}), 400
-
-#         # Add user information to the alignments
-#         for alignment in data['alignments']:
-#             if alignment:
-#                 alignment['aligned_by'] = session.get('user', {}).get('name', 'unknown')
-
-#         output_path = os.path.join(ALIGNMENTS_DIR, f"{data['video_id']}.json")
-#         with open(output_path, "w") as f:
-#             json.dump(data['alignments'], f, indent=2)
-#         return jsonify({
-#             "success": True,
-#             "message": "Alignments saved successfully"
-#         })
-#     except Exception as e:
-#         logger.error(f"Error saving alignments: {str(e)}")
-#         return jsonify({
-#             "success": False,
-#             "message": str(e)
-#         }), 500
-
-# @app.route("/api/extract_clips/<video_id>")
-# @login_required
-# def extract_clips_for_video(video_id):
-#     """Extract clips and start transcription for a video."""
-#     status = clip_extraction_status.get(video_id, {})
-#     if status.get("percent", 0) < 100:
-#         thread = threading.Thread(target=run_clip_extraction, args=(video_id,))
-#         thread.start()
-#     if video_id not in transcription_progress_status or transcription_progress_status.get(video_id, {}).get("percent", 0) < 100:
-#         thread_trans = threading.Thread(target=run_transcription, args=(video_id,))
-#         thread_trans.start()
-#     return jsonify({"status": "started"})
-
-# @app.route("/api/clip_progress/<video_id>")
-# @login_required
-# def clip_progress(video_id):
-#     """Get clip extraction progress."""
-#     progress = clip_extraction_status.get(video_id, {"current": 0, "total": 0, "percent": 0})
-#     return jsonify(progress)
-
-# @app.route("/api/transcription_progress/<video_id>")
-# @login_required
-# def transcription_progress(video_id):
-#     """Get transcription progress."""
-#     progress = transcription_progress_status.get(video_id, {"status": "not started", "percent": 0})
-#     return jsonify(progress)
-
-# if __name__ == '__main__':
-#     try:
-#         # Print diagnostic information
-#         print("=" * 50)
-#         print(f"Starting app with configuration:")
-#         print(f"- Running in HF Space: {is_hf_space}")
-#         print(f"- Auth bypass: {bypass_auth}")
-#         print(f"- Port: {os.getenv('PORT', 5000)}")
-#         print(f"- Available videos: {os.listdir(VIDEO_DIR) if os.path.exists(VIDEO_DIR) else 'None'}")
-#         print("=" * 50)
-        
-#         port = int(os.getenv('PORT', 5000))
-#         app.run(host='0.0.0.0', port=port, debug=True)
-#     except Exception as e:
-#         print(f"Error starting the application: {e}")
-#         import traceback
-#         traceback.print_exc()
-
-
-from flask import Flask, render_template, jsonify, request, send_from_directory, send_file, redirect, url_for, session
-import os, json, threading, time, signal, sys
-from datetime import datetime
-from extract_signed_segments_from_annotations import ClipExtractor, VideoClip
-import logging
-from dotenv import load_dotenv
 import boto3
-from botocore.exceptions import ClientError
+import json
+import logging
+import os
+import platform
+import requests
+import signal
+import sys
 import tempfile
+import threading
+import time
 import uuid
-import requests
+from botocore.exceptions import ClientError
+from datetime import datetime
+from dotenv import load_dotenv
+from extract_signed_segments_from_annotations import ClipExtractor, VideoClip
+from flask import Flask, jsonify, redirect, render_template, request, send_file, send_from_directory, session, url_for
+from typing import Any, Dict, List, Optional
 from urllib.parse import urlparse
 
 # Load environment variables
 load_dotenv()
 
 # Add this near the top with other environment variables
-bypass_auth = os.getenv('BYPASS_AUTH', 'false').lower() == 'true'
+bypass_auth = os.getenv("BYPASS_AUTH", "false").lower() == "true"
 
 # Configure logging first
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 )
 logger = logging.getLogger(__name__)
 
 # Hugging Face specific configuration
-is_hf_space = os.getenv('SPACE_ID') is not None
+is_hf_space = os.getenv("SPACE_ID") is not None
 if is_hf_space:
     logger.info("Running in Hugging Face Spaces environment")
     # Allow insecure transport for development in HF
-    os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
+    os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "1"
     # Ensure port is set correctly
-    os.environ['PORT'] = '7860'
+    os.environ["PORT"] = "7860"
 
-    
+# Debug information
+print("=" * 50)
+print(f"Python version: {sys.version}")
+print(f"Platform: {platform.platform()}")
+print(f"Current directory: {os.getcwd()}")
+print(f"Directory contents: {os.listdir('.')}")
+print("=" * 50)
 
 app = Flask(__name__)
-app.secret_key = os.getenv('SECRET_KEY', 'dev_key_for_testing')
+app.secret_key = os.getenv("SECRET_KEY", "dev_key_for_testing")
 
 # Configure session for HF
 if is_hf_space:
-    app.config['SESSION_COOKIE_SECURE'] = False
-    app.config['SESSION_COOKIE_HTTPONLY'] = True
-    app.config['SESSION_COOKIE_SAMESITE'] = None  # Add this line
-    app.config['PERMANENT_SESSION_LIFETIME'] = 86400  # 24 hours
+    app.config["SESSION_COOKIE_SECURE"] = False
+    app.config["SESSION_COOKIE_HTTPONLY"] = True
+    app.config["SESSION_COOKIE_SAMESITE"] = None  # Add this line
+    app.config["PERMANENT_SESSION_LIFETIME"] = 86400  # 24 hours
 
 # Directory paths
 VIDEO_DIR = os.path.abspath("data/videos")
@@ -630,9 +67,9 @@ ALIGNMENTS_DIR = os.path.abspath("data/alignments")
 TRANSCRIPTS_DIR = os.path.abspath("data/transcripts")
 
 # S3 configuration
-S3_BUCKET = os.getenv('S3_BUCKET', "sorenson-ai-sb-scratch")
-S3_VIDEO_PREFIX = os.getenv('S3_VIDEO_PREFIX', "awilkinson/kylie_dataset_videos_for_alignment_webapp/")
-USE_S3_FOR_VIDEOS = os.getenv('USE_S3_FOR_VIDEOS', 'true').lower() == 'true'
+S3_BUCKET = os.getenv("S3_BUCKET", "sorenson-ai-sb-scratch")
+S3_VIDEO_PREFIX = os.getenv("S3_VIDEO_PREFIX", "awilkinson/kylie_dataset_videos_for_alignment_webapp/")
+USE_S3_FOR_VIDEOS = os.getenv("USE_S3_FOR_VIDEOS", "true").lower() == "true"
 
 # Ensure all required directories exist
 for directory in [VIDEO_DIR, ANNOTATIONS_DIR, TEMP_DIR, WORD_TIMESTAMPS_DIR, ALIGNMENTS_DIR, TRANSCRIPTS_DIR]:
@@ -642,20 +79,22 @@ for directory in [VIDEO_DIR, ANNOTATIONS_DIR, TEMP_DIR, WORD_TIMESTAMPS_DIR, ALI
 clip_extraction_status = {}
 transcription_progress_status = {}
 
+
 # S3 helper functions
 def get_s3_client():
     """Get a boto3 S3 client."""
     return boto3.client(
-        's3',
-        region_name=os.environ.get('AWS_DEFAULT_REGION', 'us-west-2'),
-        aws_access_key_id=os.environ.get('AWS_ACCESS_KEY_ID'),
-        aws_secret_access_key=os.environ.get('AWS_SECRET_ACCESS_KEY')
+        "s3",
+        region_name=os.environ.get("AWS_DEFAULT_REGION", "us-west-2"),
+        aws_access_key_id=os.environ.get("AWS_ACCESS_KEY_ID"),
+        aws_secret_access_key=os.environ.get("AWS_SECRET_ACCESS_KEY")
     )
 
-def list_s3_videos():
+
+def list_s3_videos() -> List[str]:
     """List all videos in the S3 bucket with the given prefix."""
-    if not os.environ.get('AWS_ACCESS_KEY_ID') or not os.environ.get('AWS_SECRET_ACCESS_KEY'):
-        logger.warning("AWS credentials not found. Returning empty video list.")
+    if not os.environ.get("AWS_ACCESS_KEY_ID") or not os.environ.get("AWS_SECRET_ACCESS_KEY"):
+        logger.warning("AWS credentials not found.  Returning empty video list.")
         return []
     
     try:
@@ -665,15 +104,15 @@ def list_s3_videos():
             Prefix=S3_VIDEO_PREFIX
         )
         
-        if 'Contents' not in response:
+        if "Contents" not in response:
             logger.warning(f"No videos found in S3 bucket {S3_BUCKET} with prefix {S3_VIDEO_PREFIX}")
             return []
         
         # Extract video IDs (filenames without extension) from S3 keys
         videos = []
-        for item in response['Contents']:
-            key = item['Key']
-            if key.endswith('.mp4'):
+        for item in response["Contents"]:
+            key = item["Key"]
+            if key.endswith(".mp4"):
                 # Extract just the filename without extension
                 filename = os.path.basename(key)
                 video_id = os.path.splitext(filename)[0]
@@ -684,7 +123,8 @@ def list_s3_videos():
         logger.error(f"Error listing S3 videos: {str(e)}")
         return []
 
-def download_video_from_s3(video_id):
+
+def download_video_from_s3(video_id: str) -> Optional[str]:
     """Download a video from S3 to the local videos directory."""
     video_filename = f"{video_id}.mp4"
     s3_key = f"{S3_VIDEO_PREFIX}{video_filename}"
@@ -705,7 +145,8 @@ def download_video_from_s3(video_id):
         logger.error(f"Error downloading video from S3: {str(e)}")
         return None
 
-def generate_presigned_url(video_id, expiration=3600):
+
+def generate_presigned_url(video_id: str, expiration: int = 3600) -> Optional[str]:
     """Generate a presigned URL for direct access to the video in S3."""
     video_filename = f"{video_id}.mp4"
     s3_key = f"{S3_VIDEO_PREFIX}{video_filename}"
@@ -713,8 +154,8 @@ def generate_presigned_url(video_id, expiration=3600):
     try:
         s3_client = get_s3_client()
         url = s3_client.generate_presigned_url(
-            'get_object',
-            Params={'Bucket': S3_BUCKET, 'Key': s3_key},
+            "get_object",
+            Params={"Bucket": S3_BUCKET, "Key": s3_key},
             ExpiresIn=expiration
         )
         return url
@@ -722,6 +163,7 @@ def generate_presigned_url(video_id, expiration=3600):
         logger.error(f"Error generating presigned URL: {str(e)}")
         return None
 
+
 # Graceful shutdown handler
 def graceful_shutdown(signum, frame):
     """Handle graceful shutdown on signals."""
@@ -729,32 +171,37 @@ def graceful_shutdown(signum, frame):
     # Clean up as needed here
     sys.exit(0)
 
+
 # Register signal handlers
 signal.signal(signal.SIGTERM, graceful_shutdown)
 signal.signal(signal.SIGINT, graceful_shutdown)
 
+
 # Login required decorator
 def login_required(f):
     from functools import wraps
     @wraps(f)
     def decorated_function(*args, **kwargs):
-        if 'user' not in session:
+        if "user" not in session:
             logger.info(f"User not in session, redirecting to login")
-            return redirect(url_for('login'))
+            return redirect(url_for("login"))
         return f(*args, **kwargs)
     return decorated_function
 
+
 # Allow specific users (for testing)
-def is_allowed_user(username):
-    allowed_users_env = os.getenv('ALLOWED_USERS', 'Perilon')  # Default to your username
-    allowed_users = [user.strip() for user in allowed_users_env.split(',')]
+def is_allowed_user(username: str) -> bool:
+    allowed_users_env = os.getenv("ALLOWED_USERS", "Perilon")  # Default to your username
+    allowed_users = [user.strip() for user in allowed_users_env.split(",")]
     return username in allowed_users or not is_hf_space  # Allow all users in local dev
 
-def update_extraction_progress(video_id, current, total):
+
+def update_extraction_progress(video_id: str, current: int, total: int) -> None:
     percent = int((current / total) * 100)
     clip_extraction_status[video_id] = {"current": current, "total": total, "percent": percent}
 
-def run_clip_extraction(video_id):
+
+def run_clip_extraction(video_id: str) -> None:
     try:
         base_dir = app.root_path
         extractor = ClipExtractor(base_dir)
@@ -772,7 +219,8 @@ def run_clip_extraction(video_id):
         logger.error(f"Error during clip extraction for {video_id}: {str(e)}")
         clip_extraction_status[video_id] = {"error": str(e)}
 
-def run_transcription(video_id):
+
+def run_transcription(video_id: str) -> None:
     try:
         base_dir = app.root_path
         output_path = os.path.join(WORD_TIMESTAMPS_DIR, f"{video_id}_word_timestamps.json")
@@ -799,8 +247,8 @@ def run_transcription(video_id):
         transcription_progress_status[video_id] = {"status": "started", "percent": 10}
 
         # Check if AWS credentials are available
-        if not os.environ.get('AWS_ACCESS_KEY_ID') or not os.environ.get('AWS_SECRET_ACCESS_KEY'):
-            logger.warning("AWS credentials not found. Transcription will not work properly.")
+        if not os.environ.get("AWS_ACCESS_KEY_ID") or not os.environ.get("AWS_SECRET_ACCESS_KEY"):
+            logger.warning("AWS credentials not found.  Transcription will not work properly.")
             transcription_progress_status[video_id] = {
                 "status": "error", 
                 "percent": 0, 
@@ -820,58 +268,61 @@ def run_transcription(video_id):
         logger.error(f"Error during transcription for {video_id}: {str(e)}")
         transcription_progress_status[video_id] = {"status": "error", "percent": 0, "message": str(e)}
 
+
 # Authentication routes
-@app.route('/login')
+@app.route("/login")
 def login():
     """Handle login for both local and HF environments."""
-    logger.info(f"Login route called. Headers: {dict(request.headers)}")
+    logger.info(f"Login route called.  Headers: {dict(request.headers)}")
     
     if is_hf_space:
-        username = request.headers.get('X-Spaces-Username')
+        username = request.headers.get("X-Spaces-Username")
         logger.info(f"Username from headers in login: {username}")
         
         if username and is_allowed_user(username):
-            session['user'] = {'name': username, 'is_hf': True}
-            return redirect(url_for('index'))
+            session["user"] = {"name": username, "is_hf": True}
+            return redirect(url_for("index"))
         else:
             # Redirect to the HF auth endpoint
-            return redirect('/auth')
+            return redirect("/auth")
     else:
         # For local development
-        session['user'] = {'name': 'LocalDeveloper', 'is_mock': True}
-        return redirect(url_for('index'))
+        session["user"] = {"name": "LocalDeveloper", "is_mock": True}
+        return redirect(url_for("index"))
 
-@app.route('/auth/callback')
+
+@app.route("/auth/callback")
 def auth_callback():
     """This route will be called by Hugging Face after successful authentication."""
-    logger.info(f"Auth callback called. Headers: {dict(request.headers)}")
+    logger.info(f"Auth callback called.  Headers: {dict(request.headers)}")
     
     if is_hf_space:
         # In Hugging Face Spaces, the user info is available in the request headers
-        username = request.headers.get('X-Spaces-Username')
+        username = request.headers.get("X-Spaces-Username")
         if username:
-            session['user'] = {'name': username, 'is_hf': True}
-            return redirect(url_for('index'))
+            session["user"] = {"name": username, "is_hf": True}
+            return redirect(url_for("index"))
         else:
-            return render_template('error.html', message="Authentication failed. No username provided.")
-    return redirect(url_for('login'))
+            return render_template("error.html", message="Authentication failed.  No username provided.")
+    return redirect(url_for("login"))
+
 
-@app.route('/health')
+@app.route("/health")
 def health_check():
     """Health check endpoint for container verification."""
     # Log environment variables for debugging
     env_vars = {
-        "FLASK_ENV": os.environ.get('FLASK_ENV', 'production'),
-        "DEBUG": os.environ.get('DEBUG', 'Not set'),
-        "SPACE_ID": os.environ.get('SPACE_ID', 'Not set'),
-        "BYPASS_AUTH": os.environ.get('BYPASS_AUTH', 'Not set'),
-        "SECRET_KEY": os.environ.get('SECRET_KEY', 'Not set')[:5] + '...' if os.environ.get('SECRET_KEY') else 'Not set',
-        "S3_BUCKET": os.environ.get('S3_BUCKET', 'Not set'),
-        "S3_VIDEO_PREFIX": os.environ.get('S3_VIDEO_PREFIX', 'Not set'),
-        "USE_S3_FOR_VIDEOS": os.environ.get('USE_S3_FOR_VIDEOS', 'Not set')
+        "FLASK_ENV": os.environ.get("FLASK_ENV", "production"),
+        "DEBUG": os.environ.get("DEBUG", "Not set"),
+        "SPACE_ID": os.environ.get("SPACE_ID", "Not set"),
+        "BYPASS_AUTH": os.environ.get("BYPASS_AUTH", "Not set"),
+        "SECRET_KEY": os.environ.get("SECRET_KEY", "Not set")[:5] + "..." if os.environ.get("SECRET_KEY") else "Not set",
+        "S3_BUCKET": os.environ.get("S3_BUCKET", "Not set"),
+        "S3_VIDEO_PREFIX": os.environ.get("S3_VIDEO_PREFIX", "Not set"),
+        "USE_S3_FOR_VIDEOS": os.environ.get("USE_S3_FOR_VIDEOS", "Not set")
     }
     
-    logger.info(f"Health check called. Environment: {env_vars}")
+    logger.info(f"Health check called.  Environment: {env_vars}")
     
     # Get session information for debugging
     session_info = dict(session) if session else None
@@ -890,10 +341,11 @@ def health_check():
         }
     })
 
-@app.route('/auth')
+
+@app.route("/auth")
 def auth():
     """This route handles HF authentication."""
-    logger.info(f"Auth route called. Headers: {dict(request.headers)}")
+    logger.info(f"Auth route called.  Headers: {dict(request.headers)}")
     
     # Force bypass auth to be true for debugging
     bypass_auth = True
@@ -901,32 +353,33 @@ def auth():
     # If bypass is enabled, authenticate immediately
     if bypass_auth:
         logger.info("Auth bypass enabled, setting default user")
-        session['user'] = {'name': 'Perilon', 'is_hf': True}
-        return redirect(url_for('index'))
+        session["user"] = {"name": "Perilon", "is_hf": True}
+        return redirect(url_for("index"))
         
     # Normal authentication logic
-    username = request.headers.get('X-Spaces-Username')
+    username = request.headers.get("X-Spaces-Username")
     logger.info(f"Username from headers in auth: {username}")
     
     if is_hf_space and username and is_allowed_user(username):
         logger.info(f"Setting user in session: {username}")
-        session['user'] = {'name': username, 'is_hf': True}
-        return redirect(url_for('index'))
+        session["user"] = {"name": username, "is_hf": True}
+        return redirect(url_for("index"))
     elif not is_hf_space:
         # For local development
-        session['user'] = {'name': 'LocalDeveloper', 'is_mock': True}
-        return redirect(url_for('index'))
+        session["user"] = {"name": "LocalDeveloper", "is_mock": True}
+        return redirect(url_for("index"))
     else:
         # For HF with no valid username yet
-        return render_template('error.html', message=
-            "Waiting for Hugging Face authentication. If you continue to see this message, "
+        return render_template("error.html", message=
+            "Waiting for Hugging Face authentication.  If you continue to see this message, "
             "please make sure you're logged into Hugging Face and your username is allowed.")
 
+
 @app.before_request
 def check_auth():
     """Check authentication before processing requests."""
     # Skip authentication for certain routes and static files
-    if request.path in ['/login', '/logout', '/auth', '/auth/callback', '/debug', '/health'] or request.path.startswith('/static/'):
+    if request.path in ["/login", "/logout", "/auth", "/auth/callback", "/debug", "/health"] or request.path.startswith("/static/"):
         return
 
     # Force bypass auth to be true for debugging
@@ -937,38 +390,40 @@ def check_auth():
     
     if bypass_auth:
         # Set default user for bypass mode if not already set
-        if 'user' not in session:
-            session['user'] = {'name': 'Perilon', 'is_hf': True}
+        if "user" not in session:
+            session["user"] = {"name": "Perilon", "is_hf": True}
         return
     
     if is_hf_space:
         # Check for HF username header
-        username = request.headers.get('X-Spaces-Username')
+        username = request.headers.get("X-Spaces-Username")
         
-        if 'user' in session:
+        if "user" in session:
             logger.debug(f"User in session: {session['user']}")
             return
             
         if username and is_allowed_user(username):
             logger.info(f"Setting user from headers: {username}")
-            session['user'] = {'name': username, 'is_hf': True}
+            session["user"] = {"name": username, "is_hf": True}
             return
             
         # No valid user in session or headers
         logger.info(f"No authenticated user, redirecting to /auth")
-        return redirect('/auth')
-    elif 'user' not in session:
-        return redirect(url_for('login'))
+        return redirect("/auth")
+    elif "user" not in session:
+        return redirect(url_for("login"))
 
-@app.route('/logout')
+
+@app.route("/logout")
 def logout():
     """Clear session and redirect to login."""
     session.clear()  # Clear the entire session
     if is_hf_space:
-        return redirect('/auth/logout')
-    return redirect(url_for('login'))
+        return redirect("/auth/logout")
+    return redirect(url_for("login"))
+
 
-@app.route('/debug')
+@app.route("/debug")
 def debug_info():
     """Return debug information."""
     cookies = {key: request.cookies.get(key) for key in request.cookies.keys()}
@@ -978,10 +433,10 @@ def debug_info():
         "headers": dict(request.headers),
         "cookies": cookies,
         "is_hf_space": is_hf_space,
-        "allowed_users": os.getenv('ALLOWED_USERS', 'Perilon'),
+        "allowed_users": os.getenv("ALLOWED_USERS", "Perilon"),
         "app_config": {k: str(v) for k, v in app.config.items() if k in 
-                      ['SESSION_COOKIE_SECURE', 'SESSION_COOKIE_HTTPONLY', 
-                       'SESSION_COOKIE_SAMESITE', 'PERMANENT_SESSION_LIFETIME']},
+                      ["SESSION_COOKIE_SECURE", "SESSION_COOKIE_HTTPONLY", 
+                       "SESSION_COOKIE_SAMESITE", "PERMANENT_SESSION_LIFETIME"]},
         "s3_config": {
             "S3_BUCKET": S3_BUCKET,
             "S3_VIDEO_PREFIX": S3_VIDEO_PREFIX,
@@ -990,14 +445,16 @@ def debug_info():
     }
     return jsonify(info)
 
+
 # Main application routes
-@app.route('/')
+@app.route("/")
 @login_required
 def index():
     """Main entry point, redirects to video selection."""
-    return redirect(url_for('select_video'))
+    return redirect(url_for("select_video"))
+
 
-@app.route('/select_video')
+@app.route("/select_video")
 @login_required
 def select_video():
     """Page to select a video for annotation."""
@@ -1005,38 +462,41 @@ def select_video():
         video_ids = list_s3_videos()
     else:
         if not os.path.exists(VIDEO_DIR):
-            return render_template('error.html', message="Video directory not found.")
-        videos = [f for f in os.listdir(VIDEO_DIR) if f.endswith('.mp4')]
+            return render_template("error.html", message="Video directory not found.")
+        videos = [f for f in os.listdir(VIDEO_DIR) if f.endswith(".mp4")]
         video_ids = [os.path.splitext(v)[0] for v in videos]
     
-    return render_template('select_video.html', video_ids=video_ids, user=session.get('user'))
+    return render_template("select_video.html", video_ids=video_ids, user=session.get("user"))
+
 
-@app.route('/player/<video_id>')
+@app.route("/player/<video_id>")
 @login_required
 def player(video_id):
     """Video player page for annotation."""
-    return render_template('player.html', video_id=video_id, user=session.get('user'))
+    return render_template("player.html", video_id=video_id, user=session.get("user"))
 
-@app.route('/videos')
+
+@app.route("/videos")
 @login_required
 def get_videos():
     """API endpoint to get available videos."""
     if USE_S3_FOR_VIDEOS:
         videos = list_s3_videos()
         if not videos:
-            return jsonify({'error': 'No videos found in S3'}), 404
+            return jsonify({"error": "No videos found in S3"}), 404
         # Return just the filenames with .mp4 extension for compatibility
         return jsonify([f"{vid}.mp4" for vid in videos])
     else:
         # Original local file behavior
         if not os.path.exists(VIDEO_DIR):
-            return jsonify({'error': 'Video directory not found'}), 404
-        videos = [f for f in os.listdir(VIDEO_DIR) if f.endswith(('.mp4', '.avi', '.mov'))]
+            return jsonify({"error": "Video directory not found"}), 404
+        videos = [f for f in os.listdir(VIDEO_DIR) if f.endswith((".mp4", ".avi", ".mov"))]
         if not videos:
-            return jsonify({'error': 'No videos found'}), 404
+            return jsonify({"error": "No videos found"}), 404
         return jsonify(videos)
 
-@app.route('/video/<path:filename>')
+
+@app.route("/video/<path:filename>")
 @login_required
 def serve_video(filename):
     """Serve a video file from S3 or local storage."""
@@ -1053,59 +513,63 @@ def serve_video(filename):
         if local_path and os.path.exists(local_path):
             return send_from_directory(VIDEO_DIR, filename)
         
-        return jsonify({'error': 'Video not found in S3'}), 404
+        return jsonify({"error": "Video not found in S3"}), 404
     else:
         # Original local file behavior
         if not os.path.exists(os.path.join(VIDEO_DIR, filename)):
-            return jsonify({'error': 'Video not found'}), 404
+            return jsonify({"error": "Video not found"}), 404
         return send_from_directory(VIDEO_DIR, filename)
 
-@app.route('/save_annotations', methods=['POST'])
+
+@app.route("/save_annotations", methods=["POST"])
 @login_required
 def save_annotations():
     """Save annotation data."""
     data = request.json
-    if not data or 'video' not in data or 'timestamps' not in data:
-        return jsonify({'success': False, 'message': 'Invalid data'}), 400
+    if not data or "video" not in data or "timestamps" not in data:
+        return jsonify({"success": False, "message": "Invalid data"}), 400
 
     annotation_file = os.path.join(ANNOTATIONS_DIR, f"{data['video']}_annotations.json")
     annotation_data = {
-        "video_name": data['video'] + ".mp4",
-        "timestamps": sorted(data['timestamps']),
+        "video_name": data["video"] + ".mp4",
+        "timestamps": sorted(data["timestamps"]),
         "annotation_date": datetime.now().isoformat(),
-        "annotated_by": session.get('user', {}).get('name', 'unknown')
+        "annotated_by": session.get("user", {}).get("name", "unknown")
     }
-    with open(annotation_file, 'w') as f:
+    with open(annotation_file, "w") as f:
         json.dump(annotation_data, f, indent=4)
-    return jsonify({'success': True, 'message': 'Annotations saved successfully'})
+    return jsonify({"success": True, "message": "Annotations saved successfully"})
+
 
-@app.route('/get_annotations/<path:video_name>')
+@app.route("/get_annotations/<path:video_name>")
 @login_required
 def get_annotations(video_name):
     """Get annotations for a video."""
     annotation_file = os.path.join(ANNOTATIONS_DIR, f"{video_name}_annotations.json")
     if not os.path.exists(annotation_file):
-        return jsonify({'error': 'No annotations found'}), 404
-    with open(annotation_file, 'r') as f:
+        return jsonify({"error": "No annotations found"}), 404
+    with open(annotation_file, "r") as f:
         annotations = json.load(f)
     return jsonify(annotations)
 
+
 @app.route("/alignment/<video_id>")
 @login_required
 def alignment_mode(video_id):
     """Page for aligning sign language with transcribed text."""
     annotation_file = os.path.join(ANNOTATIONS_DIR, f"{video_id}_annotations.json")
     if not os.path.exists(annotation_file):
-        return render_template("error.html", message="No annotations found for this video. Please annotate the video first.")
-    with open(annotation_file, 'r') as f:
+        return render_template("error.html", message="No annotations found for this video.  Please annotate the video first.")
+    with open(annotation_file, "r") as f:
         annotations = json.load(f)
     return render_template(
         "alignment.html",
         video_id=video_id,
-        total_clips=len(annotations['timestamps']) - 1,
-        user=session.get('user')
+        total_clips=len(annotations["timestamps"]) - 1,
+        user=session.get("user")
     )
 
+
 @app.route("/api/transcript/<video_id>")
 @login_required
 def get_transcript(video_id):
@@ -1119,7 +583,7 @@ def get_transcript(video_id):
             "message": "No word timestamps found for this video"
         }), 404
     try:
-        with open(timestamps_file, 'r') as f:
+        with open(timestamps_file, "r") as f:
             word_data = json.load(f)
         full_text = " ".join(item["punctuated_word"] for item in word_data)
         words_with_times = [{
@@ -1140,6 +604,7 @@ def get_transcript(video_id):
             "message": f"Error processing word timestamps: {str(e)}"
         }), 500
 
+
 @app.route("/api/word_timestamps/<video_id>")
 @login_required
 def get_word_timestamps(video_id):
@@ -1153,7 +618,7 @@ def get_word_timestamps(video_id):
             "message": "No word timestamps found for this video"
         }), 404
     try:
-        with open(timestamps_file, 'r') as f:
+        with open(timestamps_file, "r") as f:
             word_data = json.load(f)
         logger.info(f"Successfully loaded {len(word_data)} word timestamps")
         return jsonify({
@@ -1167,6 +632,7 @@ def get_word_timestamps(video_id):
             "message": f"Error processing word timestamps: {str(e)}"
         }), 500
 
+
 @app.route("/api/clips/<video_id>")
 @login_required
 def get_video_clips(video_id):
@@ -1175,9 +641,9 @@ def get_video_clips(video_id):
         annotation_file = os.path.join(ANNOTATIONS_DIR, f"{video_id}_annotations.json")
         if not os.path.exists(annotation_file):
             raise FileNotFoundError("Annotations not found")
-        with open(annotation_file, 'r') as f:
+        with open(annotation_file, "r") as f:
             annotations = json.load(f)
-        timestamps = annotations['timestamps']
+        timestamps = annotations["timestamps"]
         clips = []
         for i in range(len(timestamps)-1):
             clips.append({
@@ -1197,6 +663,7 @@ def get_video_clips(video_id):
             "message": str(e)
         }), 500
 
+
 @app.route("/clip/<video_id>/<int:clip_index>")
 @login_required
 def serve_clip(video_id, clip_index):
@@ -1214,23 +681,24 @@ def serve_clip(video_id, clip_index):
         }), 404
     return send_file(clip_path, mimetype="video/mp4")
 
+
 @app.route("/api/save_alignments", methods=["POST"])
 @login_required
 def save_alignments():
     """Save alignment data."""
     try:
         data = request.json
-        if not data or 'video_id' not in data or 'alignments' not in data:
-            return jsonify({'success': False, 'message': 'Invalid data'}), 400
+        if not data or "video_id" not in data or "alignments" not in data:
+            return jsonify({"success": False, "message": "Invalid data"}), 400
 
         # Add user information to the alignments
-        for alignment in data['alignments']:
+        for alignment in data["alignments"]:
             if alignment:
-                alignment['aligned_by'] = session.get('user', {}).get('name', 'unknown')
+                alignment["aligned_by"] = session.get("user", {}).get("name", "unknown")
 
         output_path = os.path.join(ALIGNMENTS_DIR, f"{data['video_id']}.json")
         with open(output_path, "w") as f:
-            json.dump(data['alignments'], f, indent=2)
+            json.dump(data["alignments"], f, indent=2)
         return jsonify({
             "success": True,
             "message": "Alignments saved successfully"
@@ -1242,6 +710,7 @@ def save_alignments():
             "message": str(e)
         }), 500
 
+
 @app.route("/api/extract_clips/<video_id>")
 @login_required
 def extract_clips_for_video(video_id):
@@ -1264,6 +733,7 @@ def extract_clips_for_video(video_id):
         thread_trans.start()
     return jsonify({"status": "started"})
 
+
 @app.route("/api/clip_progress/<video_id>")
 @login_required
 def clip_progress(video_id):
@@ -1271,6 +741,7 @@ def clip_progress(video_id):
     progress = clip_extraction_status.get(video_id, {"current": 0, "total": 0, "percent": 0})
     return jsonify(progress)
 
+
 @app.route("/api/transcription_progress/<video_id>")
 @login_required
 def transcription_progress(video_id):
@@ -1278,16 +749,15 @@ def transcription_progress(video_id):
     progress = transcription_progress_status.get(video_id, {"status": "not started", "percent": 0})
     return jsonify(progress)
 
-if __name__ == '__main__':
-    port = int(os.getenv('PORT', 7860))
-    app.run(host='0.0.0.0', port=port)
+
+if __name__ == "__main__":
     try:
         # Print diagnostic information
         print("=" * 50)
         print(f"Starting app with configuration:")
         print(f"- Running in HF Space: {is_hf_space}")
         print(f"- Auth bypass: {bypass_auth}")
-        print(f"- Port: {os.getenv('PORT', 5000)}")
+        print(f"- Port: {os.getenv('PORT', 7860)}")
         print(f"- S3 for videos: {USE_S3_FOR_VIDEOS}")
         print(f"- S3 bucket: {S3_BUCKET}")
         print(f"- S3 prefix: {S3_VIDEO_PREFIX}")
@@ -1300,8 +770,8 @@ if __name__ == '__main__':
                 print(f"- Error listing S3 videos: {str(e)}")
         print("=" * 50)
         
-        port = int(os.getenv('PORT', 5000))
-        app.run(host='0.0.0.0', port=port, debug=True)
+        port = int(os.getenv("PORT", 7860))
+        app.run(host="0.0.0.0", port=port, debug=True)
     except Exception as e:
         print(f"Error starting the application: {e}")
         import traceback

pig.txt

@@ -2,120 +2,131 @@ Building webapp
 #0 building with "default" instance using docker driver
 
 #1 [internal] load build definition from Dockerfile
-#1 transferring dockerfile: 1.19kB done
+#1 transferring dockerfile: 1.30kB done
 #1 DONE 0.0s
 
 #2 [internal] load metadata for docker.io/library/python:3.9-slim
-#2 DONE 0.3s
+#2 DONE 0.5s
 
 #3 [internal] load .dockerignore
 #3 transferring context: 2B done
 #3 DONE 0.0s
 
-#4 [1/9] FROM docker.io/library/python:3.9-slim@sha256:d1fd807555208707ec95b284afd10048d0737e84b5f2d6fdcbed2922b9284b56
+#4 [ 1/12] FROM docker.io/library/python:3.9-slim@sha256:d1fd807555208707ec95b284afd10048d0737e84b5f2d6fdcbed2922b9284b56
 #4 DONE 0.0s
 
 #5 [internal] load build context
-#5 transferring context: 19.78kB 0.0s done
+#5 transferring context: 170.74kB 0.0s done
 #5 DONE 0.0s
 
-#6 [2/9] WORKDIR /app
+#6 [ 4/12] RUN pip install --no-cache-dir -r requirements.txt
 #6 CACHED
 
-#7 [3/9] COPY requirements.txt .
+#7 [ 2/12] WORKDIR /app
 #7 CACHED
 
-#8 [4/9] RUN pip install --no-cache-dir -r requirements.txt
+#8 [ 3/12] COPY requirements.txt .
 #8 CACHED
 
-#9 [5/9] RUN apt-get update && apt-get install -y ffmpeg wget git && apt-get clean
+#9 [ 5/12] RUN apt-get update && apt-get install -y ffmpeg wget git && apt-get clean
 #9 CACHED
 
-#10 [6/9] RUN mkdir -p /home/user &&     chown -R 1000:1000 /home/user
+#10 [ 6/12] RUN mkdir -p /home/user &&     chown -R 1000:1000 /home/user
 #10 CACHED
 
-#11 [7/9] COPY . .
-#11 DONE 0.3s
-
-#12 [8/9] RUN mkdir -p data/videos data/annotations data/temp data/word_timestamps data/alignments data/transcripts
-#12 DONE 0.1s
-
-#13 [9/9] RUN ls -la /app &&     ls -la /app/flask_app.py &&     which gunicorn &&     pip list
-#13 0.170 total 148
-#13 0.170 drwxr-xr-x 1 root root  4096 Feb 27 21:59 .
-#13 0.170 drwxr-xr-x 1 root root  4096 Feb 27 21:59 ..
-#13 0.170 -rw-rw-r-- 1 root root   202 Feb 27 21:42 .env
-#13 0.170 drwxrwxr-x 8 root root  4096 Feb 27 21:59 .git
-#13 0.170 -rw-rw-r-- 1 root root  1519 Feb 26 22:49 .gitattributes
-#13 0.170 -rw-rw-r-- 1 root root    72 Feb 26 23:20 .gitignore
-#13 0.170 -rw-rw-r-- 1 root root   403 Feb 27 21:50 .hf-space
-#13 0.170 drwxrwxr-x 2 root root  4096 Feb 26 22:51 .space
-#13 0.170 -rw-rw-r-- 1 root root  1151 Feb 27 21:58 Dockerfile
-#13 0.170 -rw-rw-r-- 1 root root   804 Feb 26 22:54 README.md
-#13 0.170 -rw-rw-r-- 1 root root   904 Feb 26 22:50 check_large_files_linux.sh
-#13 0.170 drwxrwxr-x 9 root root  4096 Feb 26 22:50 data
-#13 0.170 -rw-rw-r-- 1 root root   571 Feb 27 21:42 docker-compose.yml
-#13 0.170 -rw-rw-r-- 1 root root 10867 Feb 27 21:42 extract_signed_segments_from_annotations.py
-#13 0.170 -rw-rw-r-- 1 root root 51619 Feb 27 21:51 flask_app.py
-#13 0.170 -rw-rw-r-- 1 root root  6704 Feb 27 21:42 get_transcription_with_amazon.py
-#13 0.170 -rw-rw-r-- 1 root root   258 Feb 27 21:59 pig.txt
-#13 0.170 -rw-rw-r-- 1 root root    66 Feb 27 17:46 requirements.txt
-#13 0.170 drwxrwxr-x 2 root root  4096 Feb 26 22:50 static
-#13 0.170 drwxrwxr-x 2 root root  4096 Feb 27 21:56 templates
-#13 0.170 -rw-rw-r-- 1 root root  5569 Feb 26 22:50 tree.txt
-#13 0.171 -rw-rw-r-- 1 root root 51619 Feb 27 21:51 /app/flask_app.py
-#13 0.172 /usr/local/bin/gunicorn
-#13 0.499 WARNING: The directory '/home/user/.cache/pip' or its parent directory is not owned or is not writable by the current user. The cache has been disabled. Check the permissions and owner of that directory. If executing pip with sudo, you should use sudo's -H flag.
-#13 0.544 Package            Version
-#13 0.544 ------------------ -----------
-#13 0.544 Authlib            1.5.0
-#13 0.544 blinker            1.9.0
-#13 0.544 boto3              1.37.2
-#13 0.545 botocore           1.37.2
-#13 0.545 certifi            2025.1.31
-#13 0.545 cffi               1.17.1
-#13 0.545 charset-normalizer 3.4.1
-#13 0.545 click              8.1.8
-#13 0.545 cryptography       44.0.1
-#13 0.546 ffmpeg-python      0.2.0
-#13 0.546 Flask              3.1.0
-#13 0.546 future             1.0.0
-#13 0.546 gunicorn           23.0.0
-#13 0.546 idna               3.10
-#13 0.546 importlib_metadata 8.6.1
-#13 0.547 itsdangerous       2.2.0
-#13 0.547 Jinja2             3.1.5
-#13 0.547 jmespath           1.0.1
-#13 0.547 MarkupSafe         3.0.2
-#13 0.547 packaging          24.2
-#13 0.547 pip                23.0.1
-#13 0.547 pycparser          2.22
-#13 0.548 python-dateutil    2.9.0.post0
-#13 0.548 python-dotenv      1.0.1
-#13 0.548 requests           2.32.3
-#13 0.548 s3transfer         0.11.3
-#13 0.548 setuptools         58.1.0
-#13 0.548 six                1.17.0
-#13 0.549 urllib3            1.26.20
-#13 0.549 Werkzeug           3.1.3
-#13 0.549 wheel              0.45.1
-#13 0.549 zipp               3.21.0
-#13 0.719 
-#13 0.719 [notice] A new release of pip is available: 23.0.1 -> 25.0.1
-#13 0.719 [notice] To update, run: pip install --upgrade pip
-#13 DONE 0.8s
-
-#14 exporting to image
-#14 exporting layers
-#14 exporting layers 0.5s done
-#14 writing image sha256:f71a97e216e67b0ebb92ed1a322fb6e703b2be41f2f0e9c2a51e21a67d0f3a96 done
-#14 naming to docker.io/library/vsl_boundary_annotation_and_alignment_tool_webapp done
-#14 DONE 0.5s
+#11 [ 7/12] RUN mkdir -p data/videos data/annotations data/temp data/word_timestamps data/alignments data/transcripts
+#11 DONE 0.2s
+
+#12 [ 8/12] COPY . .
+#12 DONE 0.3s
+
+#13 [ 9/12] COPY entrypoint.sh /app/
+#13 DONE 0.0s
+
+#14 [10/12] RUN chmod +x /app/entrypoint.sh
+#14 DONE 0.1s
+
+#15 [11/12] RUN chmod -R 755 /app &&     chmod -R 777 /app/data
+#15 DONE 0.9s
+
+#16 [12/12] RUN ls -la /app &&     ls -la /app/flask_app.py &&     which gunicorn &&     pip list
+#16 0.179 total 172
+#16 0.179 drwxr-xr-x 1 root root  4096 Feb 27 23:30 .
+#16 0.179 drwxr-xr-x 1 root root  4096 Feb 27 23:30 ..
+#16 0.179 -rwxr-xr-x 1 root root   202 Feb 27 23:14 .env
+#16 0.179 drwxr-xr-x 1 root root  4096 Feb 27 23:30 .git
+#16 0.179 -rwxr-xr-x 1 root root  1519 Feb 26 22:49 .gitattributes
+#16 0.179 -rwxr-xr-x 1 root root    72 Feb 26 23:20 .gitignore
+#16 0.179 -rwxr-xr-x 1 root root   403 Feb 27 23:14 .hf-space
+#16 0.179 drwxr-xr-x 1 root root  4096 Feb 26 22:51 .space
+#16 0.179 -rwxr-xr-x 1 root root  1257 Feb 27 23:22 Dockerfile
+#16 0.179 -rwxr-xr-x 1 root root   804 Feb 26 22:54 README.md
+#16 0.179 -rwxr-xr-x 1 root root     0 Feb 27 23:21 __init__.py
+#16 0.179 -rwxr-xr-x 1 root root   904 Feb 26 22:50 check_large_files_linux.sh
+#16 0.179 drwxrwxrwx 1 root root  4096 Feb 26 22:50 data
+#16 0.179 -rwxr-xr-x 1 root root   571 Feb 27 23:14 docker-compose.yml
+#16 0.179 -rwxr-xr-x 1 root root   312 Feb 27 23:22 entrypoint.sh
+#16 0.179 -rwxr-xr-x 1 root root 10867 Feb 27 23:14 extract_signed_segments_from_annotations.py
+#16 0.179 -rwxr-xr-x 1 root root 51698 Feb 27 23:21 flask_app.py
+#16 0.179 -rwxr-xr-x 1 root root  6815 Feb 27 23:14 get_transcription_with_amazon.py
+#16 0.179 -rwxr-xr-x 1 root root   258 Feb 27 23:30 pig.txt
+#16 0.179 -rwxr-xr-x 1 root root    66 Feb 27 23:14 requirements.txt
+#16 0.179 drwxr-xr-x 1 root root  4096 Feb 26 22:50 static
+#16 0.179 drwxr-xr-x 1 root root  4096 Feb 27 23:30 templates
+#16 0.179 -rwxr-xr-x 1 root root  5569 Feb 26 22:50 tree.txt
+#16 0.180 -rwxr-xr-x 1 root root 51698 Feb 27 23:21 /app/flask_app.py
+#16 0.181 /usr/local/bin/gunicorn
+#16 0.509 WARNING: The directory '/home/user/.cache/pip' or its parent directory is not owned or is not writable by the current user. The cache has been disabled. Check the permissions and owner of that directory. If executing pip with sudo, you should use sudo's -H flag.
+#16 0.554 Package            Version
+#16 0.554 ------------------ -----------
+#16 0.554 Authlib            1.5.0
+#16 0.554 blinker            1.9.0
+#16 0.555 boto3              1.37.2
+#16 0.555 botocore           1.37.2
+#16 0.555 certifi            2025.1.31
+#16 0.555 cffi               1.17.1
+#16 0.555 charset-normalizer 3.4.1
+#16 0.555 click              8.1.8
+#16 0.556 cryptography       44.0.1
+#16 0.556 ffmpeg-python      0.2.0
+#16 0.556 Flask              3.1.0
+#16 0.556 future             1.0.0
+#16 0.556 gunicorn           23.0.0
+#16 0.556 idna               3.10
+#16 0.556 importlib_metadata 8.6.1
+#16 0.557 itsdangerous       2.2.0
+#16 0.557 Jinja2             3.1.5
+#16 0.557 jmespath           1.0.1
+#16 0.557 MarkupSafe         3.0.2
+#16 0.557 packaging          24.2
+#16 0.557 pip                23.0.1
+#16 0.558 pycparser          2.22
+#16 0.558 python-dateutil    2.9.0.post0
+#16 0.558 python-dotenv      1.0.1
+#16 0.558 requests           2.32.3
+#16 0.558 s3transfer         0.11.3
+#16 0.558 setuptools         58.1.0
+#16 0.559 six                1.17.0
+#16 0.559 urllib3            1.26.20
+#16 0.559 Werkzeug           3.1.3
+#16 0.559 wheel              0.45.1
+#16 0.559 zipp               3.21.0
+#16 0.730 
+#16 0.730 [notice] A new release of pip is available: 23.0.1 -> 25.0.1
+#16 0.730 [notice] To update, run: pip install --upgrade pip
+#16 DONE 0.8s
+
+#17 exporting to image
+#17 exporting layers
+#17 exporting layers 0.6s done
+#17 writing image sha256:7783d4fd70349562f507d3734fb83e77d9df5ec0145f4eb87d9ec8ccf30dbda3 done
+#17 naming to docker.io/library/vsl_boundary_annotation_and_alignment_tool_webapp done
+#17 DONE 0.6s
 
  2 warnings found (use docker --debug to expand):
- - SecretsUsedInArgOrEnv: Do not use ARG or ENV instructions for sensitive data (ENV "SECRET_KEY") (line 25)
- - SecretsUsedInArgOrEnv: Do not use ARG or ENV instructions for sensitive data (ENV "BYPASS_AUTH") (line 24)
-Recreating 3aed3e7bb19b_vsl_boundary_annotation_and_alignment_tool_webapp_1 ... 
+ - SecretsUsedInArgOrEnv: Do not use ARG or ENV instructions for sensitive data (ENV "SECRET_KEY") (line 36)
+ - SecretsUsedInArgOrEnv: Do not use ARG or ENV instructions for sensitive data (ENV "BYPASS_AUTH") (line 35)
+Recreating 3aed3e7bb19b_vsl_boundary_annotation_and_alignment_tool_webapp_1 ... 
 
 ERROR: for 3aed3e7bb19b_vsl_boundary_annotation_and_alignment_tool_webapp_1  'ContainerConfig'