Update main.py

main.py

@@ -11,7 +11,6 @@ from sqlalchemy.exc import IntegrityError
 from thefuzz import process, fuzz
 from werkzeug.utils import secure_filename
 import tempfile
-import stat
 
 # ───────────────────────────────────────────────────────────────────────────────
 # CONFIGURATION
@@ -23,95 +22,89 @@ log = logging.getLogger("product-pipeline-api")
 app = Flask(__name__)
 CORS(app)
 
-# --- Database Path Resolution with Fallbacks ---
-def get_database_path():
-    """
-    Robust database path resolution with multiple fallbacks for Hugging Face Spaces.
-    """
-    # Try different paths in order of preference
-    potential_paths = [
-        # Standard data directory
-        os.path.join('data', 'products.db'),
-        # Temp directory (usually writable)
-        os.path.join(tempfile.gettempdir(), 'products.db'),
-        # Current working directory
-        'products.db',
-        # User home directory
-        os.path.expanduser('~/products.db'),
-        # In-memory database as last resort
-        ':memory:'
-    ]
+# --- App Configuration ---
+# --- ROBUST DATABASE PATH HANDLING ---
+def setup_database_path():
+    """Setup database path with fallbacks for Hugging Face Spaces."""
+    # Try original path first
+    DB_FOLDER = 'data'
+    DB_PATH = os.path.join(DB_FOLDER, 'products.db')
     
-    for db_path in potential_paths:
-        if db_path == ':memory:':
-            log.warning("Using in-memory database - data will not persist between restarts")
-            return db_path
-            
-        try:
-            # Create directory if it doesn't exist
-            db_dir = os.path.dirname(db_path)
-            if db_dir and not os.path.exists(db_dir):
-                os.makedirs(db_dir, exist_ok=True)
-            
-            # Test write permissions
-            test_file = db_path + '.test'
-            with open(test_file, 'w') as f:
-                f.write('test')
-            os.remove(test_file)
-            
-            log.info(f"Selected database path: {os.path.abspath(db_path)}")
-            return db_path
-            
-        except (OSError, PermissionError) as e:
-            log.warning(f"Cannot use database path {db_path}: {e}")
-            continue
+    try:
+        os.makedirs(DB_FOLDER, exist_ok=True)
+        # Test if we can write to this directory
+        test_file = os.path.join(DB_FOLDER, 'test.tmp')
+        with open(test_file, 'w') as f:
+            f.write('test')
+        os.remove(test_file)
+        log.info(f"Using database path: {DB_PATH}")
+        return DB_PATH
+    except (OSError, PermissionError):
+        log.warning(f"Cannot write to {DB_FOLDER}, trying fallbacks...")
     
-    # Should never reach here due to :memory: fallback
+    # Fallback 1: Use temp directory
+    try:
+        temp_db_path = os.path.join(tempfile.gettempdir(), 'products.db')
+        test_file = os.path.join(tempfile.gettempdir(), 'test.tmp')
+        with open(test_file, 'w') as f:
+            f.write('test')
+        os.remove(test_file)
+        log.info(f"Using temp database path: {temp_db_path}")
+        return temp_db_path
+    except (OSError, PermissionError):
+        log.warning("Cannot write to temp directory, trying current directory...")
+    
+    # Fallback 2: Current directory
+    try:
+        current_db_path = 'products.db'
+        test_file = 'test.tmp'
+        with open(test_file, 'w') as f:
+            f.write('test')
+        os.remove(test_file)
+        log.info(f"Using current directory database path: {current_db_path}")
+        return current_db_path
+    except (OSError, PermissionError):
+        log.warning("Cannot write to current directory, using in-memory database...")
+    
+    # Final fallback: In-memory database
+    log.warning("Using in-memory database - data will not persist!")
     return ':memory:'
 
-# --- App Configuration ---
-DB_PATH = get_database_path()
+DB_PATH = setup_database_path()
 app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{DB_PATH}'
 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 
