QuerySUTRA 0.5.2__tar.gz → 0.6.0__tar.gz

{querysutra-0.5.2 → querysutra-0.6.0}/PKG-INFO

@@ -1,9 +1,25 @@
 Metadata-Version: 2.4
 Name: QuerySUTRA
-Version: 0.5.2
-Summary: SUTRA
+Version: 0.6.0
+Summary: AI-powered data analysis for structured and unstructured data. Query PDF, Word, CSV, Excel with natural language.
 Author: Aditya Batta
 License: MIT
+Project-URL: Homepage, https://github.com/adityabatta/QuerySUTRA
+Project-URL: Repository, https://github.com/adityabatta/QuerySUTRA
+Project-URL: Issues, https://github.com/adityabatta/QuerySUTRA/issues
+Keywords: ai,data-analysis,nlp,sql,pdf,openai,natural-language,query,database
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Database
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE

{querysutra-0.5.2 → querysutra-0.6.0}/QuerySUTRA.egg-info/PKG-INFO

@@ -1,9 +1,25 @@
 Metadata-Version: 2.4
 Name: QuerySUTRA
-Version: 0.5.2
-Summary: SUTRA
+Version: 0.6.0
+Summary: AI-powered data analysis for structured and unstructured data. Query PDF, Word, CSV, Excel with natural language.
 Author: Aditya Batta
 License: MIT
+Project-URL: Homepage, https://github.com/adityabatta/QuerySUTRA
+Project-URL: Repository, https://github.com/adityabatta/QuerySUTRA
+Project-URL: Issues, https://github.com/adityabatta/QuerySUTRA/issues
+Keywords: ai,data-analysis,nlp,sql,pdf,openai,natural-language,query,database
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Database
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE

querysutra-0.6.0/QuerySUTRA.egg-info/top_level.txt

@@ -0,0 +1 @@
+sutra

