hieroglyph_annotator_gradio.py

app.py

@@ -0,0 +1,853 @@
+import gradio as gr
+import json
+import os
+import pickle
+from PIL import Image
+import shutil
+import time
+import datasets
+import tempfile
+from pathlib import Path
+import hashlib
+
+# Configuration for Hugging Face Spaces
+# Use environment variable for token - set this in Space Secrets
+HF_TOKEN = os.getenv("HF_TOKEN")
+HF_DATASET_REPO = "alyex/karnak_data"
+HF_CACHE_DIR = os.path.join(tempfile.gettempdir(), "karnak_cache")
+HF_ANNOTATIONS_DIR = "/data/annotations"  # Persistent storage in Spaces
+HF_HARD_NEGATIVES_DIR = "/data/hard_negatives"  # Persistent storage
+
+# Ensure directories exist
+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)
+
+MANIFEST_FILE = os.path.join(HF_CACHE_DIR, "manifest.pkl")
+
+# Try to load kiu_segment_metadata from dataset or local
+KIU_SEGMENT_METADATA = {}
+try:
+    # First try to load from the dataset
+    if HF_TOKEN:
+        from huggingface_hub import hf_hub_download
+        METADATA_FILE = hf_hub_download(
+            repo_id=HF_DATASET_REPO,
+            filename="kiu_segment_metadata.json",
+            token=HF_TOKEN,
+            local_dir=HF_CACHE_DIR
+        )
+        with open(METADATA_FILE, 'r') as f:
+            KIU_SEGMENT_METADATA = json.load(f)
+    else:
+        # Try to load without token
+        try:
+            from huggingface_hub import hf_hub_download
+            METADATA_FILE = hf_hub_download(
+                repo_id=HF_DATASET_REPO,
+                filename="kiu_segment_metadata.json",
+                local_dir=HF_CACHE_DIR
+            )
+            with open(METADATA_FILE, 'r') as f:
+                KIU_SEGMENT_METADATA = json.load(f)
+        except:
+            pass
+except Exception as e:
+    print(f"Could not load metadata from HF: {e}")
+    # Fallback to local file if in repo
+    try:
+        with open("kiu_segment_metadata.json", 'r') as f:
+            KIU_SEGMENT_METADATA = json.load(f)
+    except:
+        print("Warning: Could not load kiu_segment_metadata.json")
+
+class AnnotationState:
+    def __init__(self):
+        self.manifest = []
+        self.current_index = 0
+        self.history = []
+        self.dataset = None
+        self.dataset_cache = {}
+        self.annotations_cache = {}
+        
+        # Load dataset
+        self.load_dataset()
+        # Load manifest
+        self.load_manifest()
+    
+    def load_dataset(self):
+        """Load dataset from Hugging Face"""
+        try:
+            print("Loading dataset from Hugging Face...")
+            load_kwargs = {
+                'path': HF_DATASET_REPO,
+                'trust_remote_code': True
+            }
+            
+            # Only add token if available
+            if HF_TOKEN:
+                load_kwargs['token'] = HF_TOKEN
+                print("Using HF_TOKEN for authentication")
+            
+            # Try loading with streaming first (more memory efficient)
+            try:
+                load_kwargs['streaming'] = True
+                self.dataset = datasets.load_dataset(**load_kwargs)
+                print("✅ Dataset loaded with streaming")
+            except Exception as e:
+                print(f"Streaming failed, trying without: {e}")
+                load_kwargs.pop('streaming', None)
+                self.dataset = datasets.load_dataset(**load_kwargs)
+                print("✅ Dataset loaded without streaming")
+                
+        except Exception as e:
+            print(f"❌ Error loading dataset: {e}")
+            print("💡 Make sure HF_TOKEN is set in Space secrets if dataset is private")
+            self.dataset = None
+    
+    def load_manifest(self):
+        """Load manifest from cache file or build from dataset"""
+        if os.path.exists(MANIFEST_FILE):
+            try:
+                with open(MANIFEST_FILE, 'rb') as f:
+                    self.manifest = pickle.load(f)
+                print(f"✅ Loaded {len(self.manifest)} instances from cache")
+                
+                # Find first unannotated
+                self.current_index = self.find_first_unannotated()
+                print(f"✅ Starting at index {self.current_index}")
+            except Exception as e:
+                print(f"❌ Error loading manifest: {e}")
+                self.manifest = []
+                self.build_manifest_from_dataset()
+        else:
+            print("❌ Manifest not found. Building from dataset...")
+            self.build_manifest_from_dataset()
+    
+    def build_manifest_from_dataset(self):
+        """Build manifest from Hugging Face dataset"""
+        if not self.dataset:
+            print("❌ No dataset available")
+            return
+        
+        print("Building manifest from dataset...")
+        self.manifest = []
+        
+        try:
+            # Try to load train split first
+            splits = list(self.dataset.keys())
+            split = 'train' if 'train' in splits else splits[0] if splits else None
+            
+            if not split:
+                print("❌ No splits found in dataset")
+                return
+            
+            print(f"Using split: {split}")
+            
+            # Check dataset structure
+            sample_item = None
+            for item in self.dataset[split]:
+                sample_item = item
+                break
+            
+            if not sample_item:
+                print("❌ Dataset is empty")
+                return
+            
+            print(f"Sample item keys: {list(sample_item.keys())}")
+            
+            # Process dataset
+            for idx, item in enumerate(self.dataset[split]):
+                # Extract instances from the dataset item
+                instances = item.get('instances', [])
+                kiu_id = item.get('kiu_id', idx)
+                
+                # If no instances key, create a single instance
+                if not instances:
+                    instances = [{
+                        'instance_id': f"instance_{idx}",
+                        'class': 'Line',
+                        'crop_coords': item.get('crop_coords', [0, 0, 100, 100]),
+                        'direction': item.get('direction', ''),
+                        'annotated': item.get('annotated', False),
+                        'line_number': item.get('line_number')
+                    }]
+                
+                for instance in instances:
+                    if instance.get('class') == 'Line':
+                        manifest_item = {
+                            'kiu_id': kiu_id,
+                            'instance_id': instance.get('instance_id', f"instance_{len(self.manifest)}"),
+                            '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'),
+                            'dataset_item': item,  # Store full dataset item
+                            'split': split,
+                            'idx': len(self.manifest)
+                        }
+                        self.manifest.append(manifest_item)
+            
+            print(f"✅ Built manifest with {len(self.manifest)} instances")
+            
+            # Save manifest to cache
+            with open(MANIFEST_FILE, 'wb') as f:
+                pickle.dump(self.manifest, f)
+            
+            self.current_index = self.find_first_unannotated()
+            
+        except Exception as e:
+            print(f"❌ Error building manifest: {e}")
+            import traceback
+            traceback.print_exc()
+    
+    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')
+        hard_negative = sum(1 for item in self.manifest if item.get('direction') == 'HardNegative')
+        
+        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,
+            'hard_negative': hard_negative
+        }
+    
+    def get_annotation_file_path(self, item):
+        """Get path for annotation file in persistent storage"""
+        kiu_id = str(item['kiu_id']).zfill(5)
+        instance_id = item['instance_id']
+        
+        # Create a unique filename
+        filename = f"KIU_{kiu_id}_instance_{instance_id}.json"
+        return os.path.join(HF_ANNOTATIONS_DIR, filename)
+    
+    def load_annotation(self, item):
+        """Load annotation from persistent storage"""
+        annotation_file = self.get_annotation_file_path(item)
+        
+        if os.path.exists(annotation_file):
+            try:
+                with open(annotation_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except:
+                pass
+        
+        # Return default if not exists
+        return {
+            'kiu_id': item['kiu_id'],
+            'instance_id': item['instance_id'],
+            'direction': item.get('direction', ''),
+            'annotated': item.get('annotated', False),
+            'line_number': item.get('line_number'),
+            'original_data_hash': hashlib.md5(
+                json.dumps(item.get('dataset_item', {}), sort_keys=True).encode()
+            ).hexdigest()[:8]
+        }
+    
+    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(),
+            'original_data_hash': hashlib.md5(
+                json.dumps(item.get('dataset_item', {}), sort_keys=True).encode()
+            ).hexdigest()[:8]
+        }
+        
+        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 get_artifact_image(kiu_id, crop_coords):
+    """Get artifact image from dataset"""
+    if not state.dataset:
+        return None
+    
+    try:
+        # Get current item from manifest
+        if state.manifest and state.current_index < len(state.manifest):
+            item = state.manifest[state.current_index]
+            dataset_item = item.get('dataset_item', {})
+            
+            # Try different image access patterns
+            if 'image' in dataset_item and dataset_item['image'] is not None:
+                img = dataset_item['image']
+                if isinstance(img, Image.Image):
+                    return crop_and_resize(img, crop_coords)
+            
+            # Check for PIL Image in other fields
+            for key, value in dataset_item.items():
+                if isinstance(value, Image.Image):
+                    return crop_and_resize(value, crop_coords)
+            
+            # Check for image bytes or paths
+            if 'image_bytes' in dataset_item:
+                try:
+                    img = Image.open(io.BytesIO(dataset_item['image_bytes']))
+                    return crop_and_resize(img, crop_coords)
+                except:
+                    pass
+            
+            # Try to get from images dict
+            if 'images' in dataset_item and isinstance(dataset_item['images'], dict):
+                for img in dataset_item['images'].values():
+                    if isinstance(img, Image.Image):
+                        return crop_and_resize(img, crop_coords)
+    
+    except Exception as e:
+        print(f"Error getting artifact image: {e}")
+    
+    # Return a placeholder if no image found
+    return create_placeholder_image(crop_coords)
+
+def crop_and_resize(img, crop_coords):
+    """Crop and resize image"""
+    try:
+        x1, y1, x2, y2 = map(int, crop_coords)
+        x1, y1 = max(0, x1), max(0, y1)
+        x2, y2 = min(img.width, x2), min(img.height, y2)
+        
+        if x2 > x1 and y2 > y1:
+            cropped = img.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)
+            return cropped
+    except Exception as e:
+        print(f"Error cropping image: {e}")
+    return None
+
+def create_placeholder_image(crop_coords):
+    """Create a placeholder image when no image is available"""
+    try:
+        x1, y1, x2, y2 = map(int, crop_coords)
+        width = max(100, x2 - x1)
+        height = max(100, y2 - y1)
+        
+        # Create a simple placeholder
+        img = Image.new('RGB', (width, height), color=(240, 240, 240))
+        
+        # Add some text
+        from PIL import ImageDraw, ImageFont
+        draw = ImageDraw.Draw(img)
+        
+        # Try to use default font
+        try:
+            font = ImageFont.truetype("arial.ttf", 20)
+        except:
+            font = ImageFont.load_default()
+        
+        text = "Image not available"
+        text_bbox = draw.textbbox((0, 0), text, font=font)
+        text_width = text_bbox[2] - text_bbox[0]
+        text_height = text_bbox[3] - text_bbox[1]
+        
+        position = ((width - text_width) // 2, (height - text_height) // 2)
+        draw.text(position, text, fill=(100, 100, 100), font=font)
+        
+        return img
+    except:
+        return None
+
+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 = str(item['kiu_id'])
+    
+    # Load image from dataset
+    cropped = get_artifact_image(kiu_id, item['crop_coords'])
+    
+    # HTML reference
+    html_content = f"""
+    <div style="padding: 10px; background: #f5f5f5; border-radius: 5px;">
+        <strong>KIU {kiu_id.zfill(5)}</strong> - 
+        <span style="color: #0066cc;">Instance {item['instance_id']}</span>
+        <br>
+        <small>Coordinates: {item['crop_coords']}</small>
+    </div>
+    """
+    
+    # Load existing annotation
+    annotation = state.load_annotation(item)
+    direction = annotation.get('direction', '')
+    annotated = annotation.get('annotated', False)
+    
+    # Info display
+    stats = state.get_statistics()
+    line_num = annotation.get('line_number')
+    
+    # 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"
+        elif direction == 'HardNegative':
+            status = "🚫 Hard Negative"
+        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.zfill(5)} | Instance {item['instance_id']}{line_info} | {status}
+
+**Progress:** {stats['processed']}/{stats['total']} ({stats['progress_pct']:.1f}%) | **Left:** {stats['remaining']}
+
+**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']} | Hard Negatives: {stats['hard_negative']}
+"""
+    
+    line_number_value = str(line_num) if line_num else ""
+    
+    return cropped, html_content, info, line_number_value
+
+def save_annotation_to_state(direction, line_number):
+    """Save annotation to state and persistent storage"""
+    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_{str(item['kiu_id']).zfill(5)}_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
+        cropped = get_artifact_image(item['kiu_id'], item['crop_coords'])
+        if cropped:
+            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 authentication status
+    auth_status = "🔒 Private (HF_TOKEN set)" if HF_TOKEN else "🔓 Public (no HF_TOKEN)"
+    
+    gr.HTML(f"""
+    <div class="space-info">
+        <strong>📊 Space Configuration:</strong><br>
+        • Dataset: <code>{HF_DATASET_REPO}</code><br>
+        • Authentication: {auth_status}<br>
+        • Annotations stored in: <code>{HF_ANNOTATIONS_DIR}</code><br>
+        • Total instances in manifest: {len(state.manifest) if state.manifest else 0}<br>
+        {'• <span style="color: green;">✓ HF_TOKEN is set</span>' if HF_TOKEN else '• <span style="color: orange;">⚠ No HF_TOKEN set (dataset must be public)</span>'}
+    </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(f"  Annotations dir: {HF_ANNOTATIONS_DIR}")
+    print(f"  HF_TOKEN available: {'Yes' if HF_TOKEN else 'No'}")
+    print("="*80)
+    
+    # For Hugging Face Spaces
+    app.launch(
+        show_error=True,
+        server_name="0.0.0.0",
+        server_port=7860
+    )