-# --- Upload Folder Configuration ---
-def get_upload_folder():
-    """Get a writable upload folder with fallbacks."""
-    potential_folders = [
-        'uploads',
-        os.path.join(tempfile.gettempdir(), 'uploads'),
-        tempfile.mkdtemp(prefix='uploads_')
-    ]
-    
-    for folder in potential_folders:
-        try:
-            os.makedirs(folder, exist_ok=True)
-            # Test write permissions
-            test_file = os.path.join(folder, 'test.tmp')
-            with open(test_file, 'w') as f:
-                f.write('test')
-            os.remove(test_file)
-            log.info(f"Using upload folder: {os.path.abspath(folder)}")
-            return folder
-        except (OSError, PermissionError) as e:
-            log.warning(f"Cannot use upload folder {folder}: {e}")
-            continue
-    
-    # Fallback to temp directory
-    return tempfile.gettempdir()
+# --- ROBUST UPLOAD FOLDER HANDLING ---
+def setup_upload_folder():
+    """Setup upload folder with fallbacks."""
+    try:
+        upload_folder = 'uploads'
+        os.makedirs(upload_folder, exist_ok=True)
+        test_file = os.path.join(upload_folder, 'test.tmp')
+        with open(test_file, 'w') as f:
+            f.write('test')
+        os.remove(test_file)
+        return upload_folder
+    except (OSError, PermissionError):
+        log.warning("Cannot create uploads folder, using temp directory")
+        return tempfile.gettempdir()
 
-app.config['UPLOAD_FOLDER'] = get_upload_folder()
+app.config['UPLOAD_FOLDER'] = setup_upload_folder()
 
 # --- File Upload Configuration ---
 ALLOWED_EXTENSIONS = {'csv', 'xls', 'xlsx'}
 
-# --- Database Initialization with Error Handling ---
+# --- ROBUST DATABASE INITIALIZATION ---
+db = None
 try:
     db = SQLAlchemy(app)
     log.info("SQLAlchemy initialized successfully")
 except Exception as e:
     log.error(f"Failed to initialize SQLAlchemy: {e}")
-    raise
+    # Try in-memory fallback
+    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
+    db = SQLAlchemy(app)
+    log.warning("Fell back to in-memory database")
 
 # ───────────────────────────────────────────────────────────────────────────────
 # DATABASE MODEL (Based on products-20.sql)
@@ -139,47 +132,6 @@ class Product(db.Model):
     def __repr__(self):
         return f'<Product {self.id}: {self.name}>'
 
-# ───────────────────────────────────────────────────────────────────────────────
-# DATABASE INITIALIZATION WITH ROBUST ERROR HANDLING
-# ───────────────────────────────────────────────────────────────────────────────
-
-def initialize_database():
-    """Initialize database with comprehensive error handling."""
-    max_retries = 3
-    retry_count = 0
-    
-    while retry_count < max_retries:
-        try:
-            with app.app_context():
-                # Test database connection first
-                db.engine.execute('SELECT 1')
-                log.info("Database connection test successful")
-                
-                # Create all tables
-                db.create_all()
-                log.info("Database tables created successfully")
-                return True
-                
-        except Exception as e:
-            retry_count += 1
-            log.error(f"Database initialization attempt {retry_count} failed: {e}")
-            
-            if retry_count < max_retries:
-                log.info(f"Retrying database initialization... (attempt {retry_count + 1}/{max_retries})")
-                
-                # Try fallback to in-memory database
-                if retry_count == max_retries - 1:
-                    log.warning("Falling back to in-memory database")
-                    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
-                    # Recreate the database instance
-                    global db
-                    db = SQLAlchemy(app)
-            else:
-                log.error("All database initialization attempts failed")
-                return False
-    
-    return False
-
 # ───────────────────────────────────────────────────────────────────────────────
 # DATA LOADING & PRE-PROCESSING
 # ───────────────────────────────────────────────────────────────────────────────
@@ -190,86 +142,51 @@ EXISTING_PRODUCT_NAMES = []
 HS_CODE_DESCRIPTIONS = {}
 
 def parse_hs_codes_pdf(filepath='HS Codes for use under FDMS.pdf'):
-    """Parse HS Codes from PDF with error handling."""
-    log.info(f"Attempting to parse HS Codes from '{filepath}'...")
+    log.info(f"Parsing HS Codes from '{filepath}'...")
     if not os.path.exists(filepath):
         log.warning(f"HS Code PDF not found at '{filepath}'. Categorization will be limited.")
         return []
-    
     codes = []
     try:
         with pdfplumber.open(filepath) as pdf:
