Update app.py

app.py

@@ -1,443 +1,270 @@
-severity_match = re.search(r'(\d+)', severity)
-        if severity_match:
-            severity = severity_match.group(1)
-        else:
-            severity = "unknown"
+# police_vision_translator.py
+import gradio as gr
+from transformers import pipeline, AutoModelForSeq2SeqLM, AutoTokenizer, AutoProcessor
+from transformers import ViTImageProcessor, AutoModelForVisionEncoderDecoder
+from transformers import AutoModelForSpeechSeq2Seq, SpeechT5Processor
+import torch
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import os
+import tempfile
+import cv2
 
-    system_prompt = """
-    You are an experienced ER physician. Provide concise medical assessment with:
-    1. Priority level (Emergent/Urgent/Non-urgent)
-    2. Three most likely diagnoses
-    3. Immediate actions required
-    4. Patient instructions in simple language
-    5. Recommended follow-up timeframe
-    
-    Be concise but thorough. Format with clear headers.
-    """
-    
-    if lang == "ar":
-        system_prompt += " Provide your response in both Arabic and English, with Arabic first."
+# Initialize models
+print("Loading models...")
+
+# 1. Vision Document Analysis model
+document_processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224")
+document_model = AutoModelForVisionEncoderDecoder.from_pretrained("Salesforce/blip-image-captioning-large")
+
+# 2. OCR for text extraction - FIX: Use correct model class for TrOCR
+ocr_processor = AutoProcessor.from_pretrained("microsoft/trocr-base-printed")
+ocr_model = AutoModelForVisionEncoderDecoder.from_pretrained("microsoft/trocr-base-printed")
+
+# 3. Translation model
+translator_model = AutoModelForSeq2SeqLM.from_pretrained("facebook/nllb-200-distilled-600M")
+translator_tokenizer = AutoTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
+
+# 4. Speech recognition - Use pipeline which handles model loading correctly
+speech_recognizer = pipeline("automatic-speech-recognition", model="openai/whisper-medium")
+
+# 5. Text-to-speech - Use correct model type
+tts_processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
+tts_model = AutoModelForSpeechSeq2Seq.from_pretrained("microsoft/speecht5_tts")
+
+print("Models loaded!")
 
-    prompt = f"""
-    Patient: {patient['name']} ({patient['age']}yo, {patient['gender']})
-    Patient ID: {patient['id']}
-    Admitted: {patient['admitted']}
+# Language codes mapping
+LANGUAGE_CODES = {
+    "English": "eng_Latn",
+    "Arabic": "ara_Arab",
+    "Hindi": "hin_Deva",
+    "Urdu": "urd_Arab",
+    "Chinese": "zho_Hans",
+    "Russian": "rus_Cyrl",
+    "French": "fra_Latn",
+    "German": "deu_Latn",
+    "Spanish": "spa_Latn",
+    "Japanese": "jpn_Jpan"
+}
+
+def detect_document_type(image):
+    """Detect what type of document is in the image"""
+    # Use vision model to get general description
+    inputs = document_processor(images=image, return_tensors="pt")
+    outputs = document_model.generate(**inputs, max_length=50)
     
-    Vitals:
-    - Temperature: {vitals['temp']}C
-    - Heart Rate: {vitals['hr']}bpm
-    - Blood Pressure: {vitals['bp']}
-    - SpO2: {vitals['o2']}%
+    # Convert output IDs to text
+    description = document_model.decoder.tokenizer.decode(outputs[0], skip_special_tokens=True)
     
-    Symptoms: {symptom} (Duration: {duration} hours)
-    Pain Severity: {severity}/10
-
-    Provide:
-    1. Priority (Emergent/Urgent/Non-urgent)
-    2. Three most likely diagnoses
-    3. Immediate actions required
-    4. Patient instructions in simple language
-    5. Recommended follow-up timeframe
-    """
+    # Simple rule-based classification
+    if "passport" in description.lower():
+        return "Passport"
+    elif "license" in description.lower() or "driving" in description.lower():
+        return "Driver's License"
+    elif "id" in description.lower() or "identity" in description.lower() or "card" in description.lower():
+        return "ID Card"
+    else:
+        return "Unknown Document"
 