querysutra-0.6.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "QuerySUTRA"
+version = "0.6.0"
+description = "AI-powered data analysis for structured and unstructured data. Query PDF, Word, CSV, Excel with natural language."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "Aditya Batta"}]
+keywords = ["ai", "data-analysis", "nlp", "sql", "pdf", "openai", "natural-language", "query", "database"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Database",
+]
+dependencies = [
+    "pandas>=1.3.0",
+    "numpy>=1.21.0",
+    "openai>=1.0.0",
+    "plotly>=5.0.0",
+    "matplotlib>=3.3.0",
+    "PyPDF2>=3.0.0",
+    "python-docx>=0.8.11",
+    "openpyxl>=3.0.0"
+]
+
+[project.optional-dependencies]
+mysql = ["sqlalchemy>=1.4.0", "mysql-connector-python>=8.0.0"]
+postgres = ["sqlalchemy>=1.4.0", "psycopg2-binary>=2.9.0"]
+embeddings = ["sentence-transformers>=2.0.0"]
+all = [
+    "sqlalchemy>=1.4.0",
+    "mysql-connector-python>=8.0.0",
+    "psycopg2-binary>=2.9.0",
+    "sentence-transformers>=2.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/adityabatta/QuerySUTRA"
+Repository = "https://github.com/adityabatta/QuerySUTRA"
+Issues = "https://github.com/adityabatta/QuerySUTRA/issues"
+
+[tool.setuptools.packages.find]
+include = ["sutra*"]
+exclude = ["tests*", "examples*", "data*", "venv*"]

{querysutra-0.5.2 → querysutra-0.6.0}/requirements.txt

@@ -1,4 +1,4 @@
-openai==1.12.0
+openai>=1.0.0
 pandas==2.2.0
 numpy==1.24.3
 matplotlib==3.7.1

querysutra-0.6.0/setup.py

@@ -0,0 +1,3 @@
+from setuptools import setup,find_packages
+with open("README.md","r",encoding="utf-8") as f:d=f.read()
+setup(name="QuerySUTRA",version="0.6.0",author="Aditya Batta",description="AI-powered data analysis for structured and unstructured data. Query PDF, Word, CSV, Excel with natural language.",long_description=d,long_description_content_type="text/markdown",packages=find_packages(),python_requires=">=3.8",install_requires=["pandas>=1.3.0","numpy>=1.21.0","openai>=1.0.0","plotly>=5.0.0","matplotlib>=3.3.0","PyPDF2>=3.0.0","python-docx>=0.8.11","openpyxl>=3.0.0"],extras_require={"mysql":["sqlalchemy>=1.4.0","mysql-connector-python>=8.0.0"],"postgres":["sqlalchemy>=1.4.0","psycopg2-binary>=2.9.0"],"embeddings":["sentence-transformers>=2.0.0"],"all":["sqlalchemy>=1.4.0","mysql-connector-python>=8.0.0","psycopg2-binary>=2.9.0","sentence-transformers>=2.0.0"]})

querysutra-0.6.0/sutra/__init__.py

@@ -0,0 +1,6 @@
+"""QuerySUTRA v0.6.0 - AI-powered data analysis for structured and unstructured data"""
+__version__ = "0.6.0"
+
+from .sutra import SUTRA, QueryResult
+
+__all__ = ["SUTRA", "QueryResult", "__version__"]

{querysutra-0.5.2 → querysutra-0.6.0}/sutra/database_manager.py

@@ -1,196 +1,236 @@
-"""Database management for both SQLite and MySQL"""
-
-import sqlite3
-import pandas as pd
-from pathlib import Path
-from typing import Optional, Tuple, List
-from tabulate import tabulate
-import config
-
-# Add MySQL support
-try:
-    import mysql.connector
-    MYSQL_AVAILABLE = True
-except ImportError:
-    MYSQL_AVAILABLE = False
-    print("⚠️ MySQL not installed. Run: pip install mysql-connector-python")
-
-class DatabaseManager:
-    """Manage database operations (SQLite or MySQL)"""
-    
-    """Database management for both SQLite and MySQL"""
-
-import sqlite3
-import pandas as pd
-from pathlib import Path
-from typing import Optional, Tuple, List
-from tabulate import tabulate
-import config
-
-# Add MySQL support
-try:
-    import mysql.connector
-    MYSQL_AVAILABLE = True
-except ImportError:
-    MYSQL_AVAILABLE = False
-    print("⚠️ MySQL not installed. Run: pip install mysql-connector-python")
-
-class DatabaseManager:
-    """Manage database operations (SQLite or MySQL)"""
-    
-    def __init__(self, db_path: str = ':memory:', db_type: str = 'sqlite'):  # FIX: Added indentation
-        self.db_type = db_type.lower()
-        
-        if self.db_type == 'mysql':
-            if not MYSQL_AVAILABLE:
-                print("❌ MySQL not available, falling back to SQLite")
-                self.db_type = 'sqlite'
-            else:
-                # First connect without database to create it if needed
-                try:
-                    conn_temp = mysql.connector.connect(
-                        host=config.MYSQL_HOST,
-                        user=config.MYSQL_USER,
-                        password=config.MYSQL_PASSWORD
-                    )
-                    cursor_temp = conn_temp.cursor()
-                    cursor_temp.execute(f"CREATE DATABASE IF NOT EXISTS {config.MYSQL_DATABASE}")
-                    conn_temp.close()
-                    print(f"✅ Database {config.MYSQL_DATABASE} ready")
-                except Exception as e:
-                    print(f"❌ Could not create database: {e}")
-                
-                # Now connect to the database
-                self.conn = mysql.connector.connect(
-                    host=config.MYSQL_HOST,
-                    user=config.MYSQL_USER,
-                    password=config.MYSQL_PASSWORD,
-                    database=config.MYSQL_DATABASE
-                )
-                self.cursor = self.conn.cursor()
-                print(f"📂 Connected to MySQL: {config.MYSQL_DATABASE}")
-        
-        if self.db_type == 'sqlite':  # FIX: Added this block for SQLite
-            self.conn = sqlite3.connect(db_path)
-            self.cursor = self.conn.cursor()
-            print(f"📂 SQLite {'created in memory' if db_path == ':memory:' else f'connected: {db_path}'}")
-    
-    # Rest of the methods stay the same...
-    
-    def execute_schema(self, schema_sql: str) -> bool:
-        """Execute SQL schema with MySQL compatibility"""
-        try:
-            if self.db_type == 'mysql':
-                # MySQL adjustments
-                schema_sql = schema_sql.replace('INTEGER PRIMARY KEY AUTOINCREMENT', 
-                                                'INT PRIMARY KEY AUTO_INCREMENT')
-                schema_sql = schema_sql.replace('TEXT', 'VARCHAR(255)')
-                schema_sql = schema_sql.replace('REAL', 'DECIMAL(10,2)')
-                
-                # Execute statements one by one for MySQL
-                for statement in schema_sql.split(';'):
-                    if statement.strip():
-                        self.cursor.execute(statement)
-                self.conn.commit()
-            else:
-                # SQLite can handle multiple statements
-                self.cursor.executescript(schema_sql)
-                self.conn.commit()
-            
-            print("✅ Schema executed successfully!")
-            return True
-        except Exception as e:
-            print(f"❌ Error executing schema: {e}")
-            return False
-    
-    def execute_query(self, query: str) -> Optional[pd.DataFrame]:
-        """Execute query on either database"""
-        try:
-            df = pd.read_sql_query(query, self.conn)
-            return df
-        except Exception as e:
-            print(f"❌ Query error: {e}")
-            return None
-    
-    def get_tables(self):
-        """Get list of all tables in database"""
-        if self.db_type == 'mysql':
-            cursor = self.conn.cursor()
-            cursor.execute("SHOW TABLES")
-            tables = [table[0] for table in cursor.fetchall()]
-            cursor.close()
-            return tables
-        else:  # sqlite
-            cursor = self.conn.cursor()
-            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
-            tables = [table[0] for table in cursor.fetchall()]
-            cursor.close()
-            return tables
-
-    def get_columns(self, table_name):
-        """Get list of columns for a specific table"""
-        if self.db_type == 'mysql':
-            cursor = self.conn.cursor()
-            cursor.execute(f"SHOW COLUMNS FROM `{table_name}`")
-            columns = [col[0] for col in cursor.fetchall()]
-            cursor.close()
-            return columns
-        else:  # sqlite
-            cursor = self.conn.cursor()
-            cursor.execute(f"PRAGMA table_info({table_name})")
-            columns = [col[1] for col in cursor.fetchall()]
-            cursor.close()
-            return columns
-    
-    def get_schema_context(self) -> str:
-        """Get database schema"""
-        if self.db_type == 'mysql':
-            tables = self.get_tables()
-            schema = []
-            for table in tables:
-                self.cursor.execute(f"SHOW CREATE TABLE {table}")
-                schema.append(self.cursor.fetchone()[1])
-            return '\n'.join(schema)
-        else:
-            self.cursor.execute(
-                "SELECT sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';"
-            )
-            return '\n'.join([row[0] for row in self.cursor.fetchall()])
-    
-    def display_tables(self):  # FIX: Proper indentation - part of class
-        """Display all tables with their structure and data"""
-        tables = self.get_tables()
-        print(f"\n📋 Created {len(tables)} tables:")
-        
-        for table in tables:
-            print(f"\n  Table: {table}")
-            
-            # Show columns
-            columns = self.get_table_info(table)
-            for col in columns:
-                print(f"    - {col[1]} ({col[2]})")
-            
-            # Show row count
-            count = self.get_row_count(table)
-            print(f"    Records: {count}")
-    
-    def get_table_info(self, table_name: str) -> List[Tuple]:  # FIX: Proper indentation
-        """Get column information for a table"""
-        if self.db_type == 'mysql':
-            self.cursor.execute(f"DESCRIBE {table_name}")
-            return [(i, row[0], row[1]) for i, row in enumerate(self.cursor.fetchall())]
-        else:
-            self.cursor.execute(f"PRAGMA table_info({table_name})")
-            return self.cursor.fetchall()
-    
-    def get_row_count(self, table_name: str) -> int:  # FIX: Proper indentation
-        """Get number of rows in a table"""
-        self.cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
-        return self.cursor.fetchone()[0]
-    
-    def close(self):
-        """Close database connection"""
-        self.conn.close()
-        print("📂 Database connection closed")
-
+"""Database management for both SQLite and MySQL"""
+
+import sqlite3
+import pandas as pd
+from pathlib import Path
+from typing import Optional, Tuple, List
+from tabulate import tabulate
+import config
+
+# Add MySQL support
+try:
+    import mysql.connector
+    MYSQL_AVAILABLE = True
+except ImportError:
+    MYSQL_AVAILABLE = False
+    print("⚠️ MySQL not installed. Run: pip install mysql-connector-python")
+
+class DatabaseManager:
+    """Manage database operations (SQLite or MySQL)"""
+    
+    """Database management for both SQLite and MySQL"""
+
+import sqlite3
+import pandas as pd
+from pathlib import Path
+from typing import Optional, Tuple, List
+from tabulate import tabulate
+import config
+
+# Add MySQL support
+try:
+    import mysql.connector
+    MYSQL_AVAILABLE = True
+except ImportError:
+    MYSQL_AVAILABLE = False
+    print("⚠️ MySQL not installed. Run: pip install mysql-connector-python")
+
+class DatabaseManager:
+    """Manage database operations (SQLite or MySQL)"""
+    
+    def __init__(self, db_path: str = ':memory:', db_type: str = 'sqlite'):  # FIX: Added indentation
+        self.db_type = db_type.lower()
+        
+        if self.db_type == 'mysql':
+            if not MYSQL_AVAILABLE:
+                print("❌ MySQL not available, falling back to SQLite")
+                self.db_type = 'sqlite'
+            else:
+                # First connect without database to create it if needed
+                try:
+                    conn_temp = mysql.connector.connect(
+                        host=config.MYSQL_HOST,
+                        user=config.MYSQL_USER,
+                        password=config.MYSQL_PASSWORD
+                    )
+                    cursor_temp = conn_temp.cursor()
+                    cursor_temp.execute(f"CREATE DATABASE IF NOT EXISTS {config.MYSQL_DATABASE}")
+                    conn_temp.close()
+                    print(f"✅ Database {config.MYSQL_DATABASE} ready")
+                except Exception as e:
+                    print(f"❌ Could not create database: {e}")
+                
+                # Now connect to the database
+                self.conn = mysql.connector.connect(
+                    host=config.MYSQL_HOST,
+                    user=config.MYSQL_USER,
+                    password=config.MYSQL_PASSWORD,
+                    database=config.MYSQL_DATABASE
+                )
+                self.cursor = self.conn.cursor()
+                print(f"📂 Connected to MySQL: {config.MYSQL_DATABASE}")
+        
+        if self.db_type == 'sqlite':  # FIX: Added this block for SQLite
+            self.conn = sqlite3.connect(db_path)
+            self.cursor = self.conn.cursor()
+            print(f"📂 SQLite {'created in memory' if db_path == ':memory:' else f'connected: {db_path}'}")
+    
+    # Rest of the methods stay the same...
+    
+    def execute_schema(self, schema_sql: str) -> bool:
+        """Execute SQL schema with MySQL compatibility"""
+        try:
+            if self.db_type == 'mysql':
+                # MySQL adjustments
+                schema_sql = schema_sql.replace('INTEGER PRIMARY KEY AUTOINCREMENT', 
+                                                'INT PRIMARY KEY AUTO_INCREMENT')
+                schema_sql = schema_sql.replace('TEXT', 'VARCHAR(255)')
+                schema_sql = schema_sql.replace('REAL', 'DECIMAL(10,2)')
+                
+                # Execute statements one by one for MySQL
+                for statement in schema_sql.split(';'):
+                    if statement.strip():
+                        self.cursor.execute(statement)
+                self.conn.commit()
+            else:
+                # SQLite can handle multiple statements
+                self.cursor.executescript(schema_sql)
+                self.conn.commit()
+            
+            print("✅ Schema executed successfully!")
+            return True
+        except Exception as e:
+            print(f"❌ Error executing schema: {e}")
+            return False
+    
+    def execute_query(self, query: str) -> Optional[pd.DataFrame]:
+        """Execute query on either database"""
+        try:
+            df = pd.read_sql_query(query, self.conn)
+            return df
+        except Exception as e:
+            print(f"❌ Query error: {e}")
+            return None
+    
+    def get_tables(self):
+        """Get list of all tables in database"""
+        if self.db_type == 'mysql':
+            cursor = self.conn.cursor()
+            cursor.execute("SHOW TABLES")
+            tables = [table[0] for table in cursor.fetchall()]
+            cursor.close()
+            return tables
+        else:  # sqlite
+            cursor = self.conn.cursor()
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+            tables = [table[0] for table in cursor.fetchall()]
+            cursor.close()
+            return tables
+
+    def get_columns(self, table_name):
+        """Get list of columns for a specific table"""
+        if self.db_type == 'mysql':
+            cursor = self.conn.cursor()
+            cursor.execute(f"SHOW COLUMNS FROM `{table_name}`")
+            columns = [col[0] for col in cursor.fetchall()]
+            cursor.close()
+            return columns
+        else:  # sqlite
+            cursor = self.conn.cursor()
+            cursor.execute(f"PRAGMA table_info({table_name})")
+            columns = [col[1] for col in cursor.fetchall()]
+            cursor.close()
+            return columns
+    
+    def get_schema_context(self) -> str:
+        """Get database schema with relationship information"""
+        if self.db_type == 'mysql':
+            tables = self.get_tables()
+            schema = []
+            for table in tables:
+                self.cursor.execute(f"SHOW CREATE TABLE {table}")
+                schema.append(self.cursor.fetchone()[1])
+            schema_text = '\n'.join(schema)
+        else:
+            self.cursor.execute(
+                "SELECT sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';"
+            )
+            schema_text = '\n'.join([row[0] for row in self.cursor.fetchall()])
+        
+        # Add relationship summary at the beginning
+        relationships = self._extract_relationships(schema_text)
+        if relationships:
+            relationship_summary = "\n=== TABLE RELATIONSHIPS ===\n" + "\n".join(relationships) + "\n\n=== FULL SCHEMA ===\n"
+            return relationship_summary + schema_text
+        return schema_text
+    
+    def _extract_relationships(self, schema_text: str) -> List[str]:
+        """Extract and format foreign key relationships from schema"""
+        import re
+        relationships = []
+        
+        # Pattern to match FOREIGN KEY statements
+        fk_pattern = r'FOREIGN KEY\s*\(([^)]+)\)\s*REFERENCES\s+(\w+)\s*\(([^)]+)\)'
+        
+        # Split schema into individual table definitions
+        tables = schema_text.split('CREATE TABLE')
+        
+        for table_def in tables:
+            if not table_def.strip():
+                continue
+            
+            # Extract table name
+            table_match = re.search(r'[`"]?(\w+)[`"]?', table_def)
+            if not table_match:
+                continue
+            table_name = table_match.group(1)
+            
+            # Find all foreign keys in this table
+            for match in re.finditer(fk_pattern, table_def, re.IGNORECASE):
+                fk_column = match.group(1).strip('`" ')
+                ref_table = match.group(2).strip('`" ')
+                ref_column = match.group(3).strip('`" ')
+                
+                relationships.append(
+                    f"  {table_name}.{fk_column} → {ref_table}.{ref_column}"
+                )
+        
+        return relationships
+    
+    def display_tables(self):  # FIX: Proper indentation - part of class
+        """Display all tables with their structure and data"""
+        tables = self.get_tables()
+        print(f"\n📋 Created {len(tables)} tables:")
+        
+        for table in tables:
+            print(f"\n  Table: {table}")
+            
+            # Show columns
+            columns = self.get_table_info(table)
+            for col in columns:
+                print(f"    - {col[1]} ({col[2]})")
+            
+            # Show row count
+            count = self.get_row_count(table)
+            print(f"    Records: {count}")
+    
+    def get_table_info(self, table_name: str) -> List[Tuple]:  # FIX: Proper indentation
+        """Get column information for a table"""
+        if self.db_type == 'mysql':
+            self.cursor.execute(f"DESCRIBE {table_name}")
+            return [(i, row[0], row[1]) for i, row in enumerate(self.cursor.fetchall())]
+        else:
+            self.cursor.execute(f"PRAGMA table_info({table_name})")
+            return self.cursor.fetchall()
+    
+    def get_row_count(self, table_name: str) -> int:  # FIX: Proper indentation
+        """Get number of rows in a table"""
+        self.cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+        return self.cursor.fetchone()[0]
+    
+    def close(self):
+        """Close database connection"""
+        self.conn.close()
+        print("📂 Database connection closed")
+