-            for page_num, page in enumerate(pdf.pages):
-                try:
-                    text = page.extract_text()
-                    if not text:
-                        continue
-                        
-                    # Improved regex to handle variations in PDF formatting
-                    matches = re.findall(r'\"(\d{8})\"\s*,\s*\"(.*?)\"', text, re.DOTALL)
-                    for code, desc in matches:
-                        clean_desc = desc.replace('\n', ' ').strip()
-                        if code and clean_desc:
-                            codes.append({'code': code, 'description': clean_desc})
-                            HS_CODE_DESCRIPTIONS[clean_desc] = code
-                            
-                except Exception as e:
-                    log.warning(f"Error processing page {page_num + 1}: {e}")
+            for page in pdf.pages:
+                text = page.extract_text()
+                if not text:
                     continue
-                    
+                # Improved regex to handle variations in PDF formatting
+                matches = re.findall(r'\"(\d{8})\"\s*,\s*\"(.*?)\"', text, re.DOTALL)
+                for code, desc in matches:
+                    clean_desc = desc.replace('\n', ' ').strip()
+                    if code and clean_desc:
+                        codes.append({'code': code, 'description': clean_desc})
+                        HS_CODE_DESCRIPTIONS[clean_desc] = code
     except Exception as e:
-        log.error(f"Failed to parse PDF '{filepath}': {e}")
-    
-    log.info(f"Successfully parsed {len(codes)} HS codes from PDF.")
+        log.error(f"Failed to parse PDF: {e}")
+    log.info(f"Successfully parsed {len(codes)} HS codes.")
     return codes
 
 def load_existing_products(filepath='Product List.csv'):
-    """Load existing products with robust error handling."""
-    log.info(f"Attempting to load master product list from '{filepath}'...")
+    log.info(f"Loading master product list from '{filepath}'...")
     if not os.path.exists(filepath):
-        log.warning(f"Master product list not found at '{filepath}'. Using database products only.")
+        log.warning(f"Master product list not found at '{filepath}'. Validation may be limited.")
         return []
-    
     try:
-        # Try different encodings
-        encodings = ['utf-8', 'latin-1', 'cp1252']
-        df = None
-        
-        for encoding in encodings:
+        # Try multiple encodings
+        for encoding in ['utf-8', 'latin-1', 'cp1252']:
             try:
-                df = pd.read_csv(filepath, encoding=encoding)
-                log.info(f"Successfully read CSV with {encoding} encoding")
-                break
+                # Based on the CSV structure, the 'name' is in the second column.
+                df = pd.read_csv(filepath, usecols=[1], names=['name'], header=0, encoding=encoding)
+                product_names = df['name'].dropna().astype(str).unique().tolist()
+                log.info(f"Loaded {len(product_names)} unique existing products with {encoding} encoding.")
+                return product_names
             except UnicodeDecodeError:
                 continue
-        
-        if df is None:
-            log.error("Failed to read CSV with any supported encoding")
-            return []
-        
-        # Flexible column detection - try different approaches
-        product_names = []
-        
-        if len(df.columns) >= 2:
-            # Use second column if available
-            product_names = df.iloc[:, 1].dropna().astype(str).unique().tolist()
-        elif 'name' in df.columns:
-            product_names = df['name'].dropna().astype(str).unique().tolist()
-        elif 'product' in df.columns:
-            product_names = df['product'].dropna().astype(str).unique().tolist()
-        else:
-            # Use first column as fallback
-            product_names = df.iloc[:, 0].dropna().astype(str).unique().tolist()
-        
-        # Clean product names
-        product_names = [name.strip() for name in product_names if name.strip()]
-        
-        log.info(f"Loaded {len(product_names)} unique existing products from CSV.")
-        return product_names
-        
+            except Exception as e:
+                log.warning(f"Error with {encoding} encoding: {e}")
+                continue
     except Exception as e:
         log.error(f"Failed to load master product list: {e}")
-        return []
+    return []
 
 # ───────────────────────────────────────────────────────────────────────────────
 # CORE PROCESSING PIPELINE
@@ -282,127 +199,110 @@ def process_uploaded_file(filepath, filename):
         "processed": 0, "added": 0, "updated": 0, "skipped_duplicates": 0,
         "errors": [], "processed_data": []
     }
-    
+    df = None
+
     try:
-        # Read file with robust error handling
-        df = None
         file_ext = filename.rsplit('.', 1)[1].lower() if '.' in filename else ''
         
