Update app.py

app.py

@@ -7,10 +7,6 @@ from datetime import datetime, timedelta
 from typing import Dict, Any, List, Optional
 from pydantic import BaseModel, Field
 import gradio as gr
-from crewai import Agent, Crew, Process, Task, LLM
-from crewai.agent import agent
-from crewai.task import task
-from crewai.crew import crew, CrewBase
 
 # Setup logging
 logging.basicConfig(
@@ -19,12 +15,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Initialize LLM (will use environment variable)
-llm = LLM(
-    model="gemini/gemini-2.0-flash-exp",  # or any other model
-    api_key=os.getenv("GEMINI_API_KEY", "dummy-key-for-testing"),
-)
-
 # ========== DATA MODELS ==========
 class UserVerification(BaseModel):
     user_id: str = Field(..., description="User ID")
@@ -87,181 +77,174 @@ class MockDatabase:
 # Initialize mock database
 mock_db = MockDatabase()
 
-# ========== CREW CLASS ==========
-class AntiScalpingCrew(CrewBase):
-    """Anti-Scalping Ticketing System Crew"""
-    
-    @agent
-    def user_verification_agent(self) -> Agent:
-        return Agent(
-            role="User Verification Specialist",
-            goal="Verify user identity and assess verification level for ticket purchases",
-            backstory="""You are an expert in Know Your Customer (KYC) processes and identity 
-            verification. You assess user documentation, verify identities, and assign risk scores 
-            based on user history and verification completeness. You ensure only legitimate users 
-            can purchase tickets while maintaining a smooth user experience.""",
-            llm=llm,
-            verbose=True
-        )
-    
-    @agent
-    def scalping_detection_agent(self) -> Agent:
-        return Agent(
-            role="Scalping Detection Analyst",
-            goal="Detect and prevent ticket scalping through behavioral analysis",
-            backstory="""You are a specialized analyst focused on identifying scalping patterns. 
-            You analyze purchase velocity, IP addresses, buying patterns, and other behavioral 
-            indicators to detect potential scalpers. Your expertise helps maintain fair ticket 
-            distribution and prevents automated bot purchases.""",
-            llm=llm,
-            verbose=True
-        )
-    
-    @agent
-    def dynamic_pricing_agent(self) -> Agent:
-        return Agent(
-            role="Dynamic Pricing Strategist",
-            goal="Calculate fair resale prices based on demand while preventing price gouging",
-            backstory="""You are an expert in market dynamics and pricing strategies. You analyze 
-            demand levels, market conditions, and event popularity to recommend fair resale prices. 
-            You balance market forces with consumer protection, ensuring prices reflect true demand 
-            without enabling exploitative pricing.""",
-            llm=llm,
-            verbose=True
-        )
-    
-    @agent
-    def resale_monitor_agent(self) -> Agent:
-        return Agent(
-            role="Resale Compliance Officer",
-            goal="Monitor and enforce resale policies to ensure fair ticket distribution",
-            backstory="""You are responsible for ensuring all ticket resales comply with platform 
-            policies and local regulations. You monitor resale prices, frequency, and patterns to 
-            prevent policy violations. Your work ensures the secondary ticket market remains fair 
-            and accessible to genuine fans.""",
-            llm=llm,
-            verbose=True
-        )
-    
-    @task
-    def verify_user_task(self) -> Task:
-        return Task(
-            description="""Verify the user with the following details:
-            - Name: {name}
-            - Email: {email}
-            - User ID: {user_id}
-            
-            Perform KYC verification checks:
-            1. Validate email format and domain
-            2. Check if name appears legitimate
-            3. Assign verification level (basic/standard/premium)
-            4. Calculate risk score (0-1) based on user patterns
-            5. Determine if user is verified for ticket purchase
-            
-            Consider factors like email domain reputation, name consistency, and any red flags.""",
-            agent=self.user_verification_agent(),
-            expected_output="UserVerification model with complete verification details"
-        )
-    
-    @task
-    def detect_scalping_task(self) -> Task:
-        return Task(
-            description="""Analyze user behavior for scalping indicators:
-            - User ID: {user_id}
-            - Current purchase attempt for event: {event_name}
-            - Ticket quantity requested: {ticket_quantity}
-            
-            Check for scalping patterns:
-            1. Purchase velocity (multiple purchases in short time)
-            2. IP address duplication (multiple accounts from same IP)
-            3. Unusual buying patterns
-            4. Bot-like behavior indicators
-            5. Historical resale frequency
-            
-            Use the user's purchase history and behavioral data to determine scalping likelihood.""",
-            agent=self.scalping_detection_agent(),
-            expected_output="ScalpingDetection model with detection results and confidence score"
+# ========== VERIFICATION LOGIC ==========
+class UserVerificationEngine:
+    @staticmethod
+    def verify_user(name: str, email: str, user_id: str) -> UserVerification:
+        """Verify user based on provided information"""
+        
+        # Email validation
+        email_valid = "@" in email and "." in email.split("@")[-1]
+        
+        # Name validation (basic check)
+        name_valid = len(name.strip()) >= 2 and not any(char.isdigit() for char in name)
+        
+        # Risk assessment
+        risk_factors = []
+        if not email_valid:
+            risk_factors.append("invalid_email")
+        if not name_valid:
+            risk_factors.append("suspicious_name")
+        if email.endswith(('.temp', '.fake', '.test')):
+            risk_factors.append("temporary_email")
+        
+        risk_score = min(0.9, len(risk_factors) * 0.3 + random.uniform(0.1, 0.3))
+        is_verified = risk_score < 0.5 and email_valid and name_valid
+        
+        verification_level = "premium" if risk_score < 0.2 else "standard" if risk_score < 0.5 else "basic"
+        
+        return UserVerification(
+            user_id=user_id,
+            name=name,
+            email=email,
+            is_verified=is_verified,
+            verification_level=verification_level,
+            risk_score=risk_score
         )
-    
-    @task
-    def calculate_pricing_task(self) -> Task:
-        return Task(
-            description="""Calculate recommended resale price for:
-            - Event: {event_name}
-            - Original ticket price: ${original_price}
-            - Current demand level: {demand_level}
-            - Ticket type: {ticket_type}
-            
-            Pricing guidelines:
-            - Low demand: Allow 10-20% below original price (acknowledge loss)
-            - Medium demand: Allow up to 25% markup
-            - High demand: Allow up to 50% markup (with profit margin note)
-            
-            Consider market factors and ensure pricing remains fair while reflecting demand.""",
-            agent=self.dynamic_pricing_agent(),
-            expected_output="PricingRecommendation model with price calculations and justification"
+
+class ScalpingDetectionEngine:
+    @staticmethod
+    def detect_scalping(user_id: str, ticket_quantity: int, event_name: str) -> ScalpingDetection:
+        """Detect potential scalping behavior"""
+        
+        flags = []
+        purchase_velocity = mock_db.get_user_purchases(user_id)
+        ip_duplicates = mock_db.get_ip_accounts(user_id)
+        resale_frequency = mock_db.get_resale_frequency(user_id)
+        
+        # Check for scalping indicators
+        if purchase_velocity > 3:
+            flags.append("rapid_purchases")
+        if ip_duplicates > 2:
+            flags.append("multiple_ips")
+        if ticket_quantity > 4:
+            flags.append("bulk_purchase")
+        if resale_frequency > 5:
+            flags.append("frequent_reseller")
+        
+        # Calculate scalping probability
+        scalping_score = (
+            (purchase_velocity / 10) * 0.3 +
+            (ip_duplicates / 5) * 0.3 +
+            (ticket_quantity / 10) * 0.2 +
+            (resale_frequency / 20) * 0.2
         )
-    
-    @task
-    def monitor_compliance_task(self) -> Task:
-        return Task(
-            description="""Evaluate resale compliance for:
-            - User ID: {user_id}
-            - Proposed resale price: ${proposed_resale_price}
-            - Original price: ${original_price}
-            - User's resale history from scalping detection
-            
-            Check against policies:
-            1. Maximum 2x original price cap
-            2. No more than 4 resales per month
-            3. No bulk resales (>4 tickets at once)
-            4. Cooling period between purchases and resales
-            
-            Determine if resale should be allowed and provide recommendations.""",
-            agent=self.resale_monitor_agent(),
-            context=[self.detect_scalping_task(), self.calculate_pricing_task()],
-            expected_output="ResaleCompliance model with compliance decision and violations"
+        
+        is_scalper = scalping_score > 0.5
+        confidence = min(0.95, scalping_score + random.uniform(0.1, 0.2))
+        
+        return ScalpingDetection(
+            is_scalper=is_scalper,
+            confidence=confidence,
+            flags=flags,
+            purchase_velocity=purchase_velocity,
+            ip_duplicates=ip_duplicates
         )
-    
-    @task
-    def final_report_task(self) -> Task:
-        return Task(
-            description="""Create comprehensive system report combining all findings:
-            1. User verification results
-            2. Scalping detection analysis  
-            3. Pricing recommendations
-            4. Compliance evaluation
-            
-            Provide final decision on whether to:
-            - Allow ticket purchase
-            - Allow ticket resale
-            - Apply any restrictions
-            - Recommend specific actions
-            
-            Ensure report is clear and actionable.""",
-            agent=self.resale_monitor_agent(),
-            context=[
-                self.verify_user_task(),
-                self.detect_scalping_task(),
-                self.calculate_pricing_task(),
-                self.monitor_compliance_task()
-            ],
-            expected_output="Complete TicketingSystemReport with all components and final decision"
+
+class DynamicPricingEngine:
+    @staticmethod
+    def calculate_pricing(original_price: float, demand_level: str, proposed_price: float) -> PricingRecommendation:
+        """Calculate recommended pricing based on demand"""
+        
+        demand_multipliers = {
+            "low": (0.8, 1.1),      # Allow 20% below to 10% above
+            "medium": (0.9, 1.25),  # Allow 10% below to 25% above
+            "high": (1.0, 1.5)      # Allow original price to 50% above
+        }
+        
+        min_mult, max_mult = demand_multipliers.get(demand_level, (0.9, 1.25))
+        
+        min_price = original_price * min_mult
+        max_price = original_price * max_mult
+        
+        # Recommend price within acceptable range
+        recommended_price = max(min_price, min(proposed_price, max_price))
+        
+        price_ratio = recommended_price / original_price
+        
+        profit_margin = None
+        loss_percentage = None
+        
+        if price_ratio > 1.0:
+            profit_margin = (price_ratio - 1) * 100
+        elif price_ratio < 1.0:
+            loss_percentage = (1 - price_ratio) * 100
+        
+        reason = f"Adjusted for {demand_level} demand market conditions"
+        if recommended_price != proposed_price:
+            reason += f" (modified from ${proposed_price:.2f})"
+        
+        return PricingRecommendation(
+            original_price=original_price,
+            recommended_resale_price=recommended_price,
+            demand_level=demand_level,
+            price_adjustment_reason=reason,
+            profit_margin=profit_margin,
+            loss_percentage=loss_percentage
         )
-    
-    @crew
-    def crew(self) -> Crew:
-        return Crew(
-            agents=self.agents,
-            tasks=self.tasks,
-            process=Process.sequential,
-            verbose=True
+
+class ComplianceEngine:
+    @staticmethod
+    def check_compliance(
+        user_id: str, 
+        proposed_price: float, 
+        original_price: float,
+        scalping_detection: ScalpingDetection
+    ) -> ResaleCompliance:
+        """Check resale compliance against policies"""
+        
+        violations = []
+        price_ratio = proposed_price / original_price
+        
+        # Policy checks
+        if price_ratio > 2.0:
+            violations.append("price_exceeds_2x")
+        
+        if scalping_detection.is_scalper:
+            violations.append("suspected_scalper")
+        
+        if scalping_detection.purchase_velocity > 5:
+            violations.append("excessive_purchase_velocity")
+        
+        resale_frequency = mock_db.get_resale_frequency(user_id)
+        if resale_frequency > 4:
+            violations.append("monthly_resale_limit_exceeded")
+        
+        is_compliant = len(violations) == 0
+        resale_allowed = is_compliant and not scalping_detection.is_scalper
+        
+        max_allowed_price = original_price * 2.0
+        
+        if resale_allowed:
+            recommendation = "Transaction approved - complies with all policies"
+        else:
+            recommendation = f"Transaction blocked due to: {', '.join(violations)}"
+        
+        return ResaleCompliance(
+            is_compliant=is_compliant,
+            violations=violations,
+            resale_allowed=resale_allowed,
+            max_allowed_price=max_allowed_price,
+            recommendation=recommendation
         )
 
 # ========== MAIN APPLICATION ==========
 class AntiScalpingSystem:
     def __init__(self):
-        self.crew_instance = AntiScalpingCrew()
+        self.verification_engine = UserVerificationEngine()
+        self.scalping_engine = ScalpingDetectionEngine()
+        self.pricing_engine = DynamicPricingEngine()
+        self.compliance_engine = ComplianceEngine()
     
     def process_ticket_transaction(
         self,
@@ -277,76 +260,67 @@ class AntiScalpingSystem:
     ) -> Dict[str, Any]:
         """Process a ticket transaction through the anti-scalping system"""
         
-        # Simulate some purchase history for the user
-        purchase_count = mock_db.get_user_purchases(user_id)
-        mock_db.user_purchase_history[user_id] = purchase_count + 1
-        
-        inputs = {
-            "name": name,
-            "email": email,
-            "user_id": user_id,
-            "event_name": event_name,
-            "ticket_type": ticket_type,
-            "ticket_quantity": ticket_quantity,
-            "original_price": original_price,
-            "demand_level": demand_level,
-            "proposed_resale_price": proposed_resale_price
-        }
-        
         try:
-            result = self.crew_instance.crew().kickoff(inputs=inputs)
+            # Step 1: User Verification
+            verification = self.verification_engine.verify_user(name, email, user_id)
+            
+            # Step 2: Scalping Detection
+            scalping_detection = self.scalping_engine.detect_scalping(
+                user_id, ticket_quantity, event_name
+            )
+            
+            # Step 3: Dynamic Pricing
+            pricing = self.pricing_engine.calculate_pricing(
+                original_price, demand_level, proposed_resale_price
+            )
             
-            # Parse the result and create a structured response
-            if hasattr(result, 'dict'):
-                return result.dict()
+            # Step 4: Compliance Check
+            compliance = self.compliance_engine.check_compliance(
+                user_id, proposed_resale_price, original_price, scalping_detection
+            )
+            
+            # Step 5: Final Decision
+            final_decision = "APPROVED" if (
+                verification.is_verified and 
+                compliance.resale_allowed and 
+                not scalping_detection.is_scalper
+            ) else "DENIED"
+            
+            # Action items
+            action_items = []
+            if final_decision == "APPROVED":
+                action_items.append("✅ Process ticket resale")
+                action_items.append("📊 Monitor user activity")
             else:
-                # Create a mock response for demo purposes
-                return self._create_mock_response(inputs)
+                action_items.append("❌ Block transaction")
+                if scalping_detection.is_scalper:
+                    action_items.append("🚨 Flag user account for review")
+                if not verification.is_verified:
+                    action_items.append("📋 Require additional verification")
+            
+            # Create report
+            report = TicketingSystemReport(
+                verification=verification,
+                scalping_detection=scalping_detection,
+                pricing=pricing,
+                compliance=compliance,
+                final_decision=final_decision,
+                action_items=action_items
+            )
+            
+            return report.dict()
+            
         except Exception as e:
             logger.error(f"Error processing transaction: {e}")
-            return self._create_mock_response(inputs)
+            return self._create_error_response(str(e))
     
-    def _create_mock_response(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a mock response for demo purposes"""
-        is_scalper = random.random() > 0.7
-        price_ratio = inputs["proposed_resale_price"] / inputs["original_price"]
-        
+    def _create_error_response(self, error_msg: str) -> Dict[str, Any]:
+        """Create error response"""
         return {
-            "verification": {
-                "user_id": inputs["user_id"],
-                "name": inputs["name"],
-                "email": inputs["email"],
-                "is_verified": not is_scalper,
-                "verification_level": "standard" if not is_scalper else "basic",
-                "risk_score": 0.3 if not is_scalper else 0.8
-            },
-            "scalping_detection": {
-                "is_scalper": is_scalper,
-                "confidence": 0.85 if is_scalper else 0.15,
-                "flags": ["rapid_purchases", "multiple_ips"] if is_scalper else [],
-                "purchase_velocity": random.randint(1, 10),
-                "ip_duplicates": random.randint(1, 5)
-            },
-            "pricing": {
-                "original_price": inputs["original_price"],
-                "recommended_resale_price": inputs["proposed_resale_price"],
-                "demand_level": inputs["demand_level"],
-                "price_adjustment_reason": f"Based on {inputs['demand_level']} demand",
-                "profit_margin": (price_ratio - 1) * 100 if price_ratio > 1 else None,
-                "loss_percentage": (1 - price_ratio) * 100 if price_ratio < 1 else None
-            },
-            "compliance": {
-                "is_compliant": price_ratio <= 2 and not is_scalper,
-                "violations": ["price_exceeds_2x"] if price_ratio > 2 else [],
-                "resale_allowed": price_ratio <= 2 and not is_scalper,
-                "max_allowed_price": inputs["original_price"] * 2,
-                "recommendation": "Proceed with resale" if price_ratio <= 2 and not is_scalper else "Block transaction"
-            },
-            "final_decision": "APPROVED" if price_ratio <= 2 and not is_scalper else "DENIED",
-            "action_items": [
-                "Process ticket resale" if price_ratio <= 2 and not is_scalper else "Block transaction",
-                "Monitor future activity" if is_scalper else "No additional action required"
-            ]
+            "error": True,
+            "message": f"System error: {error_msg}",
+            "final_decision": "ERROR",
+            "action_items": ["🔧 Contact system administrator"]
         }
 
 # ========== GRADIO INTERFACE ==========
@@ -361,14 +335,18 @@ def create_interface():
         
         # Validate inputs
         if not all([name, email, user_id, event_name]):
-            return "Please fill in all required fields"
+            return "❌ **Error**: Please fill in all required fields"
         
         try:
-            original_price = float(original_price)
-            proposed_resale_price = float(proposed_resale_price)
-            ticket_quantity = int(ticket_quantity)
-        except ValueError:
-            return "Please enter valid numbers for prices and quantity"
+            original_price = float(original_price) if original_price else 0
+            proposed_resale_price = float(proposed_resale_price) if proposed_resale_price else 0
+            ticket_quantity = int(ticket_quantity) if ticket_quantity else 1
+            
+            if original_price <= 0 or proposed_resale_price <= 0:
+                return "❌ **Error**: Prices must be greater than 0"
+                
+        except (ValueError, TypeError):
+            return "❌ **Error**: Please enter valid numbers for prices and quantity"
         
         # Process through the system
         result = system.process_ticket_transaction(
@@ -383,95 +361,159 @@ def create_interface():
             proposed_resale_price=proposed_resale_price
         )
         
+        # Handle errors
+        if result.get("error"):
+            return f"❌ **System Error**: {result.get('message', 'Unknown error occurred')}"
+        
         # Format the output
+        decision_emoji = "✅" if result['final_decision'] == "APPROVED" else "❌"
+        
         output = f"""
-# 🎫 Anti-Scalping System Report
+# 🎫 Anti-Scalping System Analysis Report
+
+## {decision_emoji} Final Decision: **{result['final_decision']}**
+
+---
 
 ## 👤 User Verification
-- **User ID**: {result['verification']['user_id']}
+- **User ID**: `{result['verification']['user_id']}`
+- **Name**: {result['verification']['name']}
+- **Email**: {result['verification']['email']}
 - **Verified**: {'✅ Yes' if result['verification']['is_verified'] else '❌ No'}
-- **Risk Score**: {result['verification']['risk_score']:.2f}
-- **Verification Level**: {result['verification']['verification_level']}
+- **Risk Score**: {result['verification']['risk_score']:.1%} {'🟢' if result['verification']['risk_score'] < 0.3 else '🟡' if result['verification']['risk_score'] < 0.6 else '🔴'}
+- **Verification Level**: {result['verification']['verification_level'].title()}
 
-## 🔍 Scalping Detection
-- **Scalper Detected**: {'🚨 Yes' if result['scalping_detection']['is_scalper'] else '✅ No'}
-- **Confidence**: {result['scalping_detection']['confidence']:.2%}
+## 🔍 Scalping Detection Analysis
+- **Scalper Detected**: {'🚨 YES' if result['scalping_detection']['is_scalper'] else '✅ NO'}
+- **Detection Confidence**: {result['scalping_detection']['confidence']:.1%}
 - **Purchase Velocity**: {result['scalping_detection']['purchase_velocity']} purchases/hour
-- **IP Duplicates**: {result['scalping_detection']['ip_duplicates']}
-- **Flags**: {', '.join(result['scalping_detection']['flags']) if result['scalping_detection']['flags'] else 'None'}
+- **IP Address Duplicates**: {result['scalping_detection']['ip_duplicates']} accounts
+- **Red Flags**: {', '.join(result['scalping_detection']['flags']) if result['scalping_detection']['flags'] else '✅ None detected'}
 
-## 💰 Pricing Analysis
+## 💰 Dynamic Pricing Analysis
 - **Original Price**: ${result['pricing']['original_price']:.2f}
-- **Proposed Resale**: ${result['pricing']['recommended_resale_price']:.2f}
-- **Demand Level**: {result['pricing']['demand_level']}
+- **Proposed Resale**: ${proposed_resale_price:.2f}
+- **Recommended Price**: ${result['pricing']['recommended_resale_price']:.2f}
+- **Demand Level**: {result['pricing']['demand_level'].title()} 📈
 - **Price Ratio**: {result['pricing']['recommended_resale_price']/result['pricing']['original_price']:.2f}x
 """
         
         if result['pricing'].get('profit_margin'):
-            output += f"- **Profit Margin**: {result['pricing']['profit_margin']:.1f}%\n"
+            output += f"- **Profit Margin**: {result['pricing']['profit_margin']:.1f}% 📈\n"
         elif result['pricing'].get('loss_percentage'):
-            output += f"- **Loss**: {result['pricing']['loss_percentage']:.1f}%\n"
-        
-        output += f"""
-## ✅ Compliance Check
-- **Compliant**: {'✅ Yes' if result['compliance']['is_compliant'] else '❌ No'}
-- **Resale Allowed**: {'✅ Yes' if result['compliance']['resale_allowed'] else '❌ No'}
-- **Max Allowed Price**: ${result['compliance']['max_allowed_price']:.2f}
-- **Violations**: {', '.join(result['compliance']['violations']) if result['compliance']['violations'] else 'None'}
+            output += f"- **Loss**: -{result['pricing']['loss_percentage']:.1f}% 📉\n"
+        
+        output += f"""- **Reason**: {result['pricing']['price_adjustment_reason']}
 
-## 📋 Final Decision: **{result['final_decision']}**
+## ✅ Compliance Evaluation
+- **Policy Compliant**: {'✅ Yes' if result['compliance']['is_compliant'] else '❌ No'}
+- **Resale Permitted**: {'✅ Yes' if result['compliance']['resale_allowed'] else '❌ No'}
+- **Maximum Allowed**: ${result['compliance']['max_allowed_price']:.2f}
+- **Policy Violations**: {', '.join(result['compliance']['violations']) if result['compliance']['violations'] else '✅ None'}
+- **Recommendation**: {result['compliance']['recommendation']}
 
-### Action Items:
+---
+
+## 📋 Required Actions
+"""
+        for i, action in enumerate(result['action_items'], 1):
+            output += f"{i}. {action}\n"
+        
+        # Add summary box
+        if result['final_decision'] == "APPROVED":
+            output += """
+> ✅ **TRANSACTION APPROVED** - All checks passed. Resale can proceed as recommended.
+"""
+        else:
+            output += """
+> ❌ **TRANSACTION BLOCKED** - Policy violations detected. Review required before proceeding.
 """
-        for action in result['action_items']:
-            output += f"- {action}\n"
         
         return output
     
-    # Create Gradio interface
-    interface = gr.Interface(
-        fn=process_transaction,
-        inputs=[
-            gr.Textbox(label="Full Name", placeholder="John Doe"),
-            gr.Textbox(label="Email", placeholder="john@example.com"),
-            gr.Textbox(label="User ID", placeholder="USER123"),
-            gr.Textbox(label="Event Name", placeholder="Taylor Swift - Eras Tour"),
-            gr.Dropdown(
-                label="Ticket Type",
-                choices=["General Admission", "VIP", "Premium", "Standard"],
-                value="Standard"
-            ),
-            gr.Number(label="Ticket Quantity", value=1, minimum=1, maximum=10),
-            gr.Number(label="Original Ticket Price ($)", value=100),
-            gr.Radio(
-                label="Current Demand Level",
-                choices=["low", "medium", "high"],
-                value="medium"
-            ),
-            gr.Number(label="Proposed Resale Price ($)", value=150)
-        ],
-        outputs=gr.Markdown(),
+    # Create Gradio interface with better styling
+    with gr.Blocks(
         title="🎫 Anti-Scalping Ticketing System",
-        description="""
-        This AI-powered system helps prevent ticket scalping by:
-        - Verifying user identity and history
-        - Detecting scalping patterns and behaviors
-        - Recommending fair resale prices based on demand
-        - Ensuring compliance with anti-scalping policies
-        
-        Enter the ticket transaction details below to see if it should be approved.
-        """,
-        examples=[
-            ["John Smith", "john@gmail.com", "USER001", "Taylor Swift - Eras Tour", "VIP", 2, 500, "high", 750],
-            ["Jane Doe", "jane@company.com", "USER002", "NBA Finals Game 7", "Premium", 4, 300, "high", 1200],
-            ["Bob Wilson", "bob@email.com", "USER003", "Local Concert", "General Admission", 1, 50, "low", 40],
-        ],
-        theme=gr.themes.Soft()
-    )
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="slate",
+        )
+    ) as interface:
+        
+        gr.Markdown("""
+        # 🎫 AI-Powered Anti-Scalping Ticketing System
+        
+        This intelligent system prevents ticket scalping by analyzing user behavior, verifying identities, 
+        and ensuring fair pricing compliance. Enter transaction details below for real-time analysis.
+        
+        ---
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 👤 User Information")
+                name = gr.Textbox(label="Full Name", placeholder="John Doe", value="")
+                email = gr.Textbox(label="Email Address", placeholder="john@example.com", value="")
+                user_id = gr.Textbox(label="User ID", placeholder="USER123", value="")
+                
+                gr.Markdown("### 🎟️ Event Details")
+                event_name = gr.Textbox(label="Event Name", placeholder="Taylor Swift - Eras Tour", value="")
+                ticket_type = gr.Dropdown(
+                    label="Ticket Type",
+                    choices=["General Admission", "VIP", "Premium", "Standard", "Balcony", "Floor"],
+                    value="Standard"
+                )
+                ticket_quantity = gr.Number(label="Number of Tickets", value=1, minimum=1, maximum=10, precision=0)
+                
+                gr.Markdown("### 💲 Pricing Information")
+                original_price = gr.Number(label="Original Ticket Price ($)", value=100, minimum=1)
+                demand_level = gr.Radio(
+                    label="Current Market Demand",
+                    choices=["low", "medium", "high"],
+                    value="medium"
+                )
+                proposed_resale_price = gr.Number(label="Proposed Resale Price ($)", value=150, minimum=1)
+                
+                submit_btn = gr.Button("🔍 Analyze Transaction", variant="primary", size="lg")
+            
+            with gr.Column(scale=2):
+                output = gr.Markdown(value="👆 Fill in the form and click 'Analyze Transaction' to get started!")
+        
+        # Event handlers
+        submit_btn.click(
+            fn=process_transaction,
+            inputs=[
+                name, email, user_id, event_name, ticket_type,
+                ticket_quantity, original_price, demand_level, proposed_resale_price
+            ],
+            outputs=output
+        )
+        
+        # Examples section
+        gr.Markdown("---")
+        gr.Markdown("### 📋 Example Scenarios")
+        
+        examples = gr.Examples(
+            examples=[
+                ["John Smith", "john@gmail.com", "USER001", "Taylor Swift - Eras Tour", "VIP", 2, 500, "high", 750],
+                ["Jane Doe", "jane@company.com", "USER002", "NBA Finals Game 7", "Premium", 4, 300, "high", 1200],
+                ["Bob Wilson", "bob@email.com", "USER003", "Local Concert", "General Admission", 1, 50, "low", 40],
+                ["Scalper Bot", "temp@fake.com", "BOT999", "Popular Event", "Standard", 8, 100, "high", 300],
+            ],
+            inputs=[
+                name, email, user_id, event_name, ticket_type,
+                ticket_quantity, original_price, demand_level, proposed_resale_price
+            ]
+        )
     
     return interface
 
 # Main execution
 if __name__ == "__main__":
     interface = create_interface()
-    interface.launch(share=True)
+    interface.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )