Update app.py

app.py

@@ -1,747 +1,55 @@
+# app_minimal.py - TEST VERSION
 import gradio as gr
-import json
 import os
-import pickle
+import json
+from datasets import load_dataset
 from PIL import Image
-import tempfile
-import time
-from pathlib import Path
-import hashlib
 import io
-import shutil
-
-# Hugging Face imports
-from datasets import load_dataset
-import rarfile
 
-# ========== CONFIGURATION ==========
-HF_TOKEN = os.getenv("HF_TOKEN")  # Set in Space secrets
-HF_DATASET_REPO = "alyex/karnak-data-app"  # Your new dataset with images
+HF_DATASET_REPO = "alyex/karnak-data-app"
 
-# Directories
-HF_CACHE_DIR = os.path.join(tempfile.gettempdir(), "karnak_cache")
-HF_ANNOTATIONS_DIR = "/data/annotations"
-HF_HARD_NEGATIVES_DIR = "/data/hard_negatives"
-SEGMENT_EXTRACT_DIR = "/data/kiu_segment_metadata"
-
-os.makedirs(HF_CACHE_DIR, exist_ok=True)
-os.makedirs(HF_ANNOTATIONS_DIR, exist_ok=True)
-os.makedirs(HF_HARD_NEGATIVES_DIR, exist_ok=True)
-os.makedirs(SEGMENT_EXTRACT_DIR, exist_ok=True)
-
-MANIFEST_FILE = os.path.join(HF_CACHE_DIR, "manifest.pkl")
-
-class AnnotationState:
-    def __init__(self):
-        self.manifest = []
-        self.current_index = 0
-        self.history = []
-        self.karnak_dataset = None
-        self.segment_data = {}  # Will hold kiu_segment_metadata
-        
-        # Load datasets
-        self.load_datasets()
-        # Load manifest
-        self.load_manifest()
+with gr.Blocks(title="⚡ Minimal Test") as demo:
+    gr.Markdown("# 🧪 Testing Dataset Access")
     
-    def load_datasets(self):
-        """Load both datasets"""
-        print("Loading Karnak dataset...")
-        try:
-            self.karnak_dataset = load_dataset(HF_DATASET_REPO, streaming=True)
-            print(f"✅ Karnak dataset loaded")
-        except Exception as e:
-            print(f"❌ Error loading dataset: {e}")
-            self.karnak_dataset = None
-        
-        print("Loading segment metadata from local Space...")
-        self.load_segment_metadata_local()
+    kiu_input = gr.Textbox(label="Enter KIU ID", value="00001")
+    fetch_btn = gr.Button("Fetch Data")
     
-    def load_segment_metadata_local(self):
-        """Load segment metadata from local RAR file in Space repo"""
-        RAR_FILENAME = "kiu_segment_metadata.rar"
-        JSON_FILENAME = "kiu_segment_metadata.json"
-        
-        print(f"Looking for {RAR_FILENAME} in current directory...")
-        
-        # Check if RAR exists
-        if not os.path.exists(RAR_FILENAME):
-            print(f"❌ {RAR_FILENAME} not found in Space files.")
-            print(f"Available files: {os.listdir('.')}")
-            return
-        
-        print(f"✅ Found {RAR_FILENAME}")
-        
-        # Check if already extracted
-        json_path = os.path.join(SEGMENT_EXTRACT_DIR, JSON_FILENAME)
-        if os.path.exists(json_path):
-            print(f"Loading cached metadata from {json_path}")
-            try:
-                with open(json_path, 'r') as f:
-                    self.segment_data = json.load(f)
-                print(f"✅ Loaded {len(self.segment_data)} segment entries")
-                return
-            except Exception as e:
-                print(f"Error loading cached JSON: {e}")
+    image_output = gr.Image(label="Image")
+    html_output = gr.HTML(label="HTML Preview")
+    status = gr.Markdown()
+    
+    def fetch_data(kiu_id):
+        kiu_id = kiu_id.zfill(5)
         
-        # Extract from RAR
         try:
-            print(f"Extracting {RAR_FILENAME}...")
-            with rarfile.RarFile(RAR_FILENAME) as rf:
-                # Find JSON file in RAR
-                json_file_in_rar = None
-                for file_info in rf.infolist():
-                    if 'kiu_segment_metadata' in file_info.filename and file_info.filename.endswith('.json'):
-                        json_file_in_rar = file_info.filename
-                        break
-                
-                if json_file_in_rar:
-                    print(f"Found JSON file: {json_file_in_rar}")
-                    rf.extract(json_file_in_rar, SEGMENT_EXTRACT_DIR)
-                    
-                    extracted_path = os.path.join(SEGMENT_EXTRACT_DIR, json_file_in_rar)
-                    
-                    # Load the data
-                    with open(extracted_path, 'r') as f:
-                        self.segment_data = json.load(f)
+            # Load dataset
+            dataset = load_dataset(HF_DATASET_REPO, streaming=True)
+            
+            # Find the KIU
+            found = False
+            html_content = ""
+            image_data = None
+            
+            for item in dataset["train"].take(100):  # Limit search
+                if item["kiu_id"] == kiu_id:
+                    found = True
+                    html_content = item.get("html", "No HTML")
                     
-                    print(f"✅ Loaded {len(self.segment_data)} segment entries")
+                    if item.get("image"):
+                        image = Image.open(io.BytesIO(item["image"]))
+                        image_data = image
                     
-                    # Rename to standard name
-                    if extracted_path != json_path:
-                        shutil.move(extracted_path, json_path)
-                else:
-                    print("❌ No JSON file found in RAR archive")
-                    print("Files in RAR:")
-                    for file_info in rf.infolist():
-                        print(f"  - {file_info.filename}")
-                        
-        except Exception as e:
-            print(f"❌ Error extracting RAR: {e}")
-            import traceback
-            traceback.print_exc()
-    
-    def load_manifest(self):
-        """Build manifest from segment metadata"""
-        if not self.segment_data:
-            print("❌ No segment data available")
-            self.manifest = []
-            return
-        
-        print("Building manifest from segment metadata...")
-        self.manifest = []
-        
-        # The segment_data is a dict where keys are like "KIU_00001_segments"
-        for key, segment_info in self.segment_data.items():
-            if not isinstance(segment_info, dict):
-                continue
-            
-            kiu_id = segment_info.get('kiu_id')
-            if not kiu_id:
-                # Try to extract from filename
-                if 'KIU_' in key:
-                    try:
-                        kiu_id = key.split('_')[1]  # Extract number from "KIU_00001_segments"
-                    except:
-                        continue
-            
-            instances = segment_info.get('instances', [])
-            
-            for instance in instances:
-                if instance.get('class') == 'Line':
-                    manifest_item = {
-                        'kiu_id': str(kiu_id).zfill(5),
-                        'instance_id': instance.get('instance_id'),
-                        'crop_coords': instance.get('crop_coords', [0, 0, 100, 100]),
-                        'direction': instance.get('direction', ''),
-                        'annotated': instance.get('annotated', False),
-                        'line_number': instance.get('line_number'),
-                        'segment_key': key,
-                        'segment_info': segment_info
-                    }
-                    self.manifest.append(manifest_item)
-        
-        print(f"✅ Built manifest with {len(self.manifest)} instances")
-        
-        # Save to cache
-        with open(MANIFEST_FILE, 'wb') as f:
-            pickle.dump(self.manifest, f)
-        
-        self.current_index = self.find_first_unannotated()
-    
-    def get_kiu_data(self, kiu_id):
-        """Get HTML and image for a KIU from the dataset"""
-        if not self.karnak_dataset:
-            return None, None
-        
-        kiu_id_str = str(kiu_id).zfill(5)
-        
-        # Search in the streaming dataset
-        try:
-            for item in self.karnak_dataset["train"]:
-                if item["kiu_id"] == kiu_id_str:
-                    # Convert image bytes to PIL Image
-                    if item["image"]:
-                        try:
-                            image = Image.open(io.BytesIO(item["image"]))
-                            return item["html"], image
-                        except Exception as e:
-                            print(f"Error converting image for KIU {kiu_id_str}: {e}")
-                    return item["html"], None
-        except Exception as e:
-            print(f"Error streaming dataset for KIU {kiu_id_str}: {e}")
-        
-        return None, None
-    
-    def needs_annotation(self, item):
-        """Check if item needs annotation"""
-        if not item.get('annotated', False):
-            return True
-        
-        direction = item.get('direction')
-        if direction == 'TTB_NEEDS_RECLASSIFICATION':
-            return True
-        
-        return False
-    
-    def find_first_unannotated(self):
-        """Find first item that needs annotation"""
-        for idx, item in enumerate(self.manifest):
-            if self.needs_annotation(item):
-                return idx
-        return 0
-    
-    def find_next_unannotated(self, from_index=None):
-        """Find next item that needs annotation"""
-        if not self.manifest:
-            return 0
-            
-        start_idx = from_index if from_index is not None else self.current_index
-        
-        # Search forward
-        for idx in range(start_idx + 1, len(self.manifest)):
-            if self.needs_annotation(self.manifest[idx]):
-                return idx
-        
-        # Wrap around
-        for idx in range(0, start_idx):
-            if self.needs_annotation(self.manifest[idx]):
-                return idx
-        
-        return start_idx
-    
-    def get_statistics(self):
-        """Calculate statistics"""
-        if not self.manifest:
-            return {'total': 0, 'remaining': 0, 'processed': 0, 'progress_pct': 0}
-        
-        total = len(self.manifest)
-        remaining = sum(1 for item in self.manifest if self.needs_annotation(item))
-        processed = total - remaining
-        progress_pct = (processed / total * 100) if total > 0 else 0
-        
-        # Count by direction
-        ltr = sum(1 for item in self.manifest if item.get('direction') == 'LTR')
-        rtl = sum(1 for item in self.manifest if item.get('direction') == 'RTL')
-        ttb_ltr = sum(1 for item in self.manifest if item.get('direction') == 'TTB_LTR')
-        ttb_rtl = sum(1 for item in self.manifest if item.get('direction') == 'TTB_RTL')
-        skip = sum(1 for item in self.manifest if item.get('direction') == 'Skip')
-        unclear = sum(1 for item in self.manifest if item.get('direction') == 'Unclear')
-        ttb_reclass = sum(1 for item in self.manifest if item.get('direction') == 'TTB_NEEDS_RECLASSIFICATION')
-        
-        return {
-            'total': total,
-            'remaining': remaining,
-            'processed': processed,
-            'progress_pct': progress_pct,
-            'ltr': ltr,
-            'rtl': rtl,
-            'ttb_ltr': ttb_ltr,
-            'ttb_rtl': ttb_rtl,
-            'skip': skip,
-            'unclear': unclear,
-            'ttb_reclass': ttb_reclass
-        }
-    
-    def get_annotation_file_path(self, item):
-        """Get path for annotation file"""
-        kiu_id = item['kiu_id']
-        instance_id = item['instance_id']
-        filename = f"KIU_{kiu_id}_instance_{instance_id}.json"
-        return os.path.join(HF_ANNOTATIONS_DIR, filename)
-    
-    def save_annotation(self, item, direction, line_number):
-        """Save annotation to persistent storage"""
-        annotation_file = self.get_annotation_file_path(item)
-        
-        annotation_data = {
-            'kiu_id': item['kiu_id'],
-            'instance_id': item['instance_id'],
-            'direction': direction,
-            'annotated': True,
-            'line_number': line_number if line_number and line_number.strip() else None,
-            'timestamp': time.time(),
-            'crop_coords': item['crop_coords'],
-            'segment_key': item.get('segment_key', '')
-        }
-        
-        with open(annotation_file, 'w', encoding='utf-8') as f:
-            json.dump(annotation_data, f, indent=2, ensure_ascii=False)
-        
-        return annotation_file
-
-# Global state
-state = AnnotationState()
-
-def load_current_instance():
-    """Load and display current instance"""
-    if not state.manifest or state.current_index >= len(state.manifest):
-        return None, "", "No items available", ""
-    
-    item = state.manifest[state.current_index]
-    kiu_id = item['kiu_id']
-    
-    # Get HTML and image from dataset
-    html_content, full_image = state.get_kiu_data(kiu_id)
-    
-    # Crop the image
-    cropped = None
-    if full_image:
-        try:
-            x1, y1, x2, y2 = map(int, item['crop_coords'])
-            x1, y1 = max(0, x1), max(0, y1)
-            x2, y2 = min(full_image.width, x2), min(full_image.height, y2)
+                    break
             