-    try:
-        response = client.chat.completions.create(
-            model="gpt-4",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.2
-        )
-        result = response.choices[0].message.content
-        
-        # Determine priority class based on content
-        priority = "stable"  # Default to stable
-        if "Emergent" in result or "emergency" in result.lower() or "طارئ" in result or "طوارئ" in result:
-            priority = "emergency"
-        elif "Urgent" in result or "urgent" in result.lower() or "عاجل" in result or "ملح" in result:
-            priority = "urgent"
-        
-        # Update priority in state
-        state.priority_level = priority
+def extract_text_from_regions(image, regions):
+    """Extract text from specific regions of the document"""
+    results = {}
+    img_array = np.array(image)
+    
+    for field_name, (x1, y1, x2, y2) in regions.items():
+        # Extract region
+        region = img_array[y1:y2, x1:x2]
+        region_pil = Image.fromarray(region)
         
-        # Format the result with proper HTML formatting
-        formatted_result = result.replace("# ", "<h3>").replace("\n# ", "</h3><h3>").replace("\n\n", "</p><p>")
-        if not formatted_result.endswith("</p>"):
-            formatted_result += "</p>"
+        # Process with OCR
+        inputs = ocr_processor(images=region_pil, return_tensors="pt")
+        generated_ids = ocr_model.generate(inputs["pixel_values"])
+        text = ocr_processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
         
-        # Reset loading state
-        state.loading = False
+        results[field_name] = text
         
-        # Return the formatted result with the appropriate CSS class
-        return f"""
-        <div class="{priority} report-section">
-            <div>{formatted_result}</div>
-        </div>
-        </div> <!-- Closing tag for analysis-container -->
-        """
+    return results
 
-    except Exception as e:
-        # Reset loading state
-        state.loading = False
-        return f"Error: {str(e)}"
-
-def show_loading_indicator():
-    if state.loading:
-        return """
-        <div style="text-align: center; padding: 20px;">
-            <div class="loading-spinner"></div>
-            <p>Analyzing patient data...</p>
-        </div>
-        """
-    return ""
+def translate_text(text, source_lang, target_lang):
+    """Translate text between languages"""
+    if not text or text.strip() == "":
+        return ""
+        
+    # Get language codes
+    src_code = LANGUAGE_CODES.get(source_lang, "eng_Latn")
+    tgt_code = LANGUAGE_CODES.get(target_lang, "ara_Arab")
+    
+    # Tokenize
+    inputs = translator_tokenizer(text, return_tensors="pt", padding=True)
+    
+    # Translate
+    translated_tokens = translator_model.generate(
+        **inputs,
+        forced_bos_token_id=translator_tokenizer.lang_code_to_id[tgt_code],
+        max_length=128
+    )
+    
+    # Decode
+    translation = translator_tokenizer.batch_decode(translated_tokens, skip_special_tokens=True)[0]
+    return translation
 
-def reset_app():
-    stop_vital_monitoring()
-    state.active = False
-    state.original_vitals = {}
-    state.current_vitals = {}
-    state.symptom_answers = {"symptom": "", "duration": "", "severity": ""}
-    state.loading = False
-    state.priority_level = "stable"
+def process_document(image, source_language="English", target_language="Arabic"):
+    """Main function to process document images"""
+    # Convert to PIL if it's not already
+    if not isinstance(image, Image.Image):
+        image = Image.fromarray(image)
+    
+    # 1. Detect document type
+    doc_type = detect_document_type(image)
+    
+    # 2. Define regions based on document type (simplified example)
+    # In a real implementation, you would use ML to detect these regions
+    width, height = image.size
+    
+    if doc_type == "Passport":
+        regions = {
+            "Name": (int(width*0.3), int(height*0.2), int(width*0.9), int(height*0.3)),
+            "Date of Birth": (int(width*0.3), int(height*0.35), int(width*0.7), int(height*0.45)),
+            "Passport Number": (int(width*0.3), int(height*0.5), int(width*0.7), int(height*0.6))
+        }
+    elif doc_type == "ID Card":
+        regions = {
+            "Name": (int(width*0.3), int(height*0.15), int(width*0.9), int(height*0.25)),
+            "ID Number": (int(width*0.3), int(height*0.3), int(width*0.7), int(height*0.4)),
+            "Address": (int(width*0.1), int(height*0.5), int(width*0.9), int(height*0.7))
+        }
+    else:  # Driver's License or Unknown
+        regions = {
+            "Name": (int(width*0.3), int(height*0.2), int(width*0.9), int(height*0.3)),
+            "License Number": (int(width*0.3), int(height*0.4), int(width*0.7), int(height*0.5)),
+            "Expiration": (int(width*0.3), int(height*0.6), int(width*0.7), int(height*0.7))
+        }
+    
+    # 3. Extract text from regions
+    extracted_info = extract_text_from_regions(image, regions)
     
