QuerySUTRA 0.4.5__py3-none-any.whl → 0.4.6__py3-none-any.whl

{querysutra-0.4.5.dist-info → querysutra-0.4.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuerySUTRA
-Version: 0.4.5
+Version: 0.4.6
 Summary: SUTRA
 Author: Aditya Batta
 License: MIT

{querysutra-0.4.5.dist-info → querysutra-0.4.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-querysutra-0.4.5.dist-info/licenses/LICENSE,sha256=F-4b93u0OVrVwGXgMwBRq6MlGyUT9zmre1oh5Gft5Ts,1066
+querysutra-0.4.6.dist-info/licenses/LICENSE,sha256=F-4b93u0OVrVwGXgMwBRq6MlGyUT9zmre1oh5Gft5Ts,1066
 sutra/__init__.py,sha256=ie1Gs0etPOrKWW6v3enD68QYLvETQWmYF0wxo9usqEU,152
 sutra/cache_manager.py,sha256=e0AAeUqoR-aiqzZ3fB-IDvpJ4JA6-YBFyRJxusEnIrA,3082
 sutra/clear_cache.py,sha256=rVIz29p7V11Uh6oHXeaWpFtYXXv-2OED91cHMAWWxtQ,187
@@ -11,7 +11,7 @@ sutra/feedback_matcher.py,sha256=WXYpGtFJnOyYQOzy-z8uBiUWH5vyJJOMS1NwEYzNfic,286
 sutra/nlp_processor.py,sha256=wMS1hz1aGWjSwPUD7lSNBbQapFtLgF2l65j0QKXQOd0,5461
 sutra/schema_embeddings.py,sha256=bVPzpJOdYTyUdG2k3ZdgYJLrX2opHBx68RIjJcMlueo,9732
 sutra/schema_generator.py,sha256=BX_vXmnvSGc6nCBx40WLSoNL3WIYPDahd1cEYloyY4M,1925
-sutra/sutra.py,sha256=GQ-3gLKoDsSDAgb57Yfc7uHFdx_ptYryxCFS8Jr0Nmc,33082
+sutra/sutra.py,sha256=etDxiGYwCj8t6sdppYk2MsFmZlX9d2JiJv1na1GYF4Y,32320
 sutra/sutra_client.py,sha256=PYYDGqVbA9pB-Zcsm52i9KarwijCIGVZOThgONZP6Vs,14203
 sutra/sutra_core.py,sha256=diaWOXUHn1wrqCQrBhLKL612tMQioaqx-ILc3y9-CqM,11708
 sutra/sutra_simple.py,sha256=rnqzG7OAt4p64XtO0peMqHS1pG5tdA8U3EYTMVsq7BE,23201
@@ -22,7 +22,7 @@ tests/test_sutra.py,sha256=6Z4SoIuBzza101304I7plkyPVkUBbjIxR8uPs9z5ntg,2383
 utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utils/file_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utils/text_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-querysutra-0.4.5.dist-info/METADATA,sha256=P58pvODZzmE6gc0VpSol2fFhomOvT_xaN7n9gIlnayk,7258
-querysutra-0.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-querysutra-0.4.5.dist-info/top_level.txt,sha256=9v0buw21eo5LaUU_3Cf9b9MqRyEvtM9cHaOuEXUKVqM,18
-querysutra-0.4.5.dist-info/RECORD,,
+querysutra-0.4.6.dist-info/METADATA,sha256=IdGXdU4zCEUwrj_FpOHDlS9T-sqa875zD6MLTUWwDuo,7258
+querysutra-0.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+querysutra-0.4.6.dist-info/top_level.txt,sha256=9v0buw21eo5LaUU_3Cf9b9MqRyEvtM9cHaOuEXUKVqM,18
+querysutra-0.4.6.dist-info/RECORD,,

sutra/sutra.py

@@ -1,18 +1,9 @@
 """
-QuerySUTRA v0.4.0 - SIMPLE & AUTOMATIC
-SUTRA: Structured-Unstructured-Text-Retrieval-Architecture
-
-FIXED:
-- Auto-creates MySQL database if not exists
-- One-line export to MySQL
-- Complete data extraction from large PDFs
-- No manual file transfers needed
-
-Author: Aditya Batta
-Version: 0.4.0
+QuerySUTRA v0.4.5 - FIXED AI EXTRACTION
+Debug mode to see why extraction fails
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.5"
 __author__ = "Aditya Batta"
 __all__ = ["SUTRA", "QueryResult", "quick_start"]
 
@@ -74,9 +65,9 @@ class SUTRA:
     
     def __init__(self, api_key: Optional[str] = None, db: str = "sutra.db",
                  use_embeddings: bool = False, check_relevance: bool = False,
-                 fuzzy_match: bool = True, cache_queries: bool = True):
+                 fuzzy_match: bool = True, cache_queries: bool = True, debug: bool = False):
         """Initialize."""
-        print("Initializing QuerySUTRA v0.4.0")
+        print("Initializing QuerySUTRA v0.4.5")
         
         if api_key:
             os.environ["OPENAI_API_KEY"] = api_key
@@ -85,6 +76,7 @@ class SUTRA:
         self.client = OpenAI(api_key=self.api_key) if self.api_key and HAS_OPENAI else None
         
         self.db_path = db
+        self.debug = debug
         
         try:
             self.conn = sqlite3.connect(db, timeout=30, check_same_thread=False)
@@ -133,7 +125,6 @@ class SUTRA:
         
         print(f"Connecting to MySQL...")
         
-        # Auto-create database if not exists
         try:
             temp_conn = mysql.connector.connect(host=host, user=user, password=password, port=port)
             temp_cursor = temp_conn.cursor()
@@ -185,24 +176,7 @@ class SUTRA:
     def upload(self, data: Union[str, pd.DataFrame], name: Optional[str] = None, 
                extract_entities: Optional[List[str]] = None,
                auto_export_mysql: Optional[Dict[str, str]] = None) -> 'SUTRA':
-        """
-        Upload data with OPTIONAL automatic MySQL export.
-        
-        Args:
-            data: File path or DataFrame
-            name: Table name
-            extract_entities: Custom entities to extract
-            auto_export_mysql: Auto-export to MySQL after upload
-                              {'host': 'localhost', 'user': 'root', 'password': 'pass', 'database': 'mydb'}
-        
-        Example:
-            sutra.upload("data.pdf", auto_export_mysql={
-                'host': 'localhost', 
-                'user': 'root', 
-                'password': '123456', 
-                'database': 'my_database'
-            })
-        """
+        """Upload data."""
         print("\nUploading...")
         
         if isinstance(data, pd.DataFrame):
@@ -238,7 +212,6 @@ class SUTRA:
             else:
                 raise ValueError(f"Unsupported: {ext}")
         
-        # AUTO-EXPORT to MySQL if requested
         if auto_export_mysql:
             print("\nAuto-exporting to MySQL...")
             self.save_to_mysql(
@@ -252,7 +225,7 @@ class SUTRA:
         return self
     
     def _smart_upload_pdf(self, path: Path, base_name: str, extract_entities: Optional[List[str]] = None):
-        """Parse PDF - extracts ALL pages."""
+        """Parse PDF."""
         if not HAS_PYPDF2:
             raise ImportError("Run: pip install PyPDF2")
         
@@ -268,7 +241,6 @@ class SUTRA:
         if self.client:
             print("AI: Extracting entities...")
             
-            # Process in chunks for large documents
             chunk_size = 10000
             all_entities = {}
             
@@ -282,11 +254,19 @@ class SUTRA:
                 
                 entities = self._extract_chunk(chunk, extract_entities)
                 
+                if self.debug:
+                    print(f"    DEBUG: Chunk {chunk_num} returned {len(entities)} entity types")
+                
                 for entity_type, records in entities.items():
                     if entity_type not in all_entities:
                         all_entities[entity_type] = []
                     all_entities[entity_type].extend(records)
             
+            if self.debug:
+                print(f"  DEBUG: Total entities collected: {len(all_entities)}")
+                for k, v in all_entities.items():
+                    print(f"    - {k}: {len(v)} records")
+            
             # Renumber IDs
             for entity_type, records in all_entities.items():
                 for idx, record in enumerate(records, 1):
@@ -306,48 +286,8 @@ class SUTRA:
         print("Creating simple table")
         self._store_dataframe(self._parse_text_simple(full_text), base_name)
     
-    def _smart_upload_docx(self, path: Path, base_name: str, extract_entities: Optional[List[str]] = None):
-        """Parse DOCX."""
-        if not HAS_DOCX:
-            raise ImportError("Run: pip install python-docx")
-        
-        doc = docx.Document(path)
-        
-        if doc.tables:
-            for i, table in enumerate(doc.tables):
-                data = [[cell.text.strip() for cell in row.cells] for row in table.rows]
-                if data and len(data) > 1:
-                    df = pd.DataFrame(data[1:], columns=data[0])
-                    self._store_dataframe(df, f"{base_name}_table_{i+1}" if len(doc.tables) > 1 else base_name)
-            return
-        
-        text = "\n".join([para.text for para in doc.paragraphs])
-        
-        if self.client and len(text) > 0:
-            entities = self._extract_chunk(text, extract_entities)
-            for entity_type, records in entities.items():
-                if records:
-                    df = pd.DataFrame(records)
-                    self._store_dataframe_safe(df, f"{base_name}_{entity_type}")
-        else:
-            self._store_dataframe(self._parse_text_simple(text), base_name)
-    
-    def _smart_upload_txt(self, path: Path, base_name: str, extract_entities: Optional[List[str]] = None):
-        """Parse TXT."""
-        with open(path, 'r', encoding='utf-8') as file:
-            text = file.read()
-        
-        if self.client and len(text) > 0:
-            entities = self._extract_chunk(text, extract_entities)
-            for entity_type, records in entities.items():
-                if records:
-                    df = pd.DataFrame(records)
-                    self._store_dataframe_safe(df, f"{base_name}_{entity_type}")
-        else:
-            self._store_dataframe(self._parse_text_simple(text), base_name)
-    
     def _extract_chunk(self, text: str, custom_entities: Optional[List[str]] = None) -> Dict:
-        """Extract entities from text chunk."""
+        """Extract entities - WITH BETTER ERROR HANDLING."""
         if not self.client:
             return {}
         
@@ -357,35 +297,98 @@ class SUTRA:
 Text:
 {text[:8000]}
 
-Extract entities like: people, skills, technologies, projects, certifications, education, work_experience, events, organizations, or ANY other structured data.
+Extract: people, skills, technologies, projects, certifications, education, work_experience, events, organizations, or ANY structured data.
 
-Return JSON with arrays. Use sequential IDs (1,2,3...). Foreign keys reference primary keys.
+Return JSON with arrays. Sequential IDs. Foreign keys reference primary keys.
 
-Example:
 {{
   "people": [{{"id": 1, "name": "John", "email": "john@co.com", "city": "Dallas"}}, ...],
   "skills": [{{"id": 1, "person_id": 1, "skill_name": "Python"}}, ...]
 }}
 
-Return ONLY valid JSON."""
+ONLY valid JSON. No explanations."""
 
             resp = self.client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=[
-                    {"role": "system", "content": "Extract ALL entities with unique IDs. Return only JSON."},
+                    {"role": "system", "content": "Extract ALL entities with unique IDs. Return ONLY valid JSON, nothing else."},
                     {"role": "user", "content": prompt}
                 ],
                 temperature=0,
                 max_tokens=8000
             )
             
-            json_text = resp.choices[0].message.content.strip().replace("```json", "").replace("```", "").strip()
-            return json.loads(json_text)
+            json_text = resp.choices[0].message.content.strip()
+            
+            if self.debug:
+                print(f"    DEBUG: AI response length: {len(json_text)} chars")
+                print(f"    DEBUG: First 200 chars: {json_text[:200]}")
+            
+            json_text = json_text.replace("```json", "").replace("```", "").strip()
+            
+            result = json.loads(json_text)
+            
+            if self.debug:
+                print(f"    DEBUG: Parsed {len(result)} entity types")
+            
+            return result
+            
+        except json.JSONDecodeError as e:
+            if self.debug:
+                print(f"    DEBUG: JSON parse error: {e}")
+                print(f"    DEBUG: Response was: {json_text[:500]}")
+            return {}
         except Exception as e:
+            if self.debug:
+                print(f"    DEBUG: Extraction error: {e}")
             return {}
     
+    def _smart_upload_docx(self, path: Path, base_name: str, extract_entities: Optional[List[str]] = None):
+        """Parse DOCX."""
+        if not HAS_DOCX:
+            raise ImportError("Run: pip install python-docx")
+        
+        doc = docx.Document(path)
+        
+        if doc.tables:
+            for i, table in enumerate(doc.tables):
+                data = [[cell.text.strip() for cell in row.cells] for row in table.rows]
+                if data and len(data) > 1:
+                    df = pd.DataFrame(data[1:], columns=data[0])
+                    self._store_dataframe(df, f"{base_name}_table_{i+1}" if len(doc.tables) > 1 else base_name)
+            return
+        
+        text = "\n".join([para.text for para in doc.paragraphs])
+        
+        if self.client and len(text) > 0:
+            entities = self._extract_chunk(text, extract_entities)
+            if entities:
+                for entity_type, records in entities.items():
+                    if records:
+                        df = pd.DataFrame(records)
+                        self._store_dataframe_safe(df, f"{base_name}_{entity_type}")
+                return
+        
+        self._store_dataframe(self._parse_text_simple(text), base_name)
+    
+    def _smart_upload_txt(self, path: Path, base_name: str, extract_entities: Optional[List[str]] = None):
+        """Parse TXT."""
+        with open(path, 'r', encoding='utf-8') as file:
+            text = file.read()
+        
+        if self.client and len(text) > 0:
+            entities = self._extract_chunk(text, extract_entities)
+            if entities:
+                for entity_type, records in entities.items():
+                    if records:
+                        df = pd.DataFrame(records)
+                        self._store_dataframe_safe(df, f"{base_name}_{entity_type}")
+                return
+        
+        self._store_dataframe(self._parse_text_simple(text), base_name)
+    
     def _store_dataframe_safe(self, df: pd.DataFrame, name: str):
-        """Store with error handling."""
+        """Store."""
         try:
             df.columns = [str(c).strip().replace(" ", "_").replace("-", "_") for c in df.columns]
             df.to_sql(name, self.conn, if_exists='replace', index=False, method='multi', chunksize=500)
@@ -403,7 +406,6 @@ Return ONLY valid JSON."""
         lines = [line.strip() for line in text.split('\n') if line.strip()]
         if not lines:
             return pd.DataFrame({'content': ['No content']})
-        
         return pd.DataFrame({'line_number': range(1, len(lines) + 1), 'content': lines})
     
     def _store_dataframe(self, df: pd.DataFrame, name: str):
@@ -412,14 +414,14 @@ Return ONLY valid JSON."""
         print(f"Uploaded: {name} ({len(df)} rows)")
     
     def ask(self, question: str, viz: Union[bool, str] = False, table: Optional[str] = None) -> 'QueryResult':
-        """Natural language query."""
+        """Query."""
         if not self.client:
             return QueryResult(False, "", pd.DataFrame(), None, "No API key")
         
         print(f"\nQuestion: {question}")
         
         if self.check_relevance and not self._is_relevant_query(question):
-            print("Warning: Irrelevant query")
+            print("Warning: Irrelevant")
             choice = input("Continue? (yes/no): ").strip().lower()
             if choice not in ['yes', 'y']:
                 return QueryResult(False, "", pd.DataFrame(), None, "Irrelevant")
@@ -471,13 +473,8 @@ Return ONLY valid JSON."""
         """Check relevance."""
         if not self.client:
             return True
-        
         try:
             tables = self._get_table_names()[:3]
-            cols = []
-            for tbl in tables:
-                cols.extend(list(self.schema_info.get(tbl, {}).keys())[:5])
-            
             resp = self.client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=[
@@ -492,7 +489,7 @@ Return ONLY valid JSON."""
             return True
     
     def _apply_fuzzy_matching(self, question: str, table: str) -> str:
-        """Fuzzy matching."""
+        """Fuzzy."""
         if not self.schema_info.get(table):
             return question
         
@@ -522,13 +519,11 @@ Return ONLY valid JSON."""
             return None
         
         q_emb = self.embedding_model.encode([question])[0]
-        best_match = None
-        best_sim = 0.85
+        best_match, best_sim = None, 0.85
         
         for cached_q, data in self.query_embeddings.items():
             if data['table'] != table:
                 continue
-            
             sim = np.dot(q_emb, data['embedding']) / (np.linalg.norm(q_emb) * np.linalg.norm(data['embedding']))
             if sim > best_sim:
                 best_sim = sim
@@ -537,19 +532,17 @@ Return ONLY valid JSON."""
         if best_match:
             print(f"  Similar ({best_sim:.0%})")
             return self.query_embeddings[best_match]['result']
-        
         return None
     
     def _store_in_embedding_cache(self, question: str, table: str, result: 'QueryResult'):
-        """Store cache."""
+        """Store."""
         q_emb = self.embedding_model.encode([question])[0]
         self.query_embeddings[question] = {'table': table, 'embedding': q_emb, 'result': result}
     
     def _visualize(self, df: pd.DataFrame, title: str, viz_type: str = "auto"):
-        """Visualize."""
+        """Viz."""
         if not HAS_PLOTLY and not HAS_MATPLOTLIB:
             return None
-        
         print(f"Creating {viz_type} chart...")
         return self._plotly_viz(df, title, viz_type) if HAS_PLOTLY else self._matplotlib_viz(df, title, viz_type)
     
@@ -578,7 +571,6 @@ Return ONLY valid JSON."""
                     fig = px.pie(df, names=cat[0], values=num[0], title=title) if len(df) <= 10 else px.bar(df, x=cat[0], y=num[0], title=title)
                 else:
                     fig = px.bar(df, y=df.columns[0], title=title)
-            
             fig.show()
             return fig
         except:
@@ -589,14 +581,12 @@ Return ONLY valid JSON."""
         try:
             plt.figure(figsize=(10, 6))
             num = df.select_dtypes(include=[np.number]).columns
-            
             if viz_type == "pie":
                 df[df.columns[0]].value_counts().plot(kind='pie')
             elif viz_type == "line" and len(num) > 0:
                 df[num[0]].plot(kind='line')
             else:
                 (df[num[0]] if len(num) > 0 else df.iloc[:, 0].value_counts()).plot(kind='bar')
-            
             plt.title(title)
             plt.tight_layout()
             plt.show()
@@ -605,7 +595,7 @@ Return ONLY valid JSON."""
             return None
     
     def tables(self) -> Dict[str, dict]:
-        """List tables."""
+        """List."""
         print("\n" + "="*70)
         print("TABLES")
         print("="*70)
@@ -626,7 +616,7 @@ Return ONLY valid JSON."""
         return result
     
     def schema(self, table: Optional[str] = None) -> dict:
-        """Show schema."""
+        """Schema."""
         if not self.schema_info:
             self._refresh_schema()
         
@@ -651,18 +641,17 @@ Return ONLY valid JSON."""
         tbl = table or self.current_table
         if not tbl:
             return pd.DataFrame()
-        
         df = pd.read_sql_query(f"SELECT * FROM {tbl} LIMIT {n}", self.conn)
         print(f"\nSample from '{tbl}':")
         print(df.to_string(index=False))
         return df
     
     def info(self):
-        """Overview."""
+        """Info."""
         return self.tables()
     
     def sql(self, query: str, viz: Union[bool, str] = False) -> 'QueryResult':
-        """Execute SQL."""
+        """SQL."""
         try:
             df = pd.read_sql_query(query, self.conn)
             print(f"Success! {len(df)} rows")
@@ -679,7 +668,7 @@ Return ONLY valid JSON."""
         return self.ask(question, viz=viz)
     
     def export_db(self, path: str, format: str = "sqlite"):
-        """Export database."""
+        """Export."""
         if format == "sqlite":
             shutil.copy2(self.db_path, path)
         elif format == "sql":
@@ -696,25 +685,12 @@ Return ONLY valid JSON."""
                     pd.read_sql_query(f"SELECT * FROM {t}", self.conn).to_excel(writer, sheet_name=t[:31], index=False)
         else:
             raise ValueError(f"Unsupported: {format}")
-        
         print(f"Saved: {path}")
         return self
     
     def save_to_mysql(self, host: str, user: str, password: str, database: str, 
-                      port: int = 3306, tables: Optional[List[str]] = None,
-                      auto_create: bool = True):
-        """
-        Export to MySQL - AUTO-CREATES database if not exists.
-        
-        Args:
-            host: MySQL host
-            user: MySQL user
-            password: MySQL password
-            database: Database name (auto-created if not exists)
-            port: MySQL port
-            tables: Specific tables to export (None = all)
-            auto_create: Auto-create database if not exists
-        """
+                      port: int = 3306, tables: Optional[List[str]] = None, auto_create: bool = True):
+        """Export to MySQL."""
         try:
             from sqlalchemy import create_engine
             import mysql.connector
@@ -723,7 +699,6 @@ Return ONLY valid JSON."""
         
         print(f"Exporting to MySQL: {host}/{database}")
         
-        # Auto-create database if requested
         if auto_create:
             try:
                 temp_conn = mysql.connector.connect(host=host, user=user, password=password, port=port)
@@ -733,7 +708,7 @@ Return ONLY valid JSON."""
                 temp_conn.close()
                 print(f"  Database '{database}' ready")
             except Exception as e:
-                print(f"  Warning: Could not auto-create database: {e}")
+                print(f"  Warning: {e}")
         
         engine = create_engine(f"mysql+mysqlconnector://{user}:{password}@{host}:{port}/{database}")
         
@@ -745,13 +720,11 @@ Return ONLY valid JSON."""
         print("Complete!")
         return self
     
-    def save_to_postgres(self, host: str, user: str, password: str, database: str, 
-                         port: int = 5432, tables: Optional[List[str]] = None):
-        """Export to PostgreSQL."""
+    def save_to_postgres(self, host: str, user: str, password: str, database: str, port: int = 5432, tables: Optional[List[str]] = None):
+        """PostgreSQL."""
         try:
             from sqlalchemy import create_engine
             engine = create_engine(f"postgresql://{user}:{password}@{host}:{port}/{database}")
-            
             print(f"Exporting to PostgreSQL...")
             for t in (tables or self._get_table_names()):
                 df = pd.read_sql_query(f"SELECT * FROM {t}", self.conn)
@@ -767,14 +740,13 @@ Return ONLY valid JSON."""
         dir = Path(path) if path else Path(".")
         dir.mkdir(parents=True, exist_ok=True)
         ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        
         self.export_db(str(dir / f"sutra_{ts}.db"), "sqlite")
         self.export_db(str(dir / f"sutra_{ts}.json"), "json")
         print("Backup complete!")
         return self
     
     def export(self, data: pd.DataFrame, path: str, format: str = "csv"):
-        """Export results."""
+        """Export."""
         if format == "csv":
             data.to_csv(path, index=False)
         elif format in ["excel", "xlsx"]:
@@ -790,7 +762,7 @@ Return ONLY valid JSON."""
             self.conn.close()
     
     def _get_table_names(self) -> List[str]:
-        """Get tables."""
+        """Tables."""
         self.cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
         return [r[0] for r in self.cursor.fetchall()]
     
@@ -802,7 +774,7 @@ Return ONLY valid JSON."""
             self.schema_info[tbl] = {r[1]: r[2] for r in self.cursor.fetchall()}
     
     def _generate_sql(self, question: str, table: str) -> str:
-        """Generate SQL."""
+        """SQL."""
         schema = self.schema_info.get(table, {})
         sample = pd.read_sql_query(f"SELECT * FROM {table} LIMIT 3", self.conn).to_string(index=False)
         schema_str = ", ".join([f"{col} ({dtype})" for col, dtype in schema.items()])
@@ -815,7 +787,6 @@ Return ONLY valid JSON."""
             ],
             temperature=0
         )
-        
         return resp.choices[0].message.content.strip().replace("```sql", "").replace("```", "").strip()
     
     def __enter__(self):
@@ -842,11 +813,7 @@ class QueryResult:
 
 
 def quick_start(api_key: str, data_path: str, question: str, viz: Union[bool, str] = False):
-    """Quick start."""
+    """Quick."""
     with SUTRA(api_key=api_key) as sutra:
         sutra.upload(data_path)
         return sutra.ask(question, viz=viz)
-
-
-if __name__ == "__main__":
-    print("QuerySUTRA v0.4.0 - Simple & Automatic")