-            if x2 > x1 and y2 > y1:
-                cropped = full_image.crop((x1, y1, x2, y2))
-                if cropped.height > 800:
-                    ratio = 800 / cropped.height
-                    new_width = int(cropped.width * ratio)
-                    cropped = cropped.resize((new_width, 800), Image.LANCZOS)
+            if found:
+                html_display = f"<div style='padding:10px;background:#f0f0f0'>{html_content[:500]}...</div>"
+                return image_data, html_display, f"✅ Found KIU {kiu_id}"
+            else:
+                return None, "Not found", f"❌ KIU {kiu_id} not found in first 100 items"
+                
         except Exception as e:
-            print(f"Error cropping image: {e}")
-    
-    # Format HTML display
-    if html_content:
-        html_display = f"""
-        <div style="padding: 10px; background: #f5f5f5; border-radius: 5px; max-height: 300px; overflow-y: auto;">
-            <strong>KIU {kiu_id}</strong>
-            <hr style="margin: 5px 0;">
-            <div style="font-size: 12px;">
-                {html_content[:2000]}{'...' if len(html_content) > 2000 else ''}
-            </div>
-        </div>
-        """
-    else:
-        html_display = f"<div style='padding: 10px; background: #fff3cd;'>No HTML for KIU {kiu_id}</div>"
-    
-    # Load existing annotation
-    annotation_file = state.get_annotation_file_path(item)
-    line_num = ""
-    if os.path.exists(annotation_file):
-        try:
-            with open(annotation_file, 'r') as f:
-                annotation = json.load(f)
-                line_num = str(annotation.get('line_number', '')) if annotation.get('line_number') else ""
-        except:
-            pass
+            return None, f"Error: {str(e)}", f"❌ Failed: {str(e)}"
     