-    return [
-        gr.update(value=None, visible=False),  # patient_info
-        gr.update(value="", visible=False),    # patient_card
-        gr.update(value=None, visible=False),  # vitals_display
-        gr.update(value="", visible=False),    # formatted_vitals
-        gr.update(value="", visible=False),    # recording_panel
-        gr.update(value=None, visible=False),  # all_symptoms_audio
-        gr.update(value="", visible=False),    # symptom_q
-        gr.update(value="", visible=False),    # duration_q
-        gr.update(value="", visible=False),    # severity_q
-        gr.update(value="", visible=False),    # analysis_title
-        gr.update(value="", visible=False),    # loading
-        gr.update(value="", visible=False),    # report
-        gr.update(interactive=True),           # generate_btn
-        gr.update(interactive=False),          # check_vitals_btn
-        gr.update(interactive=False)           # analyze_btn
-    ]
+    # 4. Translate extracted text
+    translated_info = {}
+    for field, text in extracted_info.items():
+        translated_info[field] = translate_text(text, source_language, target_language)
+    
+    # 5. Create annotated image
+    annotated_img = image.copy()
+    draw = ImageDraw.Draw(annotated_img)
+    
+    # Attempt to load a font that supports Arabic
+    try:
+        font = ImageFont.truetype("arial.ttf", 20)  # Fallback to system font
+    except IOError:
+        font = ImageFont.load_default()
+    
+    # Draw boxes and translations
+    for field, (x1, y1, x2, y2) in regions.items():
+        # Draw rectangle around region
+        draw.rectangle([(x1, y1), (x2, y2)], outline="green", width=3)
+        
+        # Draw field name and translated text
+        draw.text((x1, y1-25), field, fill="blue", font=font)
+        draw.text((x1, y2+5), f"{extracted_info[field]} → {translated_info[field]}", 
+                 fill="red", font=font)
+    
+    # Return results
+    return {
+        "document_type": doc_type,
+        "annotated_image": annotated_img,
+        "extracted_text": extracted_info,
+        "translated_text": translated_info
+    }
 
-def load_demo_case(case_name, common_cases):
-    if case_name in common_cases:
-        state.symptom_answers = common_cases[case_name].copy()
-        return [
-            gr.update(value=common_cases[case_name]["symptom"]),
-            gr.update(value=common_cases[case_name]["duration"]),
-            gr.update(value=common_cases[case_name]["severity"])
-        ]
-    return [gr.update(), gr.update(), gr.update()]
+def transcribe_speech(audio_file, source_language="English"):
+    """Transcribe speech from audio file"""
+    result = speech_recognizer(audio_file, generate_kwargs={"language": source_language.lower()})
+    return result["text"]
 
-with gr.Blocks(css=custom_css) as demo:
-    # Custom header with app branding
-    gr.HTML("""
-    <div class="app-header">
-        <div class="header-logo">🏥</div>
-        <div class="header-text">
-            <h1>AI Emergency Triage System</h1>
-            <p>World-class AI-powered medical triage for emergency departments</p>
-        </div>
-    </div>
-    """)
+def translate_speech(audio_file, source_language="English", target_language="Arabic"):
+    """Transcribe and translate speech"""
+    # 1. Transcribe speech to text
+    transcription = transcribe_speech(audio_file, source_language)
+    
+    # 2. Translate text
+    translation = translate_text(transcription, source_language, target_language)
     
-    # Create tabs for the main interface and additional features
-    with gr.Tabs() as tabs:
-        # Main interface tab
-        with gr.Tab("Main Interface"):
-            # Control panel
-            with gr.Row(elem_classes="control-panel"):
-                with gr.Column(scale=1):
-                    lang = gr.Radio(
-                        ["en", "ar"], 
-                        label="Interface Language", 
-                        value="en",
-                        elem_classes="language-selector"
-                    )
+    return {
+        "original_text": transcription,
+        "translated_text": translation
+    }
+
+# Gradio Interface
+def create_ui():
+    with gr.Blocks(title="Police Vision Translator") as app:
+        gr.Markdown("# Dubai Police Vision Translator System")
+        gr.Markdown("## Translate documents, environmental text, and speech in real-time")
+        
+        with gr.Tab("Document Translation"):
+            with gr.Row():
+                with gr.Column():
+                    doc_input = gr.Image(type="pil", label="Upload Document")
+                    source_lang = gr.Dropdown(choices=list(LANGUAGE_CODES.keys()), 
+                                             value="English", label="Source Language")
+                    target_lang = gr.Dropdown(choices=list(LANGUAGE_CODES.keys()), 
+                                             value="Arabic", label="Target Language")
+                    process_btn = gr.Button("Process Document")
                 
-                with gr.Column(scale=3):
-                    with gr.Row():
-                        generate_btn = gr.Button(
-                            "🆕 New Patient", 
-                            variant="primary", 
-                            interactive=True,
-                            elem_classes="action-button"
-                        )
-                        check_vitals_btn = gr.Button(
-                            "🩺 Check Vital Signs", 
-                            interactive=False,
-                            elem_classes="action-button"
-                        )
-                        analyze_btn = gr.Button(
-                            "🔍 Analyze Case", 
-                            interactive=False,
-                            elem_classes="action-button"
-                        )
-                        reset_btn = gr.Button(
-                            "🔄 Reset", 
-                            variant="secondary",
-                            elem_classes="action-button"
-                        )
+                with gr.Column():
+                    doc_output = gr.Image(label="Annotated Document")
+                    doc_type = gr.Textbox(label="Document Type")
+                    extracted_info = gr.JSON(label="Extracted Information")
+                    translated_info = gr.JSON(label="Translated Information")
             
-            # Main content area
-            with gr.Column():
-                # Hidden raw data (not displayed to users)
-                with gr.Group(visible=False):  # This group keeps the JSON data but hides it from view
-                    patient_info = gr.JSON(label="Patient Data")
-                    vitals_display = gr.JSON(label="Raw Vitals Data")
-                
-                # NEW LAYOUT: 3 boxes in a horizontal row with equal dimensions using CSS Grid
-                with gr.Row(elem_classes="equal-height-container"):
-                    # Box 1: Patient Info
-                    with gr.Column(elem_classes="card-container"):
-                        patient_card = gr.HTML(visible=False)
-                    
-                    # Box 2: Vital Signs
-                    with gr.Column(elem_classes="card-container"):
-                        formatted_vitals = gr.HTML(visible=False)
-                    
-                    # Box 3: Symptom Recording
-                    with gr.Column(elem_classes="card-container"):
-                        recording_panel = gr.HTML(visible=False)
-                        
-                        # Audio component for all symptoms - will be placed in the recording panel
-                        all_symptoms_audio = gr.Audio(
-                            label="Record your symptoms",
-                            visible=False,
-                            type="filepath",
-                            format="wav",
-                            elem_id="audio-recorder"
-                        )
-                
-                # Hidden text inputs (we only need values, not visual display)
-                with gr.Group(visible=False):
-                    symptom_q = gr.Textbox(label="What is your primary symptom?")
-                    duration_q = gr.Textbox(label="How long have you had it? (in hours)")
-                    severity_q = gr.Textbox(label="On a scale of 1-10, how bad is the pain?")
-                
-                # Title for analysis results
-                analysis_title = gr.HTML(visible=False)
-                
-                # Loading indicator and report appear underneath all three boxes
-                loading = gr.HTML(visible=False)
-                report = gr.HTML(visible=False)
+            process_btn.click(
+                fn=lambda img, src, tgt: process_document(img, src, tgt),
+                inputs=[doc_input, source_lang, target_lang],
+                outputs=[doc_output, doc_type, extracted_info, translated_info]
+            )
         