-        # Try different encodings and methods
-        encodings = ['utf-8', 'latin-1', 'cp1252']
-        
-        for encoding in encodings:
-            try:
-                if file_ext == 'csv':
-                    df = pd.read_csv(filepath, encoding=encoding, header=None)
-                elif file_ext in ['xls', 'xlsx']:
-                    df = pd.read_excel(filepath, header=None, engine='openpyxl')
-                
-                if df is not None:
-                    log.info(f"Successfully read file with {encoding if file_ext == 'csv' else 'excel'} format")
+        # Try multiple encodings for CSV files
+        if file_ext == 'csv':
+            for encoding in ['utf-8', 'latin-1', 'cp1252']:
+                try:
+                    df = pd.read_csv(filepath, header=None, usecols=[1], names=['product_name'], encoding=encoding)
+                    log.info(f"Successfully read CSV with {encoding} encoding")
                     break
-                    
-            except Exception as e:
-                log.warning(f"Failed to read with {encoding}: {e}")
-                continue
-        
-        if df is None or df.empty:
-            results['errors'].append("Could not read the uploaded file or file is empty")
-            return results
-        
-        # Flexible column detection
-        product_column_idx = None
-        if len(df.columns) >= 2:
-            product_column_idx = 1  # Second column
-        else:
-            product_column_idx = 0  # First column as fallback
-        
-        log.info(f"Using column index {product_column_idx} for product names")
-        
-        for index, row in df.iterrows():
-            try:
-                raw_name = row.iloc[product_column_idx] if len(row) > product_column_idx else None
-                results['processed'] += 1
-                
-                if pd.isna(raw_name) or not str(raw_name).strip():
+                except (UnicodeDecodeError, ValueError):
                     continue
+                except Exception as e:
+                    log.warning(f"Error reading CSV with {encoding}: {e}")
+                    continue
+        elif file_ext in ['xls', 'xlsx']:
+            try:
+                df = pd.read_excel(filepath, header=None, usecols=[1], names=['product_name'], engine='openpyxl')
+            except Exception as e:
+                log.error(f"Error reading Excel file: {e}")
                 
-                cleaned_name = str(raw_name).strip()
-                
-                # Fuzzy matching with existing products
-                best_match, score = (cleaned_name, 100)
-                if EXISTING_PRODUCT_NAMES:
-                    try:
-                        best_match, score = process.extractOne(
-                            cleaned_name, EXISTING_PRODUCT_NAMES, scorer=fuzz.token_sort_ratio
-                        )
-                    except Exception as e:
-                        log.warning(f"Fuzzy matching failed for '{cleaned_name}': {e}")
-                
-                validated_name = best_match if score >= FUZZY_MATCH_THRESHOLD else cleaned_name
-                
-                # HS Code matching
-                best_hs_desc = None
-                hs_code = None
-                if HS_CODE_DESCRIPTIONS:
-                    try:
-                        best_hs_desc, _ = process.extractOne(
-                            validated_name, list(HS_CODE_DESCRIPTIONS.keys())
-                        )
-                        hs_code = HS_CODE_DESCRIPTIONS.get(best_hs_desc)
-                    except Exception as e:
-                        log.warning(f"HS code matching failed for '{validated_name}': {e}")
-                
-                processed_entry = {
-                    "raw_name": str(raw_name),
-                    "cleaned_name": validated_name,
-                    "hs_code": hs_code,
-                    "primary_category": best_hs_desc or "N/A",
-                    "status": ""
-                }
-                
-                # Database operations with error handling
+        if df is None:
+            results['errors'].append("Could not read the uploaded file with any supported encoding.")
+            return results
+            
+    except Exception as e:
+        log.error(f"Could not read the uploaded file: {e}")
+        results['errors'].append(f"Invalid file format or corrupt file: {e}")
+        return results
+
+    if df.empty:
+        results['errors'].append("The uploaded file is empty.")
+        return results
+
+    for index, row in df.iterrows():
+        try:
+            raw_name = row['product_name']
+            results['processed'] += 1
+
+            if pd.isna(raw_name) or not str(raw_name).strip():
+                continue
+
+            cleaned_name = str(raw_name).strip()
+
+            # Fuzzy matching with error handling
+            best_match, score = (cleaned_name, 100)
+            if EXISTING_PRODUCT_NAMES:
                 try:
