Update app.py

app.py

@@ -1,42 +1,29 @@
 import gradio as gr
 import logging
 import traceback
+import time
+import re
+import os
+from functools import wraps, lru_cache
+from dotenv import load_dotenv
+from urllib.parse import urlparse
 
-# Logging configuration
+# Load environment variables
+load_dotenv()
+
+# Enhanced logging configuration
 logging.basicConfig(
     level=logging.INFO, 
-    format='%(asctime)s - %(levelname)s: %(message)s',
+    format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
-        logging.FileHandler('centurion_platform.log'),
+        logging.FileHandler('centurion_platform.log', encoding='utf-8', mode='a'),
         logging.StreamHandler()
     ]
 )
 logger = logging.getLogger(__name__)
 
-# CSS with validation
-def validate_css(css):
-    """
-    Basic CSS validation
-    """
-    required_selectors = [
-        '.header', 
-        '.logo', 
-        '.header-title', 
-        '.container', 
-        '.main-content', 
-        '.iframe-container', 
-        '.nav-grid', 
-        '.nav-card'
-    ]
-    
-    for selector in required_selectors:
-        if selector not in css:
-            logger.warning(f"Missing CSS selector: {selector}")
-    
-    return css
-
-# CSS with enhanced validation
-css = validate_css("""
+# CSS Configuration
+css = """
 * {
     margin: 0;
     padding: 0;
@@ -124,12 +111,109 @@ body {
         grid-template-columns: 1fr;
     }
 }
-""")
+"""
+
+# Performance and security decorators
+def performance_monitor(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        try:
+            result = func(*args, **kwargs)
+            execution_time = time.time() - start
+            logger.info(f"{func.__name__} execution time: {execution_time:.2f} seconds")
+            return result
+        except Exception as e:
+            logger.error(f"Error in {func.__name__}: {e}")
+            logger.error(traceback.format_exc())
+            raise
+    return wrapper
+
+# URL Validation and Sanitization
+@lru_cache(maxsize=100)
+def validate_and_sanitize_url(url):
+    """
+    Comprehensive URL validation and sanitization
+    """
+    try:
+        # Validate URL pattern
+        url_pattern = re.compile(
+            r'^https?://'  # http:// or https://
+            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'  # domain...
+            r'localhost|'  # localhost...
+            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'  # ...or ip
+            r'(?::\d+)?'  # optional port
+            r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+        
+        if not url_pattern.match(url):
+            logger.warning(f"Invalid URL format: {url}")
+            return None
+        
+        # Parse and validate URL
+        parsed_url = urlparse(url)
+        
+        # Whitelist allowed domains
+        allowed_domains = [
+            'noumanjavaid-new-space.hf.space',
+            'noumanjavaid-centurionv2.hf.space',
+            'noumanjavaid-watermark-demo-video.hf.space',
+            'noumanjavaid-centii.hf.space',
+            'localhost'
+        ]
+        
+        if parsed_url.netloc not in allowed_domains:
+            logger.warning(f"Unauthorized domain: {parsed_url.netloc}")
+            return None
+        
+        return url
+    except Exception as e:
+        logger.error(f"URL validation error: {e}")
+        return None
+
+# Platform Configuration
+PLATFORM_CONFIG = {
+    'main_platform_url': os.getenv('MAIN_PLATFORM_URL', 'https://noumanjavaid-centii.hf.space'),
+    'launch_config': {
+        'show_error': True,
+        'show_api': False,
+        'show_tips': False,
+        'height': 800,
+        'analytics_enabled': False,
+        'enable_queue': False,
+        'prevent_thread_lock': True
+    }
+}
 
-# Configuration validation
-def validate_configuration(demo_config):
+# Error Notification (Optional)
+def send_error_notification(error):
+    """
+    Send error notifications via external service
     """
-    Validate Gradio configuration
+    try:
+        import requests
+        
+        webhook_url = os.getenv('ERROR_WEBHOOK_URL')
+        if webhook_url:
+            payload = {
+                "text": f"🚨 Centurion Platform Error: {str(error)}",
+                "blocks": [
+                    {
+                        "type": "section",
+                        "text": {
+                            "type": "mrkdwn",
+                            "text": f"```{traceback.format_exc()}```"
+                        }
+                    }
+                ]
+            }
+            requests.post(webhook_url, json=payload)
+    except Exception as log_error:
+        logger.error(f"Error sending notification: {log_error}")
+
+# Configuration Validation
+def validate_configuration(demo):
+    """
+    Validate Gradio demo configuration
     """
     required_attributes = [
         'title', 
@@ -145,7 +229,7 @@ def validate_configuration(demo_config):
     validation_results = {}
     for attr in required_attributes:
         try:
-            value = getattr(demo_config, attr, None)
+            value = getattr(demo, attr, None)
             validation_results[attr] = value is not None
         except Exception as e:
             logger.error(f"Error validating {attr}: {e}")
@@ -153,88 +237,99 @@ def validate_configuration(demo_config):
     
     return validation_results
 
-# Navigation cards validation
-def validate_navigation_cards(cards):
+@performance_monitor
+def create_demo():
     """
-    Validate navigation card configuration
+    Create Gradio demo with comprehensive validation
     """
-    required_keys = ['icon', 'title', 'url']
-    invalid_cards = []
+    # Navigation Cards with URL Validation
+    cards = [
+        {
+            "icon": "🔍", 
+            "title": "DeepFake Detection", 
+            "url": validate_and_sanitize_url(os.getenv('DEEPFAKE_URL', 'https://noumanjavaid-new-space.hf.space'))
+        },
+        {
+            "icon": "📄", 
+            "title": "Document Analysis", "url": validate_and_sanitize_url(os.getenv('DOCUMENT_URL', 'https://noumanjavaid-centurionv2.hf.space'))
+        },
+        {
+            "icon": "🎥", 
+            "title": "Video Watermarking", 
+            "url": validate_and_sanitize_url(os.getenv('WATERMARK_URL', 'https://noumanjavaid-watermark-demo-video.hf.space'))
+        },
+        {
+            "icon": "🔐", 
+            "title": "Image Authentication", 
+            "url": validate_and_sanitize_url(os.getenv('AUTH_URL', 'https://noumanjavaid-centii.hf.space'))
+        },
+    ]
+    
+    # Validate navigation cards
+    invalid_cards = [card for card in cards if card['url'] is None]
+    if invalid_cards:
+        logger.warning(f"Invalid navigation card URLs: {invalid_cards}")
     
-    for card in cards:
-        missing_keys = [key for key in required_keys if key not in card]
-        if missing_keys:
-            invalid_cards.append({
-                'card': card, 
-                'missing_keys': missing_keys
-            })
+    # Generate HTML for navigation cards
+    html_cards = "".join(
+        f'''
+        <div class="nav-card" role="navigation" aria-label="{card['title']}" tabindex="0">
+            <a href="{card['url']}" target="_blank" rel="noopener noreferrer">
+                {card['icon']} {card['title']}
+            </a>
+        </div>
+        ''' for card in cards if card['url'] is not None
+    )
     
-    return invalid_cards
+    # Create Gradio block
+    with gr.Blocks(css=css, title="Centurion Analysis Platform") as demo:
+        # Header
+        with gr.Row(elem_classes=["header"]):
+            gr.Image(
+                "https://raw.githubusercontent.com/noumanjavaid96/ai-as-an-api/refs/heads/master/image%20(39).png",
+                elem_classes=["logo"],
+                show_label=False,
+                container=False
+            )
+            gr.Markdown("Centurion Analysis", elem_classes=["header-title"])
+        
+        # Main content
+        with gr.Row(elem_classes=["container"]):
+            with gr.Column(elem_classes=["main-content"]):
+                gr.HTML(f'''
+                    <div class="iframe-container">
+                        <iframe 
+                            src="{PLATFORM_CONFIG['main_platform_url']}" 
+                            loading="lazy"
+                            title="Centurion Main Platform"
+                        ></iframe>
+                    </div>
+                ''')
+            
+            # Navigation grid
+            with gr.Row(elem_classes=["nav-grid"]):
+                gr.HTML(html_cards)
 
-def create_demo():
-    """
-    Create Gradio demo with comprehensive validation
-    """
+    return demo
+
+def main():
     try:
-        cards = [
-            {"icon": "🔍", "title": "DeepFake Detection", "url": "https://noumanjavaid-new-space.hf.space"},
-            {"icon": "📄", "title": "Document Analysis", "url": "https://noumanjavaid-centurionv2.hf.space"},
-            {"icon": "🎥", "title": "Video Watermarking", "url": "https://noumanjavaid-watermark-demo-video.hf.space"},
-            {"icon": "🔐", "title": "Image Authentication", "url": "https://noumanjavaid-centii.hf.space"},
-        ]
+        demo = create_demo()
         
-        # Validate navigation cards
-        invalid_cards = validate_navigation_cards(cards)
-        if invalid_cards:
-            logger.warning(f"Invalid navigation cards: {invalid_cards}")
+        # Validate configuration before launching
+        config_validation = validate_configuration(demo)
+        logger.info(f"Configuration Validation: {config_validation}")
         
-        # Generate HTML for navigation cards
-        html_cards = "".join(
-            f'''
-            <div class="nav-card" role="navigation" aria-label="{card['title']}">
-                <a href="{card['url']}" target="_blank">
-                    {card['icon']} {card['title']}
-                </a>
-            </div>
-            ''' for card in cards
-        )
-        
-        # Create Gradio block
-        with gr.Blocks(css=css, title="Centurion Analysis Platform") as demo:
-            # Header
-            with gr.Row(elem_classes=["header"]):
-                gr.Image(
-                    "https://raw.githubusercontent.com/noumanjavaid96/ai-as-an-api/refs/heads/master/image%20(39).png",
-                    elem_classes=["logo"],
-                    show_label=False,
-                    container=False
-                )
-                gr.Markdown("Centurion Analysis", elem_classes=["header-title"])
-            
-            # Main content
-            with gr.Row(elem_classes=["container"]):
-                with gr.Column(elem_classes=["main-content"]):
-                    gr.HTML('''
-                        <div class="iframe-container">
-                            <iframe 
-                                src="https://noumanjavaid-centii.hf.space" 
-                                loading="lazy"
-                                title="Centurion Main Platform"
-                            ></iframe>
-                        </div>
-                    ''')
-                
-                # Navigation grid
-                with gr.Row(elem_classes=["nav-grid"]):
-                    gr.HTML(html_cards)
+        validation_errors = [k for k, v in config_validation.items() if not v]
+        if validation_errors:
+            logger.error(f"Configuration validation failed for: {validation_errors}")
+            raise ValueError(f"Invalid configuration: {validation_errors}")
         
+        demo.launch(**PLATFORM_CONFIG['launch_config'])
+    except Exception as e:
+        logger.critical(f"Application launch failed: {e}")
+        logger.critical(traceback.format_exc())
+        send_error_notification(e)
 
 if __name__ == "__main__":
-    demo.launch(
-        show_error=True,
-        show_api=False,
-        show_tips=False,
-        height=800,
-        analytics_enabled=False,
-        enable_queue=False
-    )
+    main()