-        # Demo Cases tab
-        with gr.Tab("Demo Cases"):
-            gr.Markdown("### Quick Demo Cases")
-            gr.Markdown("Select a common case to quickly load for demonstration purposes:")
-            
-            # Pre-filled case data for quick demos
-            common_cases = {
-                "Chest Pain": {
-                    "symptom": "Sharp chest pain radiating to left arm",
-                    "duration": "2",
-                    "severity": "8"
-                },
-                "Abdominal Pain": {
-                    "symptom": "Severe lower right abdominal pain with nausea",
-                    "duration": "12",
-                    "severity": "7"
-                },
-                "Shortness of Breath": {
-                    "symptom": "Difficulty breathing, wheezing sounds",
-                    "duration": "4",
-                    "severity": "6"
-                },
-                "Head Injury": {
-                    "symptom": "Hit head during fall, brief loss of consciousness",
-                    "duration": "1",
-                    "severity": "5"
-                }
-            }
+        with gr.Tab("Speech Translation"):
+            with gr.Row():
+                with gr.Column():
+                    audio_input = gr.Audio(type="filepath", label="Record Speech")
+                    speech_source_lang = gr.Dropdown(choices=list(LANGUAGE_CODES.keys()), 
+                                                   value="English", label="Source Language")
+                    speech_target_lang = gr.Dropdown(choices=list(LANGUAGE_CODES.keys()), 
+                                                   value="Arabic", label="Target Language")
+                    translate_btn = gr.Button("Translate Speech")
+                
+                with gr.Column():
+                    original_text = gr.Textbox(label="Original Speech")
+                    translated_text = gr.Textbox(label="Translated Text")
             