-                    existing_product = Product.query.filter_by(name=validated_name).first()
-                    if existing_product:
-                        if hs_code and existing_product.hs_code != hs_code:
-                            existing_product.hs_code = hs_code
-                            existing_product.primary_category = best_hs_desc or "N/A"
-                            db.session.commit()
-                            results['updated'] += 1
-                            processed_entry['status'] = 'Updated'
-                        else:
-                            results['skipped_duplicates'] += 1
-                            processed_entry['status'] = 'Skipped (Duplicate)'
-                    else:
-                        new_product = Product(
-                            name=validated_name,
-                            hs_code=hs_code,
-                            primary_category=best_hs_desc or 'N/A'
-                        )
-                        db.session.add(new_product)
-                        db.session.commit()
-                        results['added'] += 1
-                        processed_entry['status'] = 'Added'
-                        
-                    results['processed_data'].append(processed_entry)
-                    
+                    best_match, score = process.extractOne(
+                        cleaned_name, EXISTING_PRODUCT_NAMES, scorer=fuzz.token_sort_ratio
+                    )
                 except Exception as e:
-                    db.session.rollback()
-                    log.error(f"Database error for '{validated_name}': {e}")
-                    results['errors'].append(f"DB Error on '{validated_name}': {str(e)}")
-                    processed_entry['status'] = 'Error'
-                    results['processed_data'].append(processed_entry)
-                    
+                    log.warning(f"Fuzzy matching failed for '{cleaned_name}': {e}")
+
+            validated_name = best_match if score >= FUZZY_MATCH_THRESHOLD else cleaned_name
+
+            # HS Code matching with error handling
+            best_hs_desc, hs_code = None, None
+            if HS_CODE_DESCRIPTIONS:
+                try:
+                    best_hs_desc, _ = process.extractOne(
+                        validated_name, list(HS_CODE_DESCRIPTIONS.keys())
+                    )
+                    hs_code = HS_CODE_DESCRIPTIONS.get(best_hs_desc)
+                except Exception as e:
+                    log.warning(f"HS code matching failed for '{validated_name}': {e}")
+
+            processed_entry = {
+                "raw_name": str(raw_name), "cleaned_name": validated_name, "hs_code": hs_code,
+                "primary_category": best_hs_desc or "N/A", "status": ""
+            }
+            
+            try:
+                existing_product = Product.query.filter_by(name=validated_name).first()
+                if existing_product:
+                    if hs_code and existing_product.hs_code != hs_code:
+                        existing_product.hs_code = hs_code
+                        existing_product.primary_category = best_hs_desc or "N/A"
+                        db.session.commit()
+                        results['updated'] += 1
+                        processed_entry['status'] = 'Updated'
+                    else:
+                        results['skipped_duplicates'] += 1
+                        processed_entry['status'] = 'Skipped (Duplicate)'
+                else:
+                    new_product = Product(name=validated_name, hs_code=hs_code, primary_category=best_hs_desc or 'N/A')
+                    db.session.add(new_product)
+                    db.session.commit()
+                    results['added'] += 1
+                    processed_entry['status'] = 'Added'
+                results['processed_data'].append(processed_entry)
             except Exception as e:
-                log.error(f"Error processing row {index}: {e}")
-                results['errors'].append(f"Row {index + 1} processing error: {str(e)}")
-                continue
-    
-    except Exception as e:
-        log.error(f"Critical error processing file: {e}")
-        results['errors'].append(f"Critical processing error: {str(e)}")
-    
+                db.session.rollback()
+                log.error(f"Database error for '{validated_name}': {e}")
+                results['errors'].append(f"DB Error on '{validated_name}': {e}")
+                processed_entry['status'] = 'Error'
+                results['processed_data'].append(processed_entry)
+        except Exception as e:
+            log.error(f"Error processing row {index}: {e}")
+            results['errors'].append(f"Row {index + 1} error: {str(e)}")
+            continue
+            
     return results
 
 # ───────────────────────────────────────────────────────────────────────────────
@@ -417,35 +317,13 @@ def root():
     return jsonify({
         "ok": True, 
         "message": "The Product Validation server is running.",
-        "database_path": DB_PATH,
-        "upload_folder": app.config['UPLOAD_FOLDER']
+        "database": "in-memory" if DB_PATH == ':memory:' else "persistent"
     })
 
-@app.get("/api/health")
-def health_check():
-    """Health check endpoint."""
-    try:
-        # Test database connection
-        with app.app_context():
-            db.engine.execute('SELECT 1')
-        
-        return jsonify({
-            "ok": True,
-            "database": "connected",
-            "products_count": Product.query.count()
-        })
-    except Exception as e:
-        return jsonify({
-            "ok": False,
-            "database": "disconnected",
-            "error": str(e)
-        }), 500
-
 @app.post("/api/upload")
 def upload_products():
     if 'file' not in request.files:
         return jsonify({"ok": False, "error": "No file part in the request"}), 400
