Upload 3 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+turbo_air_db.sqlite filter=lfs diff=lfs merge=lfs -text

requirements_viewer.txt

@@ -0,0 +1,2 @@
+streamlit==1.28.1
+pandas==1.5.3

turbo_air_db.sqlite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bee262ed2d48dd1378df9b44bc6f7114a02499e6c41550f4fd9e63714119b21e
+size 279015424

turbo_air_viewer.py

@@ -0,0 +1,930 @@
+#!/usr/bin/env python3
+"""
+Turbo Air Viewer - Equipment Specification Database Viewer
+Deployment-ready version with automatic database download
+"""
+
+import streamlit as st
+import sqlite3
+import json
+from pathlib import Path
+import pandas as pd
+from datetime import datetime
+import re
+import time
+import base64
+import io
+import os
+import requests
+
+# Streamlit page config MUST be first
+st.set_page_config(
+    page_title="Turbo Air Equipment Viewer",
+    page_icon="❄️",
+    layout="wide"
+)
+
+# Configuration
+DB_FILENAME = "turbo_air_db.sqlite"
+# Use the exact URL you provided
+DB_URL = "https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite"
+
+def download_database():
+    """Download database from Hugging Face if not present or invalid"""
+    if os.path.exists(DB_FILENAME):
+        # Check if existing file is valid
+        try:
+            # Check file size first
+            file_size = os.path.getsize(DB_FILENAME)
+            if file_size < 1000000:  # Less than 1MB, probably wrong
+                st.warning(f"Existing database file is too small ({file_size/1024/1024:.1f} MB), re-downloading...")
+                os.remove(DB_FILENAME)
+            else:
+                conn = sqlite3.connect(DB_FILENAME)
+                cursor = conn.cursor()
+                cursor.execute("SELECT name FROM sqlite_master WHERE type='table' LIMIT 1")
+                tables = cursor.fetchall()
+                conn.close()
+                
+                if tables:
+                    st.success(f"✅ Using existing database ({file_size/1024/1024:.1f} MB)")
+                    return DB_FILENAME  # Valid database exists
+        except:
+            st.warning("Existing database file is invalid, re-downloading...")
+            if os.path.exists(DB_FILENAME):
+                os.remove(DB_FILENAME)
+    
+    # Download the database
+    st.info("🔄 Downloading database... This is a one-time download of 279 MB.")
+    
+    try:
+        # Method 1: Try requests first
+        import requests
+        
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        
+        response = requests.get(DB_URL, headers=headers, stream=True, timeout=30, allow_redirects=True)
+        
+        # Check if we got a valid response
+        if response.status_code == 200:
+            total_size = int(response.headers.get('content-length', 0))
+            
+            # Only proceed if file size looks right (should be ~279 MB)
+            if total_size < 10000000:  # Less than 10MB
+                st.error(f"Downloaded file too small ({total_size/1024/1024:.1f} MB). Expected ~279 MB.")
+                st.error("The database file may be a Git LFS pointer.")
+                raise Exception("File size mismatch")
+            
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            with open(DB_FILENAME, 'wb') as f:
+                downloaded = 0
+                for chunk in response.iter_content(chunk_size=1024*1024):  # 1MB chunks
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if total_size > 0:
+                            progress = downloaded / total_size
+                            progress_bar.progress(progress)
+                            status_text.text(f"Downloaded {downloaded/1024/1024:.1f} MB / {total_size/1024/1024:.1f} MB")
+            
+            progress_bar.empty()
+            status_text.empty()
+            
+            # Verify the downloaded file
+            if os.path.getsize(DB_FILENAME) > 100000000:  # At least 100MB
+                try:
+                    conn = sqlite3.connect(DB_FILENAME)
+                    cursor = conn.cursor()
+                    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' LIMIT 1")
+                    tables = cursor.fetchall()
+                    conn.close()
+                    
+                    if tables:
+                        st.success("✅ Database downloaded and verified successfully!")
+                        return DB_FILENAME
+                except:
+                    st.error("Downloaded file is not a valid SQLite database")
+                    
+        else:
+            st.error(f"Failed to download: HTTP {response.status_code}")
+            
+    except requests.exceptions.RequestException as e:
+        st.error(f"Download failed: {str(e)}")
+    except ImportError:
+        st.error("requests library not installed. Please add 'requests' to requirements.txt")
+    except Exception as e:
+        st.error(f"Unexpected error: {str(e)}")
+    
+    # If download failed, provide manual instructions
+    st.error("❌ Automatic download failed.")
+    st.markdown("""
+    ### Manual Download Instructions:
+    
+    1. **Download directly from this link:**
+       [Download turbo_air_db.sqlite (279 MB)](https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite)
+    
+    2. **Or use wget/curl:**
+       ```bash
+       wget https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite
+       # or
+       curl -L -o turbo_air_db.sqlite https://huggingface.co/spaces/TurboAir/turbo-air-viewer/resolve/main/turbo_air_db.sqlite
+       ```
+    
+    3. **Or clone with Git LFS:**
+       ```bash
+       git lfs install
+       git clone https://huggingface.co/spaces/TurboAir/turbo-air-viewer
+       ```
+    
+    **Note:** The database file is 279 MB. Make sure you have a stable internet connection.
+    """)
+    
+    return None
+
+# Download or verify database
+DB_PATH = download_database()
+
+if DB_PATH is None:
+    st.error("❌ Unable to load database. Please refresh the page to try again.")
+    st.stop()
+
+# Rest of your original code continues here...
+# Product type mappings
+PRODUCT_TYPES = {
+    'TSR': 'Reach-In Refrigerators',
+    'TSF': 'Reach-In Freezers',
+    'TGM': 'Glass Door Merchandisers',
+    'TOM': 'Open Display Merchandisers',
+    'MUR': 'Undercounter Refrigerators',
+    'MUF': 'Undercounter Freezers',
+    'PRO': 'Prep Tables',
+    'M3': 'M3 Series',
+    'TBP': 'Back Bar Coolers',
+    'CRT': 'Countertop Display',
+    'TPR': 'Pizza Prep Tables',
+    'MST': 'Sandwich/Salad Units',
+    'J': 'J Series',
+    'TUF': 'Undercounter Freezers',
+    'TUR': 'Undercounter Refrigerators',
+    'TGF': 'Glass Door Freezers',
+    'TGR': 'Glass Door Refrigerators',
+    'JUF': 'J Series Undercounter Freezers',
+    'JUR': 'J Series Undercounter Refrigerators',
+    'PST': 'Prep Station Tables'
+}
+
+# Enhanced dark theme
+st.markdown("""
+<style>
+    .stApp {
+        background-color: #1a1a1a;
+    }
+    
+    .search-container {
+        padding: 25px;
+        margin: 20px 0;
+    }
+    
+    .search-label {
+        color: #4CAF50;
+        font-size: 1.2em;
+        font-weight: bold;
+        margin-bottom: 10px;
+        display: block;
+    }
+    
+    .stSelectbox > div > div {
+        background-color: #3d3d3d !important;
+        border: 1px solid #555 !important;
+        border-radius: 10px !important;
+    }
+    
+    .specs-table {
+        padding: 10px;
+    }
+    
+    .google-search-button {
+        width: 100%;
+        padding: 0.5rem;
+        background-color: #4CAF50;
+        color: white;
+        border: none;
+        border-radius: 5px;
+        cursor: pointer;
+        font-size: 16px;
+    }
+    
+    .google-search-button:hover {
+        background-color: #45a049;
+    }
+    
+    .pdf-container iframe {
+        border: 2px solid #444;
+        border-radius: 8px;
+    }
+    
+    .main-title {
+        color: #4CAF50;
+        font-size: 2.5em;
+        font-weight: bold;
+        margin: 0;
+    }
+    
+    .subtitle {
+        color: #888;
+        font-size: 1.1em;
+        margin-top: 5px;
+    }
+    
+    .quality-badge {
+        display: inline-block;
+        padding: 2px 8px;
+        border-radius: 4px;
+        font-size: 0.85em;
+        margin-left: 5px;
+        font-weight: 600;
+    }
+    
+    .quality-excellent {
+        background-color: #4CAF50;
+        color: white;
+    }
+    
+    .quality-good {
+        background-color: #8BC34A;
+        color: white;
+    }
+    
+    .quality-acceptable {
+        background-color: #FFC107;
+        color: black;
+    }
+    
+    .quality-poor {
+        background-color: #FF5722;
+        color: white;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'selected_model' not in st.session_state:
+    st.session_state.selected_model = None
+if 'bookmarked_models' not in st.session_state:
+    st.session_state.bookmarked_models = []
+
+# Cache functions
+@st.cache_data
+def get_all_models():
+    """Get all models from database - CACHED"""
+    if DB_PATH is None:
+        return []
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    all_models = []
+    
+    try:
+        # First try the model_index table (faster)
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='model_index'")
+        if cursor.fetchone():
+            cursor.execute("SELECT model FROM model_index ORDER BY model")
+            models = cursor.fetchall()
+            if models:
+                all_models = [m[0] for m in models]
+                conn.close()
+                return all_models
+        
+        # Fallback to scanning documents
+        cursor.execute("SELECT full_data FROM documents")
+        rows = cursor.fetchall()
+        
+        model_set = set()
+        for row in rows:
+            try:
+                data = json.loads(row[0])
+                models = data.get('models', [])
+                model_set.update(models)
+            except:
+                continue
+        
+        all_models = sorted(list(model_set))
+        
+    except Exception as e:
+        st.error(f"Database error: {e}")
+        all_models = []
+    finally:
+        conn.close()
+    
+    return all_models
+
+@st.cache_data
+def get_model_data(model_name):
+    """Get data for specific model - CACHED"""
+    if DB_PATH is None:
+        return None
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    try:
+        # Search for the model in documents
+        cursor.execute("""
+        SELECT id, file_path, full_data, quality FROM documents 
+        WHERE full_data LIKE ?
+        ORDER BY import_date DESC
+        LIMIT 1
+        """, (f'%"{model_name}"%',))
+        
+        row = cursor.fetchone()
+        if row:
+            doc_id, file_path, full_data_str, quality = row
+            
+            try:
+                data = json.loads(full_data_str)
+            except:
+                data = {'models': [], 'specs': {}, 'features': []}
+            
+            filename = Path(file_path).name if file_path else 'Unknown'
+            
+            return {
+                'id': doc_id,
+                'filename': filename,
+                'file_path': file_path,
+                'data': data,
+                'quality': quality
+            }
+            
+    except Exception as e:
+        st.error(f"Database error: {e}")
+    finally:
+        conn.close()
+    
+    return None
+
+def clean_spec_data(specs):
+    """Clean and validate specification data"""
+    cleaned_specs = {}
+    
+    for key, value in specs.items():
+        if value and isinstance(value, str):
+            # Clean amperage values
+            if key == 'amperage':
+                if value.strip().upper() in ['A', 'AMP', 'AMPS', 'AMPERE', 'AMPERES']:
+                    value = 'N/A'
+                else:
+                    match = re.search(r'(\d+\.?\d*)\s*[Aa]', value)
+                    if match:
+                        value = f"{match.group(1)} A"
+                    elif value.strip().upper() == 'A':
+                        value = 'N/A'
+            
+            # Clean voltage values
+            elif key == 'voltage':
+                if value.strip().upper() in ['V', 'VOLT', 'VOLTS']:
+                    value = 'N/A'
+                else:
+                    match = re.search(r'(\d+)\s*[Vv]', value)
+                    if match:
+                        value = f"{match.group(1)}V"
+            
+            # Clean phase values
+            elif key == 'phase':
+                if value.strip() in ['1', 'Single', 'single', '1-phase', '1 phase']:
+                    value = '1-Phase'
+                elif value.strip() in ['3', 'Three', 'three', '3-phase', '3 phase']:
+                    value = '3-Phase'
+            
+            # Clean frequency values
+            elif key == 'frequency':
+                if value.strip().upper() in ['HZ', 'HERTZ']:
+                    value = 'N/A'
+                else:
+                    match = re.search(r'(\d+)\s*[Hh][Zz]', value)
+                    if match:
+                        value = f"{match.group(1)} Hz"
+        
+        cleaned_specs[key] = value
+    
+    return cleaned_specs
+
+def get_product_type(model):
+    """Determine product type from model number"""
+    for prefix, type_name in PRODUCT_TYPES.items():
+        if model.startswith(prefix):
+            return type_name
+    
+    model_upper = model.upper()
+    if 'REFRIGERATOR' in model_upper or 'REF' in model_upper:
+        return "Refrigerator"
+    elif 'FREEZER' in model_upper or 'FRZ' in model_upper:
+        return "Freezer"
+    elif 'PREP' in model_upper:
+        return "Prep Table"
+    elif 'DISPLAY' in model_upper:
+        return "Display Case"
+    elif 'MERCHANDISER' in model_upper:
+        return "Merchandiser"
+    
+    return "Equipment"
+
+def format_model_option(model):
+    """Format model with product type for display"""
+    product_type = get_product_type(model)
+    return f"{model} - {product_type}"
+
+def export_bookmarked_models():
+    """Export bookmarked models to CSV"""
+    if not st.session_state.bookmarked_models:
+        return None
+    
+    export_data = []
+    for model in st.session_state.bookmarked_models:
+        model_data = get_model_data(model)
+        if model_data:
+            specs = model_data['data'].get('specs', {})
+            specs = clean_spec_data(specs)
+            features = model_data['data'].get('features', [])
+            
+            # Parse dimensions
+            dimensions = specs.get('dimensions', 'N/A')
+            width, depth, height = 'N/A', 'N/A', 'N/A'
+            
+            dim_patterns = [
+                r'(\d+\.?\d*)["\s]*[WwLl]\s*[xX×]\s*(\d+\.?\d*)["\s]*[DdWw]\s*[xX×]\s*(\d+\.?\d*)["\s]*[HhTt]',
+                r'(\d+\.?\d*)\s*[xX×]\s*(\d+\.?\d*)\s*[xX×]\s*(\d+\.?\d*)',
+                r'(\d+\.?\d*)"?\s*x\s*(\d+\.?\d*)"?\s*x\s*(\d+\.?\d*)"?'
+            ]
+            
+            for pattern in dim_patterns:
+                dim_match = re.search(pattern, dimensions)
+                if dim_match:
+                    width = f"{dim_match.group(1)}\""
+                    depth = f"{dim_match.group(2)}\""
+                    height = f"{dim_match.group(3)}\""
+                    break
+            
+            row = {
+                'Model': model,
+                'Product Type': get_product_type(model),
+                'Voltage': specs.get('voltage', 'N/A'),
+                'Amperage': specs.get('amperage', 'N/A'),
+                'Phase': specs.get('phase', 'N/A'),
+                'Frequency': specs.get('frequency', 'N/A'),
+                'Width': width,
+                'Depth': depth,
+                'Height': height,
+                'Capacity': specs.get('capacity', 'N/A'),
+                'Weight': specs.get('weight', 'N/A'),
+                'Refrigerant': specs.get('refrigerant', 'N/A'),
+                'Temperature Range': specs.get('temperature_range', 'N/A'),
+                'BTU': specs.get('btu', 'N/A'),
+                'Compressor': specs.get('compressor', 'N/A'),
+                'Features': '; '.join(features),
+                'Source File': model_data['filename']
+            }
+            export_data.append(row)
+    
+    df = pd.DataFrame(export_data)
+    return df.to_csv(index=False)
+
+def display_pdf_preview(file_path, model_name):
+    """Display PDF preview inline"""
+    import os
+    
+    if os.path.exists(file_path):
+        try:
+            with open(file_path, "rb") as f:
+                pdf_data = f.read()
+            
+            file_size_mb = len(pdf_data) / (1024 * 1024)
+            
+            # Create columns for controls
+            col1, col2, col3 = st.columns([2, 1, 1])
+            
+            with col1:
+                st.download_button(
+                    "📥 Download PDF",
+                    data=pdf_data,
+                    file_name=f"{model_name}_spec_sheet.pdf",
+                    mime="application/pdf",
+                    use_container_width=True,
+                    type="primary"
+                )
+            
+            with col2:
+                st.success(f"✅ PDF loaded ({file_size_mb:.1f} MB)")
+            
+            with col3:
+                if st.button("❌ Close Preview", use_container_width=True):
+                    st.session_state[f'show_pdf_{model_name}'] = False
+                    st.rerun()
+            
+            # Display PDF inline
+            st.markdown("---")
+            
+            if file_size_mb < 10:
+                # Convert to base64
+                base64_pdf = base64.b64encode(pdf_data).decode('utf-8')
+                
+                # Create HTML for inline PDF display
+                pdf_display = f"""
+                    <iframe 
+                        src="data:application/pdf;base64,{base64_pdf}"
+                        width="100%"
+                        height="800px"
+                        type="application/pdf"
+                        style="border: 2px solid #4CAF50; border-radius: 8px;">
+                    </iframe>
+                """
+                
+                st.markdown(pdf_display, unsafe_allow_html=True)
+                
+            else:
+                st.warning("PDF file is too large for inline viewing. Please use the download button.")
+                
+        except Exception as e:
+            st.error(f"Error reading PDF: {str(e)}")
+    else:
+        st.error("PDF file not found at the stored location.")
+        st.info("The PDF file may have been moved or the database contains an old file path.")
+
+def get_high_accuracy_models(limit=8):
+    """Get models with highest extraction quality"""
+    if DB_PATH is None:
+        return []
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    high_accuracy = []
+    
+    try:
+        cursor.execute("""
+        SELECT full_data, quality FROM documents 
+        WHERE quality IN ('excellent', 'good')
+        ORDER BY 
+            CASE quality
+                WHEN 'excellent' THEN 1
+                WHEN 'good' THEN 2
+                ELSE 3
+            END,
+            import_date DESC
+        LIMIT 200
+        """)
+        
+        rows = cursor.fetchall()
+        seen_models = set()
+        
+        for row in rows:
+            if len(high_accuracy) >= limit:
+                break
+                
+            try:
+                data = json.loads(row[0])
+                models = data.get('models', [])
+                specs = data.get('specs', {})
+                
+                filled_specs = sum(1 for v in specs.values() if v and v != 'N/A')
+                
+                if models and filled_specs >= 4:
+                    for model in models:
+                        if model not in seen_models:
+                            product_type = get_product_type(model)
+                            
+                            type_count = sum(1 for item in high_accuracy if get_product_type(item['model']) == product_type)
+                            if type_count >= 2:
+                                continue
+                            
+                            seen_models.add(model)
+                            high_accuracy.append({
+                                'model': model,
+                                'quality': row[1],
+                                'spec_count': filled_specs,
+                                'product_type': product_type
+                            })
+                            
+                            if len(high_accuracy) >= limit:
+                                break
+            except:
+                continue
+    
+    finally:
+        conn.close()
+    
+    high_accuracy.sort(key=lambda x: (
+        0 if x['quality'] == 'excellent' else 1,
+        -x['spec_count']
+    ))
+    
+    return high_accuracy[:limit]
+
+# MAIN UI
+st.title("❄️ Turbo Air Equipment Viewer")
+st.caption("Professional Equipment Specification Database")
+
+# Get all models
+all_models = get_all_models()
+
+if not all_models:
+    st.error("⚠️ No data found in database. Please ensure turbo_air_db.sqlite is available.")
+    st.stop()
+
+# Bookmarks section
+if st.session_state.bookmarked_models:
+    st.markdown("### 📌 Bookmarked Models")
+    
+    view_col1, view_col2 = st.columns([2, 1])
+    with view_col2:
+        st.markdown(f"**{len(st.session_state.bookmarked_models)} models selected**")
+    
+    # List view
+    display_limit = 5
+    for idx, model in enumerate(st.session_state.bookmarked_models[:display_limit]):
+        col_model, col_remove = st.columns([5, 1])
+        with col_model:
+            st.text(f"• {model}")
+        with col_remove:
+            if st.button("❌", key=f"remove_bookmark_list_{idx}", help=f"Remove {model}"):
+                st.session_state.bookmarked_models.remove(model)
+                st.rerun()
+    
+    if len(st.session_state.bookmarked_models) > display_limit:
+        with st.expander(f"Show all {len(st.session_state.bookmarked_models)} bookmarks"):
+            for idx, model in enumerate(st.session_state.bookmarked_models[display_limit:], display_limit):
+                col_model, col_remove = st.columns([5, 1])
+                with col_model:
+                    st.text(f"• {model}")
+                with col_remove:
+                    if st.button("❌", key=f"remove_bookmark_exp_{idx}", help=f"Remove {model}"):
+                        st.session_state.bookmarked_models.remove(model)
+                        st.rerun()
+    
+    # Export section
+    st.markdown("---")
+    export_col1, export_col2 = st.columns(2)
+    
+    with export_col1:
+        csv_data = export_bookmarked_models()
+        if csv_data:
+            st.download_button(
+                "📥 Export CSV",
+                data=csv_data,
+                file_name=f"turbo_air_selection_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+    
+    with export_col2:
+        if st.button("🗑️ Clear All", use_container_width=True):
+            st.session_state.bookmarked_models = []
+            st.rerun()
+else:
+    st.info("📌 No models bookmarked yet. Select models to create your custom list!")
+
+# Main content area
+col1, col2 = st.columns([1, 3])
+
+with col1:
+    st.markdown("### 💡 Quick Tips")
+    st.write("• View PDF spec sheets")
+    st.write("• Bookmark models for lists")
+    st.write("• Google search finds prices")
+    st.write("• Export includes all specs")
+
+with col2:
+    st.markdown('### 🔍 Model Search')
+    st.caption("Start typing the model number or browse all models")
+    
+    # Group models by product type
+    grouped_models = {}
+    for model in all_models:
+        product_type = get_product_type(model)
+        if product_type not in grouped_models:
+            grouped_models[product_type] = []
+        grouped_models[product_type].append(model)
+    
+    # Create formatted options
+    formatted_options = ['']
+    for product_type in sorted(grouped_models.keys()):
+        for model in sorted(grouped_models[product_type]):
+            formatted_options.append(model)
+    
+    # Search selectbox
+    selected = st.selectbox(
+        "Select or type a model number:",
+        options=formatted_options,
+        format_func=lambda x: format_model_option(x) if x else "Select a model or start typing...",
+        key="model_search",
+        index=formatted_options.index(st.session_state.selected_model) if st.session_state.selected_model in formatted_options else 0,
+        help="Start typing to filter models"
+    )
+    
+    if selected:
+        st.session_state.selected_model = selected
+
+# High Accuracy Models
+with st.expander("⭐ Example Models - Click to expand", expanded=False):
+    st.caption("Examples of models with comprehensive data")
+    
+    high_accuracy = get_high_accuracy_models()
+    if high_accuracy:
+        cols = st.columns(4)
+        col_idx = 0
+        
+        for item in high_accuracy:
+            with cols[col_idx % 4]:
+                if st.button(
+                    f"{item['model']}", 
+                    key=f"ha_{item['model']}", 
+                    use_container_width=True,
+                    help=f"{item['product_type']} - {item['spec_count']} specifications"
+                ):
+                    st.session_state.selected_model = item['model']
+                    st.rerun()
+                
+                st.caption(f"{item['product_type']}")
+                quality_class = f"quality-{item['quality']}"
+                quality_label = "⭐ Excellent" if item['quality'] == 'excellent' else "✓ Good"
+                st.markdown(f'<span class="quality-badge {quality_class}">{quality_label}</span>', 
+                           unsafe_allow_html=True)
+            
+            col_idx += 1
+
+# Display selected model
+if selected and selected != '':
+    st.markdown("---")
+    
+    model_data = get_model_data(selected)
+    
+    if model_data:
+        # Model header with bookmark
+        col1, col2 = st.columns([4, 1])
+        with col1:
+            st.markdown(f"## {selected}")
+            st.caption(f"Product Type: {get_product_type(selected)}")
+            if model_data.get('quality'):
+                quality_class = f"quality-{model_data['quality']}"
+                st.markdown(f'<span class="quality-badge {quality_class}">Data Quality: {model_data["quality"].title()}</span>', 
+                          unsafe_allow_html=True)
+        
+        with col2:
+            is_bookmarked = selected in st.session_state.bookmarked_models
+            bookmark_label = "❌ Remove" if is_bookmarked else "📌 Bookmark"
+            if st.button(bookmark_label, key=f"bookmark_{selected}", use_container_width=True):
+                if is_bookmarked:
+                    st.session_state.bookmarked_models.remove(selected)
+                    st.success("Bookmark removed!")
+                else:
+                    if len(st.session_state.bookmarked_models) >= 50:
+                        st.error("Maximum 50 bookmarks allowed")
+                    else:
+                        st.session_state.bookmarked_models.append(selected)
+                        st.success("Model bookmarked!")
+                time.sleep(0.5)
+                st.rerun()
+        
+        # Specifications
+        specs = model_data['data'].get('specs', {})
+        specs = clean_spec_data(specs)
+        
+        if specs:
+            st.markdown("### Technical Specifications")
+            
+            spec_col1, spec_col2 = st.columns(2)
+            
+            with spec_col1:
+                st.markdown("**Electrical Specifications:**")
+                if specs.get('voltage') and specs.get('voltage') != 'N/A':
+                    st.write(f"Voltage: {specs['voltage']}")
+                if specs.get('amperage') and specs.get('amperage') != 'N/A':
+                    st.write(f"Amperage: {specs['amperage']}")
+                if specs.get('phase') and specs.get('phase') != 'N/A':
+                    st.write(f"Phase: {specs['phase']}")
+                if specs.get('frequency') and specs.get('frequency') != 'N/A':
+                    st.write(f"Frequency: {specs['frequency']}")
+                
+                st.markdown("**Physical Specifications:**")
+                if specs.get('dimensions') and specs.get('dimensions') != 'N/A':
+                    st.write(f"Dimensions: {specs['dimensions']}")
+                if specs.get('weight') and specs.get('weight') != 'N/A':
+                    st.write(f"Weight: {specs['weight']}")
+            
+            with spec_col2:
+                st.markdown("**Performance Specifications:**")
+                if specs.get('refrigerant') and specs.get('refrigerant') != 'N/A':
+                    st.write(f"Refrigerant: {specs['refrigerant']}")
+                if specs.get('temperature_range') and specs.get('temperature_range') != 'N/A':
+                    st.write(f"Temperature: {specs['temperature_range']}")
+                if specs.get('compressor') and specs.get('compressor') != 'N/A':
+                    st.write(f"Compressor: {specs['compressor']}")
+                if specs.get('btu') and specs.get('btu') != 'N/A':
+                    st.write(f"BTU: {specs['btu']}")
+                if specs.get('capacity') and specs.get('capacity') != 'N/A':
+                    st.write(f"Capacity: {specs['capacity']}")
+        
+        # Features
+        features = model_data['data'].get('features', [])
+        if features:
+            st.markdown("### Features")
+            feature_cols = st.columns(3)
+            for idx, feature in enumerate(features):
+                with feature_cols[idx % 3]:
+                    st.write(f"• {feature}")
+        
+        # Certifications
+        certifications = model_data['data'].get('certifications', [])
+        if certifications:
+            st.markdown("### Certifications")
+            st.write(" • ".join(certifications))
+        
+        # Description
+        description = model_data['data'].get('description', '')
+        if description:
+            st.markdown("### Description")
+            st.write(description)
+        
+        # Use cases
+        use_cases = model_data['data'].get('use_cases', '')
+        if use_cases:
+            st.markdown("### Use Cases")
+            st.write(use_cases)
+        
+        # Action buttons - View PDF and Search in Google
+        st.markdown("### Actions")
+        action_col1, action_col2 = st.columns(2)
+        
+        with action_col1:
+            # PDF toggle button
+            pdf_key = f'show_pdf_{selected}'
+            button_text = "📄 Hide PDF" if st.session_state.get(pdf_key, False) else "📄 View PDF"
+            if st.button(button_text, use_container_width=True, key=f"view_pdf_{selected}"):
+                st.session_state[pdf_key] = not st.session_state.get(pdf_key, False)
+        
+        with action_col2:
+            # Google search button
+            google_search = f"https://www.google.com/search?q=turboair+{selected.replace(' ', '+')}+price"
+            st.markdown(f'''
+            <a href="{google_search}" target="_blank" style="text-decoration: none;">
+                <button class="google-search-button">
+                🔍 Search in Google
+                </button>
+            </a>
+            ''', unsafe_allow_html=True)
+        
+        # Display PDF preview if requested
+        pdf_key = f'show_pdf_{selected}'
+        if st.session_state.get(pdf_key, False):
+            st.markdown("---")
+            st.markdown("### 📄 PDF Specification Sheet")
+            
+            if 'file_path' in model_data and model_data['file_path']:
+                display_pdf_preview(model_data['file_path'], selected)
+            else:
+                st.error("❌ No PDF file path found for this model.")
+                st.info("PDF file may not be available.")
+        
+        # Source info
+        st.markdown("---")
+        st.caption(f"Source: {model_data['filename']}")
+    else:
+        st.error(f"No data found for model {selected}")
+
+# Stats at bottom
+st.markdown("---")
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("### Models by Product Type")
+    type_counts = {}
+    for model in all_models:
+        ptype = get_product_type(model)
+        type_counts[ptype] = type_counts.get(ptype, 0) + 1
+    
+    sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True)
+    for ptype, count in sorted_types[:8]:
+        if ptype == "Equipment" and count < 20:
+            continue
+        st.write(f"{ptype}: {count}")
+
+with col2:
+    st.markdown("### Database Info")
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        cursor.execute("SELECT COUNT(*) FROM documents")
+        doc_count = cursor.fetchone()[0]
+        conn.close()
+        
+        st.write(f"• Total Documents: {doc_count}")
+        st.write(f"• Total Models: {len(all_models)}")
+        st.write(f"• Database Size: {Path(DB_PATH).stat().st_size/1024/1024:.1f} MB")
+    except:
+        st.write("• Database info unavailable")
+
+# Footer
+st.markdown("---")
+st.caption("Turbo Air Equipment Viewer - Professional Specification Database")
+st.caption("💡 Tip: Use Google search button to find current prices and availability")