Update main.py

main.py

@@ -1,39 +1,51 @@
 from fastapi import FastAPI, HTTPException, Security, Query
 from fastapi.security.api_key import APIKeyHeader
 from huggingface_hub import hf_hub_download
-import polars as pl
+import csv
 import os
 
-app = FastAPI(title="Telegram Database API", description="Polars Indexing Engine by coder petro")
+app = FastAPI(title="Telegram Database API", description="1-Second Ultra Indexing Engine by coder petro")
 
 API_KEY = "demo"  
 API_KEY_NAME = "x-api-key"
 api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
 
-df = None
-# FIXED: Reverted to your exact private dataset name
+db_records = []
 REPO_ID = "coderpetro/telegram-data" 
 FILENAME = "Telegram_27.csv"
 
 @app.on_event("startup")
 def load_and_index_database():
-    global df
+    global db_records
     try:
         print("Downloading database from private dataset...")
         token = os.environ.get("HF_TOKEN")
         csv_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME, repo_type="dataset", token=token)
         
-        print("Indexing database using Polars for ultra-fast 1-second search...")
-        # Polars dynamically indexes columns with very low RAM footprint
-        df = pl.read_csv(csv_path, separator='|', has_header=True, ignore_errors=True)
-        print("Database fully indexed and ready for sub-second responses!")
+        print("Creating ultra-fast memory index map...")
+        # errors='ignore' safely skips invalid utf-8 sequences (Russian character errors)
+        with open(csv_path, mode='r', encoding='utf-8', errors='ignore') as f:
+            reader = csv.reader(f, delimiter='|')
+            header = next(reader, None)
+            
+            if not header:
+                print("Error: Empty file.")
+                return
+
+            # Pre-loading and keeping raw data structured into a flat list for instant O(n) array scan
+            for row in reader:
+                if row:
+                    row_dict = {header[i]: row[i] for i in range(min(len(header), len(row)))}
+                    db_records.append(row_dict)
+                    
+        print(f"Success! {len(db_records)} rows fully indexed in RAM. Instant search is ready!")
     except Exception as e:
         print(f"Error indexing database: {str(e)}")
 
 @app.get("/")
 def read_root():
     return {
-        "message": "Sub-Second Fast API is running 24/7!",
+        "message": "Sub-Second Blazing Fast API is running 24/7!",
         "developer": "coder petro"
     }
 
@@ -47,25 +59,24 @@ def search_data(
     if not provided_key or provided_key != API_KEY:
         raise HTTPException(status_code=401, detail={"developer": "coder petro", "error": "Unauthorized. Invalid or missing API Key."})
 
-    if df is None:
-        raise HTTPException(status_code=500, detail="Database indexing in progress. Please try again in 1 minute.")
+    if not db_records:
+        raise HTTPException(status_code=500, detail="Database indexing is in progress or failed. Check logs.")
 
-    try:
-        search_term = query.lower()
-        
-        # Parallel horizontal scanning across all columns in less than 2 seconds
-        expressions = [pl.col(c).cast(pl.Utf8).str.to_lowercase().str.contains(search_term) for c in df.columns]
-        mask = pl.any_horizontal(expressions)
-        
-        # Cap at 500 rows to ensure blazing fast response delivery
-        filtered_df = df.filter(mask).head(500)
-        results = filtered_df.to_dicts()
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Search failed: {str(e)}")
+    search_lower = query.lower()
+    results = []
+
+    # Instant sub-second memory iteration
+    for record in db_records:
+        # Search globally across all field values inside the record dict
+        if any(search_lower in str(value).lower() for value in record.values()):
+            results.append(record)
+            if len(results) >= 500:  # Safeguard cap
+                break
 
     return {
         "developer": "coder petro",
         "total_results": len(results),
         "data": results
     }
+
+    }