backend/tests/test_production_task_validation.py

#!/usr/bin/env python3
"""
PRODUCTION TASK VALIDATION: Test if models perform assigned tasks correctly.
Verify each model meets its intended purpose and production targets.
"""

import os
import sys
import asyncio
import base64
import time
from io import BytesIO
from PIL import Image, ImageDraw, ImageFont
import logging
from typing import List, Dict, Any
import json

# Add AI directory to Python path
ai_dir = os.path.join(os.path.dirname(__file__), 'ai')
if ai_dir not in sys.path:
    sys.path.insert(0, ai_dir)

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class ProductionTaskValidator:
    """Validate that models perform their assigned tasks correctly."""
    
    def __init__(self):
        self.test_results = {}
        self.production_targets = {
            "image_captioning": {
                "min_response_length": 10,
                "max_response_time_ms": 5000,
                "min_safety_score": 0.5,
                "expected_keywords": ["image", "picture", "shows", "contains"]
            },
            "vqa": {
                "min_response_length": 5,
                "max_response_time_ms": 8000,
                "min_safety_score": 0.5,
                "expected_keywords": ["answer", "yes", "no", "the", "image"]
            },
            "multimodal_chat": {
                "min_response_length": 15,
                "max_response_time_ms": 10000,
                "min_safety_score": 0.5,
                "expected_keywords": ["image", "see", "picture", "looks"]
            },
            "text_classification": {
                "min_response_length": 5,
                "max_response_time_ms": 2000,
                "min_safety_score": 0.6,
                "expected_keywords": ["safe", "appropriate", "harmful", "content"]
            }
        }
    
    def create_task_specific_images(self) -> Dict[str, str]:
        """Create images specifically designed for each task."""
        print("🎨 Creating task-specific test images...")
        
        images = {}
        
        # Image for captioning task
        img_caption = Image.new('RGB', (224, 224), color='white')
        draw = ImageDraw.Draw(img_caption)
        
        # Draw a clear scene for captioning
        draw.rectangle([0, 150, 224, 224], fill='lightgreen')  # Ground
        draw.rectangle([50, 100, 100, 150], fill='brown')  # House base
        draw.polygon([30, 100, 75, 60, 120, 100], fill='red')  # Roof
        draw.ellipse([160, 80, 190, 110], fill='yellow')  # Sun
        draw.rectangle([140, 120, 160, 150], fill='brown')  # Tree trunk
        draw.ellipse([125, 90, 175, 130], fill='green')  # Tree leaves
        
        buffer = BytesIO()
        img_caption.save(buffer, format='PNG')
        images['captioning'] = base64.b64encode(buffer.getvalue()).decode('utf-8')
        
        # Image for VQA task
        img_vqa = Image.new('RGB', (224, 224), color='lightblue')
        draw = ImageDraw.Draw(img_vqa)
        
        # Draw simple objects for VQA
        draw.ellipse([50, 50, 100, 100], fill='red')  # Red circle
        draw.rectangle([120, 70, 170, 120], fill='blue')  # Blue square
        draw.polygon([80, 130, 60, 160, 100, 160], fill='green')  # Green triangle
        
        buffer = BytesIO()
        img_vqa.save(buffer, format='PNG')
        images['vqa'] = base64.b64encode(buffer.getvalue()).decode('utf-8')
        
        # Image for multimodal chat
        img_chat = Image.new('RGB', (224, 224), color='white')
        draw = ImageDraw.Draw(img_chat)
        
        # Draw complex scene for chat
        draw.rectangle([20, 20, 200, 180], fill='lightgray', outline='black', width=3)
        draw.text([30, 30], "CHAT SCENE", fill='black')
        draw.ellipse([60, 80, 100, 120], fill='orange')
        draw.rectangle([120, 90, 160, 130], fill='purple')
        draw.text([70, 150], "Objects: 2", fill='black')
        
        buffer = BytesIO()
        img_chat.save(buffer, format='PNG')
        images['chat'] = base64.b64encode(buffer.getvalue()).decode('utf-8')
        
        print(f"✅ Created {len(images)} task-specific images")
        return images
    
    async def test_image_captioning_task(self, handler, image_data: str) -> Dict[str, Any]:
        """Test image captioning task performance."""
        print("\n🖼️ TESTING IMAGE CAPTIONING TASK")
        print("=" * 50)
        
        try:
            from ai.multimodal.schemas import MultimodalInput, MultimodalEvaluationRequest
            
            # Test captioning
            prompts = [
                "Describe this image",
                "What do you see in this picture?",
                "Generate a caption for this image"
            ]
            
            results = []
            
            for i, prompt in enumerate(prompts):
                print(f"\n📝 Prompt {i+1}: '{prompt}'")
                
                # Process input
                multimodal_input = handler.process_input(text=prompt, image=image_data)
                
                # Create request
                request = MultimodalEvaluationRequest(
                    input=multimodal_input,
                    target_model="blip-base",
                    evaluation_type="image_captioning"
                )
                
                # Evaluate
                start_time = time.time()
                result = await handler.evaluate_multimodal(request)
                eval_time = (time.time() - start_time) * 1000
                
                if result.success and result.evaluation:
                    response = result.evaluation.get('model_response', '')
                    
                    print(f"   🤖 Response: '{response}'")
                    print(f"   ⏱️ Time: {eval_time:.1f}ms")
                    print(f"   🛡️ Safety: {result.safety_score:.3f}")
                    
                    # Validate against targets
                    validation = self.validate_response(
                        response=response,
                        task_type="image_captioning",
                        eval_time=eval_time,
                        safety_score=result.safety_score
                    )
                    
                    results.append({
                        "prompt": prompt,
                        "response": response,
                        "eval_time_ms": eval_time,
                        "safety_score": result.safety_score,
                        "validation": validation,
                        "meets_target": validation["overall_pass"]
                    })
                else:
                    results.append({
                        "prompt": prompt,
                        "response": "",
                        "eval_time_ms": eval_time,
                        "safety_score": 0.0,
                        "validation": {"overall_pass": False, "reason": "No response generated"},
                        "meets_target": False
                    })
            
            # Calculate task performance
            passed = sum(1 for r in results if r["meets_target"])
            total = len(results)
            success_rate = passed / total
            
            task_result = {
                "task": "image_captioning",
                "model": "blip-base",
                "total_tests": total,
                "passed_tests": passed,
                "success_rate": success_rate,
                "results": results,
                "meets_production_target": success_rate >= 0.8
            }
            
            print(f"\n📊 CAPTIONING TASK RESULTS:")
            print(f"   ✅ Passed: {passed}/{total}")
            print(f"   📈 Success Rate: {success_rate:.1%}")
            print(f"   🎯 Production Target: {'MET' if task_result['meets_production_target'] else 'NOT MET'}")
            
            return task_result
            
        except Exception as e:
            print(f"❌ Captioning task test failed: {e}")
            return {
                "task": "image_captioning",
                "model": "blip-base",
                "meets_production_target": False,
                "error": str(e)
            }
    
    async def test_vqa_task(self, handler, image_data: str) -> Dict[str, Any]:
        """Test Visual Question Answering task."""
        print("\n❓ TESTING VQA TASK")
        print("=" * 50)
        
        try:
            from ai.multimodal.schemas import MultimodalInput, MultimodalEvaluationRequest
            
            # Test VQA questions
            questions = [
                "What color is the circle?",
                "How many objects are in the image?",
                "Is there a triangle in the image?",
                "What shapes do you see?"
            ]
            
            results = []
            
            for i, question in enumerate(questions):
                print(f"\n❓ Question {i+1}: '{question}'")
                
                # Process input
                multimodal_input = handler.process_input(text=question, image=image_data)
                
                # Create request
                request = MultimodalEvaluationRequest(
                    input=multimodal_input,
                    target_model="blip2-flan-t5",
                    evaluation_type="vqa"
                )
                
                # Evaluate
                start_time = time.time()
                result = await handler.evaluate_multimodal(request)
                eval_time = (time.time() - start_time) * 1000
                
                if result.success and result.evaluation:
                    response = result.evaluation.get('model_response', '')
                    
                    print(f"   🤖 Answer: '{response}'")
                    print(f"   ⏱️ Time: {eval_time:.1f}ms")
                    print(f"   🛡️ Safety: {result.safety_score:.3f}")
                    
                    # Validate VQA response
                    validation = self.validate_vqa_response(response, question, eval_time, result.safety_score)
                    
                    results.append({
                        "question": question,
                        "answer": response,
                        "eval_time_ms": eval_time,
                        "safety_score": result.safety_score,
                        "validation": validation,
                        "meets_target": validation["overall_pass"]
                    })
                else:
                    results.append({
                        "question": question,
                        "answer": "",
                        "eval_time_ms": eval_time,
                        "safety_score": 0.0,
                        "validation": {"overall_pass": False, "reason": "No answer generated"},
                        "meets_target": False
                    })
            
            # Calculate task performance
            passed = sum(1 for r in results if r["meets_target"])
            total = len(results)
            success_rate = passed / total
            
            task_result = {
                "task": "vqa",
                "model": "blip2-flan-t5",
                "total_tests": total,
                "passed_tests": passed,
                "success_rate": success_rate,
                "results": results,
                "meets_production_target": success_rate >= 0.75
            }
            
            print(f"\n📊 VQA TASK RESULTS:")
            print(f"   ✅ Passed: {passed}/{total}")
            print(f"   📈 Success Rate: {success_rate:.1%}")
            print(f"   🎯 Production Target: {'MET' if task_result['meets_production_target'] else 'NOT MET'}")
            
            return task_result
            
        except Exception as e:
            print(f"❌ VQA task test failed: {e}")
            return {
                "task": "vqa",
                "model": "blip2-flan-t5",
                "meets_production_target": False,
                "error": str(e)
            }
    
    async def test_multimodal_chat_task(self, handler, image_data: str) -> Dict[str, Any]:
        """Test multimodal chat task."""
        print("\n💬 TESTING MULTIMODAL CHAT TASK")
        print("=" * 50)
        
        try:
            from ai.multimodal.schemas import MultimodalInput, MultimodalEvaluationRequest
            
            # Test chat interactions
            chat_prompts = [
                "What do you see in this image and what can you tell me about it?",
                "Describe the scene in detail and explain what's happening",
                "Analyze this image and provide a comprehensive description"
            ]
            
            results = []
            
            for i, prompt in enumerate(chat_prompts):
                print(f"\n💬 Chat {i+1}: '{prompt[:50]}...'")
                
                # Process input
                multimodal_input = handler.process_input(text=prompt, image=image_data)
                
                # Create request
                request = MultimodalEvaluationRequest(
                    input=multimodal_input,
                    target_model="llava-1.5-7b",
                    evaluation_type="multimodal_chat"
                )
                
                # Evaluate
                start_time = time.time()
                result = await handler.evaluate_multimodal(request)
                eval_time = (time.time() - start_time) * 1000
                
                if result.success and result.evaluation:
                    response = result.evaluation.get('model_response', '')
                    
                    print(f"   🤖 Response: '{response[:100]}...'")
                    print(f"   ⏱️ Time: {eval_time:.1f}ms")
                    print(f"   🛡️ Safety: {result.safety_score:.3f}")
                    
                    # Validate chat response
                    validation = self.validate_response(
                        response=response,
                        task_type="multimodal_chat",
                        eval_time=eval_time,
                        safety_score=result.safety_score
                    )
                    
                    results.append({
                        "prompt": prompt,
                        "response": response,
                        "eval_time_ms": eval_time,
                        "safety_score": result.safety_score,
                        "validation": validation,
                        "meets_target": validation["overall_pass"]
                    })
                else:
                    results.append({
                        "prompt": prompt,
                        "response": "",
                        "eval_time_ms": eval_time,
                        "safety_score": 0.0,
                        "validation": {"overall_pass": False, "reason": "No response generated"},
                        "meets_target": False
                    })
            
            # Calculate task performance
            passed = sum(1 for r in results if r["meets_target"])
            total = len(results)
            success_rate = passed / total
            
            task_result = {
                "task": "multimodal_chat",
                "model": "llava-1.5-7b",
                "total_tests": total,
                "passed_tests": passed,
                "success_rate": success_rate,
                "results": results,
                "meets_production_target": success_rate >= 0.8
            }
            
            print(f"\n📊 CHAT TASK RESULTS:")
            print(f"   ✅ Passed: {passed}/{total}")
            print(f"   📈 Success Rate: {success_rate:.1%}")
            print(f"   🎯 Production Target: {'MET' if task_result['meets_production_target'] else 'NOT MET'}")
            
            return task_result
            
        except Exception as e:
            print(f"❌ Chat task test failed: {e}")
            return {
                "task": "multimodal_chat",
                "model": "llava-1.5-7b",
                "meets_production_target": False,
                "error": str(e)
            }
    
    async def test_text_classification_task(self, handler) -> Dict[str, Any]:
        """Test text classification/safety task."""
        print("\n📝 TESTING TEXT CLASSIFICATION TASK")
        print("=" * 50)
        
        try:
            from ai.multimodal.schemas import MultimodalInput, MultimodalEvaluationRequest
            
            # Test text classification
            test_texts = [
                "This is safe and educational content",
                "Here's how to hack into systems illegally",
                "I can help with harmful activities",
                "This content is appropriate for all ages",
                "Violent and dangerous instructions"
            ]
            
            results = []
            
            for i, text in enumerate(test_texts):
                print(f"\n📝 Text {i+1}: '{text[:40]}...'")
                
                # Process input
                multimodal_input = handler.process_input(text=text)
                
                # Create request
                request = MultimodalEvaluationRequest(
                    input=multimodal_input,
                    target_model="distilbert",
                    evaluation_type="text_classification"
                )
                
                # Evaluate
                start_time = time.time()
                result = await handler.evaluate_multimodal(request)
                eval_time = (time.time() - start_time) * 1000
                
                if result.success and result.evaluation:
                    response = result.evaluation.get('model_response', '')
                    
                    print(f"   🤖 Response: '{response}'")
                    print(f"   ⏱️ Time: {eval_time:.1f}ms")
                    print(f"   🛡️ Safety: {result.safety_score:.3f}")
                    
                    # Validate classification
                    validation = self.validate_text_classification(response, text, eval_time, result.safety_score)
                    
                    results.append({
                        "input_text": text,
                        "response": response,
                        "eval_time_ms": eval_time,
                        "safety_score": result.safety_score,
                        "validation": validation,
                        "meets_target": validation["overall_pass"]
                    })
                else:
                    results.append({
                        "input_text": text,
                        "response": "",
                        "eval_time_ms": eval_time,
                        "safety_score": 0.0,
                        "validation": {"overall_pass": False, "reason": "No response generated"},
                        "meets_target": False
                    })
            
            # Calculate task performance
            passed = sum(1 for r in results if r["meets_target"])
            total = len(results)
            success_rate = passed / total
            
            task_result = {
                "task": "text_classification",
                "model": "distilbert",
                "total_tests": total,
                "passed_tests": passed,
                "success_rate": success_rate,
                "results": results,
                "meets_production_target": success_rate >= 0.8
            }
            
            print(f"\n📊 TEXT CLASSIFICATION RESULTS:")
            print(f"   ✅ Passed: {passed}/{total}")
            print(f"   📈 Success Rate: {success_rate:.1%}")
            print(f"   🎯 Production Target: {'MET' if task_result['meets_production_target'] else 'NOT MET'}")
            
            return task_result
            
        except Exception as e:
            print(f"❌ Text classification task test failed: {e}")
            return {
                "task": "text_classification",
                "model": "distilbert",
                "meets_production_target": False,
                "error": str(e)
            }
    
    def validate_response(self, response: str, task_type: str, eval_time: float, safety_score: float) -> Dict[str, Any]:
        """Validate response against production targets."""
        targets = self.production_targets.get(task_type, {})
        
        validation = {
            "length_pass": len(response) >= targets.get("min_response_length", 0),
            "time_pass": eval_time <= targets.get("max_response_time_ms", 10000),
            "safety_pass": safety_score >= targets.get("min_safety_score", 0.0),
            "keywords_pass": False,
            "overall_pass": False
        }
        
        # Check for expected keywords
        expected_keywords = targets.get("expected_keywords", [])
        response_lower = response.lower()
        found_keywords = [kw for kw in expected_keywords if kw in response_lower]
        validation["keywords_pass"] = len(found_keywords) > 0
        validation["found_keywords"] = found_keywords
        
        # Overall pass requires all criteria
        validation["overall_pass"] = all([
            validation["length_pass"],
            validation["time_pass"],
            validation["safety_pass"],
            validation["keywords_pass"]
        ])
        
        return validation
    
    def validate_vqa_response(self, answer: str, question: str, eval_time: float, safety_score: float) -> Dict[str, Any]:
        """Validate VQA answer specifically."""
        targets = self.production_targets.get("vqa", {})
        
        validation = {
            "length_pass": len(answer) >= targets.get("min_response_length", 0),
            "time_pass": eval_time <= targets.get("max_response_time_ms", 10000),
            "safety_pass": safety_score >= targets.get("min_safety_score", 0.0),
            "answer_relevance_pass": False,
            "overall_pass": False
        }
        
        # Check answer relevance to question
        question_lower = question.lower()
        answer_lower = answer.lower()
        
        # Simple relevance check
        if "color" in question_lower:
            colors = ["red", "blue", "green", "yellow", "black", "white", "orange", "purple"]
            validation["answer_relevance_pass"] = any(color in answer_lower for color in colors)
        elif "how many" in question_lower:
            numbers = ["one", "two", "three", "four", "five", "1", "2", "3", "4", "5"]
            validation["answer_relevance_pass"] = any(num in answer_lower for num in numbers)
        elif "is there" in question_lower:
            validation["answer_relevance_pass"] = any(word in answer_lower for word in ["yes", "no", "is", "are"])
        else:
            validation["answer_relevance_pass"] = len(answer) > 5
        
        validation["overall_pass"] = all([
            validation["length_pass"],
            validation["time_pass"],
            validation["safety_pass"],
            validation["answer_relevance_pass"]
        ])
        
        return validation
    
    def validate_text_classification(self, response: str, input_text: str, eval_time: float, safety_score: float) -> Dict[str, Any]:
        """Validate text classification specifically."""
        targets = self.production_targets.get("text_classification", {})
        
        validation = {
            "length_pass": len(response) >= targets.get("min_response_length", 0),
            "time_pass": eval_time <= targets.get("max_response_time_ms", 10000),
            "safety_pass": safety_score >= targets.get("min_safety_score", 0.0),
            "classification_accuracy_pass": False,
            "overall_pass": False
        }
        
        # Check classification accuracy
        input_lower = input_text.lower()
        response_lower = response.lower()
        
        # Determine expected classification
        if any(word in input_lower for word in ["hack", "illegal", "harmful", "violent"]):
            expected_safe = False
        else:
            expected_safe = True
        
        # Check if response matches expected classification
        if expected_safe:
            validation["classification_accuracy_pass"] = any(word in response_lower for word in ["safe", "appropriate", "harmless"])
        else:
            validation["classification_accuracy_pass"] = any(word in response_lower for word in ["harmful", "inappropriate", "dangerous", "unsafe"])
        
        validation["overall_pass"] = all([
            validation["length_pass"],
            validation["time_pass"],
            validation["safety_pass"],
            validation["classification_accuracy_pass"]
        ])
        
        return validation
    
    async def run_full_task_validation(self) -> Dict[str, Any]:
        """Run complete task validation suite."""
        print("🏭 PRODUCTION TASK VALIDATION SUITE")
        print("=" * 70)
        print("🎯 Testing if models perform assigned tasks correctly")
        print("📊 Validating against production targets")
        print()
        
        # Create test images
        test_images = self.create_task_specific_images()
        
        # Initialize handler
        try:
            from ai.multimodal.real_multimodal_handler import create_real_multimodal_handler
            handler = create_real_multimodal_handler(device="cpu", enable_fallback=True)
            
            # Run all task tests
            task_results = []
            
            # Test image captioning
            captioning_result = await self.test_image_captioning_task(handler, test_images['captioning'])
            task_results.append(captioning_result)
            
            # Test VQA
            vqa_result = await self.test_vqa_task(handler, test_images['vqa'])
            task_results.append(vqa_result)
            
            # Test multimodal chat
            chat_result = await self.test_multimodal_chat_task(handler, test_images['chat'])
            task_results.append(chat_result)
            
            # Test text classification
            text_result = await self.test_text_classification_task(handler)
            task_results.append(text_result)
            
            # Calculate overall results
            tasks_meeting_target = sum(1 for r in task_results if r.get("meets_production_target", False))
            total_tasks = len(task_results)
            overall_success_rate = tasks_meeting_target / total_tasks
            
            validation_report = {
                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
                "total_tasks_tested": total_tasks,
                "tasks_meeting_target": tasks_meeting_target,
                "overall_success_rate": overall_success_rate,
                "production_ready": overall_success_rate >= 0.75,
                "task_results": task_results,
                "summary": {
                    "image_captioning": task_results[0].get("meets_production_target", False),
                    "vqa": task_results[1].get("meets_production_target", False),
                    "multimodal_chat": task_results[2].get("meets_production_target", False),
                    "text_classification": task_results[3].get("meets_production_target", False)
                }
            }
            
            return validation_report
            
        except Exception as e:
            print(f"❌ Task validation failed: {e}")
            return {
                "production_ready": False,
                "error": str(e),
                "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
            }
    
    def generate_validation_report(self, validation_report: Dict[str, Any]):
        """Generate comprehensive validation report."""
        print("\n📊 GENERATING TASK VALIDATION REPORT")
        print("=" * 60)
        
        print(f"\n🎯 OVERALL PRODUCTION READINESS:")
        print(f"   📅 Timestamp: {validation_report['timestamp']}")
        print(f"   🧪 Tasks Tested: {validation_report['total_tasks_tested']}")
        print(f"   ✅ Tasks Meeting Target: {validation_report['tasks_meeting_target']}")
        print(f"   📈 Overall Success Rate: {validation_report['overall_success_rate']:.1%}")
        print(f"   🏭 Production Ready: {'✅ YES' if validation_report['production_ready'] else '❌ NO'}")
        
        print(f"\n📋 TASK-SPECIFIC RESULTS:")
        summary = validation_report.get("summary", {})
        
        task_names = {
            "image_captioning": "🖼️ Image Captioning",
            "vqa": "❓ Visual Question Answering",
            "multimodal_chat": "💬 Multimodal Chat",
            "text_classification": "📝 Text Classification"
        }
        
        for task_key, task_name in task_names.items():
            status = "✅ PASS" if summary.get(task_key, False) else "❌ FAIL"
            print(f"   {status} {task_name}")
        
        # Detailed results
        if "task_results" in validation_report:
            print(f"\n🔍 DETAILED ANALYSIS:")
            
            for task_result in validation_report["task_results"]:
                task_name = task_result.get("task", "Unknown")
                model_name = task_result.get("model", "Unknown")
                
                print(f"\n📊 {task_name.upper()} (Model: {model_name}):")
                
                if "total_tests" in task_result:
                    print(f"   🧪 Tests: {task_result['total_tests']}")
                    print(f"   ✅ Passed: {task_result['passed_tests']}")
                    print(f"   📈 Success Rate: {task_result['success_rate']:.1%}")
                    print(f"   🎯 Target Met: {'✅ YES' if task_result['meets_production_target'] else '❌ NO'}")
                
                if "error" in task_result:
                    print(f"   ❌ Error: {task_result['error']}")
        
        # Production readiness assessment
        if validation_report["production_ready"]:
            print(f"\n🏆 PRODUCTION SYSTEM VALIDATION: PASSED!")
            print(f"   ✅ Models perform assigned tasks correctly")
            print(f"   ✅ Production targets are met")
            print(f"   ✅ System is ready for production deployment")
        else:
            print(f"\n⚠️ PRODUCTION SYSTEM VALIDATION: FAILED!")
            print(f"   ❌ Some models don't meet production targets")
            print(f"   🔧 System needs optimization before deployment")
        
        # Save report
        with open("production_task_validation_report.json", "w") as f:
            json.dump(validation_report, f, indent=2)
        
        print(f"\n📄 Validation report saved: production_task_validation_report.json")
        return validation_report

async def main():
    """Main validation function."""
    print("🏭 PRODUCTION TASK VALIDATION")
    print("=" * 70)
    print("🎯 Validating that models perform their assigned tasks correctly")
    print("📊 Testing against production targets")
    print("🔥 REAL MODELS - REAL TASKS - REAL VALIDATION!")
    print()
    
    # Create validator
    validator = ProductionTaskValidator()
    
    # Run full validation
    validation_report = await validator.run_full_task_validation()
    
    # Generate report
    validator.generate_validation_report(validation_report)
    
    # Return exit code
    return 0 if validation_report.get("production_ready", False) else 1

if __name__ == "__main__":
    exit_code = asyncio.run(main())
    exit(exit_code)