-    # Info display
-    stats = state.get_statistics()
-    direction = item.get('direction', '')
-    annotated = item.get('annotated', False)
-    
-    # Determine status
-    if annotated:
-        if direction in ['LTR', 'RTL', 'TTB_LTR', 'TTB_RTL']:
-            status = f"✅ {direction}"
-        elif direction == 'TTB_NEEDS_RECLASSIFICATION':
-            status = "⚠️ NEEDS RECLASS"
-        elif direction == 'Skip':
-            status = "⏭️ Skipped"
-        elif direction == 'Unclear':
-            status = "❓ Unclear"
-        else:
-            status = f"✅ {direction}"
-    else:
-        status = "⏳ Pending"
-    
-    line_info = f" | Line #{line_num}" if line_num else ""
-    
-    info = f"""
-**{state.current_index + 1} / {stats['total']}** | KIU {kiu_id} | Instance {item['instance_id']}{line_info} | {status}
-
-**Progress:** {stats['processed']}/{stats['total']} ({stats['progress_pct']:.1f}%) | **Left:** {stats['remaining']}
+    fetch_btn.click(fetch_data, inputs=[kiu_input], outputs=[image_output, html_output, status])
 
-**Counts:** LTR: {stats['ltr']} | RTL: {stats['rtl']} | TTB+LTR: {stats['ttb_ltr']} | TTB+RTL: {stats['ttb_rtl']}
-Skipped: {stats['skip']} | Unclear: {stats['unclear']} | Needs Reclass: {stats['ttb_reclass']}
-"""
-    
-    return cropped, html_display, info, line_num
-
-def save_annotation_to_state(direction, line_number):
-    """Save annotation"""
-    if not state.manifest or state.current_index >= len(state.manifest):
-        return False
-    
-    item = state.manifest[state.current_index]
-    
-    try:
-        # Save to persistent storage
-        annotation_file = state.save_annotation(item, direction, line_number)
-        
-        # Update manifest
-        item['direction'] = direction
-        item['annotated'] = True
-        if line_number and line_number.strip():
-            try:
-                item['line_number'] = int(line_number.strip())
-            except:
-                pass
-        
-        # Update manifest cache
-        with open(MANIFEST_FILE, 'wb') as f:
-            pickle.dump(state.manifest, f)
-        
-        print(f"✅ Annotation saved to {annotation_file}")
-        return True
-    except Exception as e:
-        print(f"Error saving: {e}")
-        return False
-
-def annotate_and_next(direction, line_number):
-    """Annotate current instance and jump to next unannotated"""
-    if not state.manifest:
-        return None, "", "No items available", ""
-    
-    # Save to history
-    state.history.append({
-        'index': state.current_index,
-        'item': state.manifest[state.current_index].copy()
-    })
-    
-    # Save annotation
-    save_annotation_to_state(direction, line_number)
-    
-    # Jump to next unannotated
-    next_idx = state.find_next_unannotated()
-    state.current_index = next_idx
-    
-    return load_current_instance()
-
-def undo_last():
-    """Undo last annotation"""
-    if not state.manifest or not state.history:
-        return load_current_instance()
-    
-    last = state.history.pop()
-    state.current_index = last['index']
-    
-    item = state.manifest[state.current_index]
-    
-    try:
-        # Get annotation file path
-        annotation_file = state.get_annotation_file_path(item)
-        
-        if os.path.exists(annotation_file):
-            os.remove(annotation_file)
-        
-        # Restore manifest
-        state.manifest[state.current_index] = last['item']
-        
-        # Update manifest cache
-        with open(MANIFEST_FILE, 'wb') as f:
-            pickle.dump(state.manifest, f)
-            
-    except Exception as e:
-        print(f"Error undoing: {e}")
-    
-    return load_current_instance()
-
-def flag_hard_negative(line_number):
-    """Flag current instance as hard negative"""
-    if not state.manifest or state.current_index >= len(state.manifest):
-        return load_current_instance()
-    
-    item = state.manifest[state.current_index]
-    
-    try:
-        # Create hard negative directory
-        instance_dir_name = f"KIU_{item['kiu_id']}_instance_{item['instance_id']}"
-        instance_dir = os.path.join(HF_HARD_NEGATIVES_DIR, instance_dir_name)
-        os.makedirs(instance_dir, exist_ok=True)
-        
-        # Get artifact image
-        html, full_image = state.get_kiu_data(item['kiu_id'])
-        if full_image:
-            # Crop the full image
-            x1, y1, x2, y2 = map(int, item['crop_coords'])
-            x1, y1 = max(0, x1), max(0, y1)
-            x2, y2 = min(full_image.width, x2), min(full_image.height, y2)
-            
-            if x2 > x1 and y2 > y1:
-                cropped = full_image.crop((x1, y1, x2, y2))
-                cropped.save(os.path.join(instance_dir, "hard_negative.jpg"), "JPEG")
-        
-        # Save metadata
-        metadata = {
-            'kiu_id': item['kiu_id'],
-            'instance_id': item['instance_id'],
-            'crop_coords': item['crop_coords'],
-            'flagged_as_hard_negative': True,
-            'timestamp': time.time()
-        }
-        
-        with open(os.path.join(instance_dir, "metadata.json"), 'w', encoding='utf-8') as f:
-            json.dump(metadata, f, indent=2, ensure_ascii=False)
-        
-        # Mark as hard negative in annotations
-        save_annotation_to_state("HardNegative", line_number)
-        
-        # Update manifest
-        item['direction'] = 'HardNegative'
-        item['annotated'] = True
-        
-        # Update manifest cache
-        with open(MANIFEST_FILE, 'wb') as f:
-            pickle.dump(state.manifest, f)
-            
-    except Exception as e:
-        print(f"Error flagging: {e}")
-    
-    # Move to next unannotated
-    next_idx = state.find_next_unannotated()
-    state.current_index = next_idx
-    
-    return load_current_instance()
-
-# Navigation functions
-def go_back():
-    if not state.manifest:
-        return None, "", "No items available", ""
-    state.current_index = max(0, state.current_index - 1)
-    return load_current_instance()
-
-def go_forward():
-    if not state.manifest:
-        return None, "", "No items available", ""
-    state.current_index = min(len(state.manifest) - 1, state.current_index + 1)
-    return load_current_instance()
-
-def jump_to_next_unannotated():
-    if not state.manifest:
-        return None, "", "No items available", ""
-    next_idx = state.find_next_unannotated()
-    state.current_index = next_idx
-    return load_current_instance()
-
-def jump_to_index(target):
-    if not state.manifest:
-        return None, "", "No items available", ""
-    try:
-        idx = int(target) - 1
-        if 0 <= idx < len(state.manifest):
-            state.current_index = idx
-    except:
-        pass
-    return load_current_instance()
-
-def jump_to_kiu(kiu_id):
-    if not state.manifest:
-        return None, "", "No items available", ""
-    kiu_id = kiu_id.strip().zfill(5)
-    for idx, item in enumerate(state.manifest):
-        if str(item['kiu_id']).zfill(5) == kiu_id:
-            state.current_index = idx
-            break
-    return load_current_instance()
-
-def jump_to_old_ttb():
-    """Jump to next TTB that needs reclassification"""
-    if not state.manifest:
-        return None, "", "No items available", ""
-    
-    for idx in range(state.current_index + 1, len(state.manifest)):
-        if state.manifest[idx].get('direction') == 'TTB_NEEDS_RECLASSIFICATION':
-            state.current_index = idx
-            return load_current_instance()
-    
-    for idx in range(0, state.current_index):
-        if state.manifest[idx].get('direction') == 'TTB_NEEDS_RECLASSIFICATION':
-            state.current_index = idx
-            return load_current_instance()
-    
-    return load_current_instance()
-
-def export_annotations():
-    """Export all annotations as a single JSON file"""
-    annotations = []
-    
-    # Scan annotation directory
-    for filename in os.listdir(HF_ANNOTATIONS_DIR):
-        if filename.endswith('.json'):
-            filepath = os.path.join(HF_ANNOTATIONS_DIR, filename)
-            try:
-                with open(filepath, 'r', encoding='utf-8') as f:
-                    annotations.append(json.load(f))
-            except:
-                pass
-    
-    # Create export file
-    export_file = os.path.join(HF_ANNOTATIONS_DIR, "all_annotations.json")
-    with open(export_file, 'w', encoding='utf-8') as f:
-        json.dump(annotations, f, indent=2, ensure_ascii=False)
-    
-    return f"✅ Exported {len(annotations)} annotations to `{export_file}`"
-
-# Build Gradio Interface
-with gr.Blocks(title="⚡ Hieroglyph Annotation Tool - Hugging Face") as app:
-    
-    gr.HTML("""
-    <style>
-        .gr-button { 
-            margin: 2px !important; 
-            min-width: 80px !important;
-            height: 36px !important;
-        }
-        .gradio-container {
-            max-width: 1400px !important;
-        }
-        h1 {
-            color: #2c3e50;
-            margin-bottom: 10px;
-        }
-        .info-box {
-            background: #f8f9fa;
-            padding: 10px;
-            border-radius: 5px;
-            border-left: 4px solid #007bff;
-            margin-bottom: 10px;
-        }
-        .space-info {
-            background: #e3f2fd;
-            padding: 10px;
-            border-radius: 5px;
-            margin-bottom: 15px;
-        }
-    </style>
-    """)
-    
-    gr.Markdown("# ⚡ Hieroglyph Direction Annotation - Hugging Face Space")
-    
-    # Display status
-    stats = state.get_statistics()
-    
-    gr.HTML(f"""
-    <div class="space-info">
-        <strong>📊 Space Status:</strong><br>
-        • Dataset: <code>{HF_DATASET_REPO}</code><br>
-        • Manifest: {stats['total']} instances | {stats['remaining']} remaining<br>
-        • Progress: {stats['progress_pct']:.1f}%<br>
-    </div>
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            image_display = gr.Image(label="Line Instance", type="pil", height=500)
-            
-            line_number_input = gr.Textbox(
-                label="Line Number (optional)", 
-                placeholder="1, 2, 3...",
-                max_lines=1
-            )
-            
-            with gr.Row():
-                ltr_btn = gr.Button("➡️ LTR", variant="primary")
-                rtl_btn = gr.Button("⬅️ RTL", variant="primary")
-                ttb_ltr_btn = gr.Button("⬇️➡️ TTB+LTR", variant="primary")
-                ttb_rtl_btn = gr.Button("⬇️⬅️ TTB+RTL", variant="primary")
-            
-            with gr.Row():
-                skip_btn = gr.Button("⏭️ Skip", variant="secondary")
-                unclear_btn = gr.Button("❓ Unclear", variant="secondary")
-                hard_neg_btn = gr.Button("🚫 Bad", variant="secondary")
-        
-        with gr.Column(scale=1):
-            html_display = gr.HTML(label="Reference")
-    
-    info_display = gr.Markdown()
-    
-    with gr.Row():
-        back_btn = gr.Button("⬅️ Back")
-        forward_btn = gr.Button("➡️ Forward")
-        undo_btn = gr.Button("↩️ Undo")
-        next_unann_btn = gr.Button("⏭️ Next Unannotated", variant="primary")
-        export_btn = gr.Button("💾 Export", variant="secondary")
-    
-    with gr.Row():
-        jump_input = gr.Textbox(label="Jump to Index", placeholder="123", scale=2)
-        jump_btn = gr.Button("Go", scale=1)
-        kiu_input = gr.Textbox(label="Find KIU", placeholder="00001", scale=2)
-        kiu_btn = gr.Button("Find", scale=1)
-        old_ttb_btn = gr.Button("Find TTB Reclass", scale=1, variant="secondary")
-    
-    export_output = gr.Markdown()
-    
-    # Event handlers
-    ltr_btn.click(
-        lambda ln: annotate_and_next("LTR", ln), 
-        inputs=[line_number_input],
-        outputs=[image_display, html_display, info_display, line_number_input]
-    )
-    rtl_btn.click(
-        lambda ln: annotate_and_next("RTL", ln),
-        inputs=[line_number_input],
-        outputs=[image_display, html_display, info_display, line_number_input]
-    )
-    ttb_ltr_btn.click(
-        lambda ln: annotate_and_next("TTB_LTR", ln),
-        inputs=[line_number_input],
-        outputs=[image_display, html_display, info_display, line_number_input]
-    )
-    ttb_rtl_btn.click(
-        lambda ln: annotate_and_next("TTB_RTL", ln),
-        inputs=[line_number_input],
-        outputs=[image_display, html_display, info_display, line_number_input]
-    )
-    skip_btn.click(
-        lambda ln: annotate_and_next("Skip", ln),
-        inputs=[line_number_input],
-        outputs=[image_display, html_display, info_display, line_number_input]
-    )
-    unclear_btn.click(
-        lambda ln: annotate_and_next("Unclear", ln),
-        inputs=[line_number_input],
-        outputs=[image_display, html_display, info_display, line_number_input]
-    )
-    hard_neg_btn.click(
-        flag_hard_negative,
-        inputs=[line_number_input],
-        outputs=[image_display, html_display, info_display, line_number_input]
-    )
-    
-    back_btn.click(go_back, outputs=[image_display, html_display, info_display, line_number_input])
-    forward_btn.click(go_forward, outputs=[image_display, html_display, info_display, line_number_input])
-    undo_btn.click(undo_last, outputs=[image_display, html_display, info_display, line_number_input])
-    next_unann_btn.click(jump_to_next_unannotated, outputs=[image_display, html_display, info_display, line_number_input])
-    export_btn.click(export_annotations, outputs=[export_output])
-    
-    jump_btn.click(jump_to_index, inputs=[jump_input], outputs=[image_display, html_display, info_display, line_number_input])
-    kiu_btn.click(jump_to_kiu, inputs=[kiu_input], outputs=[image_display, html_display, info_display, line_number_input])
-    old_ttb_btn.click(jump_to_old_ttb, outputs=[image_display, html_display, info_display, line_number_input])
-    
-    # Load initial state
-    app.load(load_current_instance, outputs=[image_display, html_display, info_display, line_number_input])
-
-if __name__ == "__main__":
-    stats = state.get_statistics()
-    print("\n" + "="*80)
-    print("⚡ Hieroglyph Annotation Tool - Hugging Face Space")
-    print("="*80)
-    print(f"📊 Statistics:")
-    print(f"  Total instances: {stats['total']:,}")
-    print(f"  Remaining: {stats['remaining']:,}")
-    print(f"  Progress: {stats['progress_pct']:.1f}%")
-    print("="*80)
-    
-    app.launch(server_name="0.0.0.0", server_port=7860)
+demo.launch(server_name="0.0.0.0", server_port=7860)