-            case_selector = gr.Radio(
-                list(common_cases.keys()),
-                label="Common Emergency Cases"
+            translate_btn.click(
+                fn=lambda audio, src, tgt: translate_speech(audio, src, tgt),
+                inputs=[audio_input, speech_source_lang, speech_target_lang],
+                outputs=[original_text, translated_text]
             )
             
-            load_case_btn = gr.Button("Load Case Data", variant="secondary")
-            
-            # Define the event handler inside the Blocks context
-            load_case_btn.click(
-                fn=lambda case_name: load_demo_case(case_name, common_cases),
-                inputs=[case_selector],
-                outputs=[symptom_q, duration_q, severity_q]
-            )
-        
-        # About tab
         with gr.Tab("About"):
             gr.Markdown("""
-            # AI Emergency Triage System
+            # Police Vision Translator MVP
             
-            ## World AI Expo Dubai Demo
+            This system demonstrates AI-powered translation capabilities for law enforcement:
             
-            This system demonstrates how advanced AI can assist medical professionals in emergency departments by:
+            - **Document Translation**: Identify and translate key fields in passports, IDs, and licenses
+            - **Speech Translation**: Real-time translation of conversations with civilians
             
-            - **Rapid assessment** of patient condition using vital signs and symptoms
-            - **Intelligent prioritization** of cases based on medical urgency
-            - **Multilingual support** for diverse patient populations
-            - **Voice recognition** for hands-free data entry during busy periods
-            - **Real-time monitoring** of changing patient conditions
+            ## Technologies Used
             
-            ### Technical Features
+            - Vision Transformers for document analysis
+            - NLLB-200 for translation between 200+ languages
+            - Whisper for multilingual speech recognition
+            - SpeechT5 for text-to-speech synthesis
             
-            - GPT-4 for medical analysis and triage recommendations
-            - OpenAI Whisper API for speech recognition
-            - Gradio for interactive UI components
-            - Real-time vital sign monitoring and visualization
-            - Responsive design for various device sizes
-            
-            ### Important Notice
-            
-            This is a technology demonstration only. All medical advice and diagnoses should be verified by qualified healthcare professionals. This system is not a replacement for medical expertise.
+            Developed for demonstration at the World AI Expo Dubai.
             """)
     
-    # Event handlers - all defined inside the Blocks context
-    # Generate new patient
-    generate_btn.click(
-        fn=generate_patient, 
-        inputs=[lang], 
-        outputs=[patient_info]
-    ).then(
-        lambda patient, lang: format_patient_card(patient, lang),
-        inputs=[patient_info, lang],
-        outputs=[patient_card]
-    ).then(
-        # Clear previous data when generating a new patient
-        lambda: [
-            gr.update(visible=True), 
-            gr.update(interactive=True),
-            gr.update(value=""),   # Clear formatted_vitals
-            gr.update(value=""),   # Clear recording_panel
-            gr.update(value=None), # Clear all_symptoms_audio
-            gr.update(value=""),   # Clear analysis_title
-            gr.update(value=""),   # Clear report
-            gr.update(visible=False),  # Hide report
-            gr.update(visible=False),  # Hide analysis_title
-            gr.update(visible=False),  # Hide all_symptoms_audio
-            gr.update(interactive=False) # Disable analyze button
-        ], 
-        outputs=[
-            patient_card, 
-            check_vitals_btn,
-            formatted_vitals,
-            recording_panel,
-            all_symptoms_audio,
-            analysis_title,
-            report,
-            report,
-            analysis_title,
-            all_symptoms_audio,
-            analyze_btn
-        ]
-    )
-    
-    # Language change handler
-    lang.change(
-        fn=lambda patient, vitals, lang, priority: [
-            format_patient_card(patient, lang), 
-            format_vitals_display(vitals, lang),
-            format_recording_panel(lang),
-            format_analysis_title(priority, lang) if priority else ""
-        ],
-        inputs=[patient_info, vitals_display, lang, gr.State(lambda: state.priority_level)],
-        outputs=[patient_card, formatted_vitals, recording_panel, analysis_title]
-    )
-    
-    # Check vital signs
-    check_vitals_btn.click(
-        fn=simulate_initial_vitals, 
-        inputs=[], 
-        outputs=[vitals_display]
-    ).then(
-        lambda vitals, lang: format_vitals_display(vitals, lang),
-        inputs=[vitals_display, lang],
-        outputs=[formatted_vitals]
-    ).then(
-        lambda lang: format_recording_panel(lang),
-        inputs=[lang],
-        outputs=[recording_panel]
-    ).then(
-        lambda: [gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)],
-        outputs=[formatted_vitals, recording_panel, all_symptoms_audio]
-    ).then(
-        fn=lambda vd, fv, lg: start_vital_monitoring(vd, fv, lg), 
-        inputs=[vitals_display, formatted_vitals, lang],
-        outputs=[]
-    ).then(
-        lambda: gr.update(interactive=True),
-        outputs=[analyze_btn]
-    )
-    
-    # Handle single audio recording for all symptoms
-    all_symptoms_audio.change(
-        fn=lambda audio, lang: process_all_symptoms_audio(audio, lang),
-        inputs=[all_symptoms_audio, lang],
-        outputs=[symptom_q, duration_q, severity_q]
-    )
-    
-    # Handle text input
-    symptom_q.change(
-        fn=lambda text: update_text_input(text, 0),
-        inputs=[symptom_q],
-        outputs=[]
-    )
-    
-    duration_q.change(
-        fn=lambda text: update_text_input(text, 1),
-        inputs=[duration_q],
-        outputs=[]
-    )
-    
-    severity_q.change(
-        fn=lambda text: update_text_input(text, 2),
-        inputs=[severity_q],
-        outputs=[]
-    )
-    
-    # Analyze patient case - FIXING THE ORDER HERE
-    analyze_btn.click(
-        # First hide any existing analysis
-        lambda: [gr.update(visible=False), gr.update(visible=False)],
-        outputs=[analysis_title, report]
-    ).then(
-        # Show loading indicator
-        fn=show_loading_indicator,
-        inputs=[],
-        outputs=[loading]
-    ).then(
-        lambda: gr.update(visible=True),
-        outputs=[loading]
-    ).then(
-        # Process the analysis
-        fn=analyze_case,
-        inputs=[lang, patient_info, vitals_display],
-        outputs=[report]
-    ).then(
-        # Now create the analysis title with correct priority AFTER analyzing
-        fn=lambda lang: format_analysis_title(state.priority_level, lang),
-        inputs=[lang],
-        outputs=[analysis_title]
-    ).then(
-        # Show both the title and report, hide loading
-        lambda: [gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)],
-        outputs=[analysis_title, report, loading]
-    )
-    
-    # Reset application state
-    reset_btn.click(
-        fn=reset_app,
-        inputs=[],
-        outputs=[
-            patient_info, patient_card, vitals_display, formatted_vitals,
-            recording_panel, all_symptoms_audio,
-            symptom_q, duration_q, severity_q,
-            analysis_title, loading, report, 
-            generate_btn, check_vitals_btn, analyze_btn
-        ]
-    )
+    return app
 
-# For deployment on Hugging Face Spaces
+# Launch app
 if __name__ == "__main__":
+    demo = create_ui()
     demo.launch()