-    
     file = request.files['file']
     if file.filename == '':
         return jsonify({"ok": False, "error": "No file selected"}), 400
@@ -455,32 +333,20 @@ def upload_products():
             filename = secure_filename(file.filename)
             filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
             file.save(filepath)
-            
             results = process_uploaded_file(filepath, filename)
             
             # Clean up uploaded file
             try:
                 os.remove(filepath)
             except:
-                pass  # Non-critical if cleanup fails
+                pass  # Non-critical cleanup
                 
-            return jsonify({
-                "ok": True, 
-                "message": "File processed successfully", 
-                "results": results
-            })
-            
+            return jsonify({"ok": True, "message": "File processed successfully", "results": results})
         except Exception as e:
-            log.error(f"Upload processing error: {e}")
-            return jsonify({
-                "ok": False, 
-                "error": f"File processing failed: {str(e)}"
-            }), 500
+            log.error(f"Upload error: {e}")
+            return jsonify({"ok": False, "error": f"Upload failed: {str(e)}"}, 500)
 
-    return jsonify({
-        "ok": False, 
-        "error": f"Invalid file type. Allowed types are: {', '.join(ALLOWED_EXTENSIONS)}"
-    }), 400
+    return jsonify({"ok": False, "error": f"Invalid file type. Allowed types are: {', '.join(ALLOWED_EXTENSIONS)}"}), 400
 
 @app.get("/api/products")
 def get_products():
@@ -489,41 +355,57 @@ def get_products():
         all_products = Product.query.all()
         products_list = [product.to_dict() for product in all_products]
         log.info(f"Successfully retrieved {len(products_list)} products.")
-        return jsonify({
-            "ok": True, 
-            "count": len(products_list), 
-            "products": products_list
-        })
+        return jsonify({"ok": True, "count": len(products_list), "products": products_list})
     except Exception as e:
         log.error(f"Could not retrieve products from database: {e}")
-        return jsonify({
-            "ok": False, 
-            "error": f"Failed to retrieve products: {str(e)}"
-        }), 500
+        return jsonify({"ok": False, "error": f"Database error: {str(e)}"}, 500)
 
 # ───────────────────────────────────────────────────────────────────────────────
 # MAIN (Server Initialization)
 # ───────────────────────────────────────────────────────────────────────────────
 
 if __name__ == "__main__":
-    log.info("===== Application Startup at 2025-09-20 14:18:26 =====")
-    
-    # Initialize database with error handling
-    if not initialize_database():
-        log.error("Failed to initialize database. Server may not function properly.")
+    log.info("===== Application Startup =====")
     
+    # Robust database initialization
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            with app.app_context():
+                log.info(f"Initializing server (attempt {attempt + 1})...")
+                db.create_all()
+                log.info("Database tables created successfully")
+                break
+        except Exception as e:
+            log.error(f"Database initialization failed (attempt {attempt + 1}): {e}")
+            if attempt == max_retries - 1:
+                log.error("All database initialization attempts failed, trying in-memory fallback")
+                try:
+                    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
+                    # Reinitialize the database connection
+                    from flask_sqlalchemy import SQLAlchemy
+                    db.init_app(app)
+                    with app.app_context():
+                        db.create_all()
+                        log.warning("Using in-memory database - data will not persist")
+                        break
+                except Exception as fallback_error:
+                    log.error(f"Even in-memory database failed: {fallback_error}")
+                    raise
+            else:
+                import time
+                time.sleep(1)  # Brief pause between retries
+
     # Load supporting data (non-critical)
     try:
-        log.info("Loading supporting data...")
         HS_CODES_DATA = parse_hs_codes_pdf()
         EXISTING_PRODUCT_NAMES = load_existing_products()
         log.info("Supporting data loaded successfully")
     except Exception as e:
         log.warning(f"Failed to load supporting data: {e}")
         log.info("Server will continue with limited functionality")
-    
-    log.info(f"Server initialization complete. Database: {DB_PATH}")
-    log.info("Starting Flask development server...")
-    
+
+    log.info(f"Server is ready. Database: {DB_PATH}")
+
     port = int(os.environ.get("PORT", "7860"))
     app.run(host="0.0.0.0", port=port, debug=False)