sqlshell 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

sqlshell/utils/profile_keys.py

@@ -0,0 +1,356 @@
+import sys
+import itertools
+import pandas as pd
+import random
+from PyQt6.QtWidgets import (
+    QApplication, QWidget, QVBoxLayout, QLabel, QTableWidget, QTableWidgetItem, QHeaderView, QTabWidget, QMainWindow
+)
+from PyQt6.QtCore import Qt
+
+
+def find_functional_dependencies(df: pd.DataFrame, max_lhs_size: int = 2):
+    """
+    Discover all functional dependencies X -> A in the DataFrame for |X| <= max_lhs_size.
+    Returns a list of tuples (lhs, rhs).
+    """
+    fds = []
+    cols = list(df.columns)
+    n_rows = len(df)
+
+    for size in range(1, max_lhs_size + 1):
+        for lhs in itertools.combinations(cols, size):
+            # for each potential dependent attribute not in lhs
+            lhs_df = df[list(lhs)]
+            # group by lhs and count distinct values of each other column
+            grouped = df.groupby(list(lhs))
+            for rhs in cols:
+                if rhs in lhs:
+                    continue
+                # Check if for each group, rhs has only one distinct value
+                distinct_counts = grouped[rhs].nunique(dropna=False)
+                if (distinct_counts <= 1).all():
+                    fds.append((lhs, rhs))
+    return fds
+
+
+def propose_normalized_tables(cols, candidate_keys, fds):
+    """
+    Propose a set of normalized tables based on functional dependencies.
+    Uses a simplified approach to create 3NF tables.
+    
+    Parameters:
+    - cols: list of all columns
+    - candidate_keys: list of candidate keys
+    - fds: list of functional dependencies as (lhs, rhs) tuples
+    
+    Returns:
+    - List of proposed tables as (table_name, primary_key, attributes) tuples
+    """
+    # Start with a set of all attributes
+    all_attrs = set(cols)
+    proposed_tables = []
+    
+    # Group FDs by their determinants (LHS)
+    determinant_groups = {}
+    for lhs, rhs in fds:
+        lhs_key = tuple(sorted(lhs))
+        if lhs_key not in determinant_groups:
+            determinant_groups[lhs_key] = []
+        determinant_groups[lhs_key].append(rhs)
+    
+    # Create tables for each determinant group
+    table_counter = 1
+    for lhs, rhs_list in determinant_groups.items():
+        table_attrs = set(lhs) | set(rhs_list)
+        if table_attrs:  # Skip empty tables
+            table_name = f"Table_{table_counter}"
+            primary_key = ", ".join(lhs)
+            attributes = list(table_attrs)
+            proposed_tables.append((table_name, primary_key, attributes))
+            table_counter += 1
+    
+    # Create a table for any remaining attributes not in any FD
+    # or create a table with a candidate key if none exists yet
+    used_attrs = set()
+    for _, _, attrs in proposed_tables:
+        used_attrs.update(attrs)
+    
+    remaining_attrs = all_attrs - used_attrs
+    if remaining_attrs:
+        # If we have a candidate key, use it for remaining attributes
+        for key in candidate_keys:
+            key_set = set(key)
+            if key_set & remaining_attrs:  # If key has overlap with remaining attrs
+                table_name = f"Table_{table_counter}"
+                primary_key = ", ".join(key)
+                attributes = list(remaining_attrs | key_set)
+                proposed_tables.append((table_name, primary_key, attributes))
+                break
+        else:  # No suitable candidate key
+            table_name = f"Table_{table_counter}"
+            primary_key = "id (suggested)"
+            attributes = list(remaining_attrs)
+            proposed_tables.append((table_name, primary_key, attributes))
+    
+    return proposed_tables
+
+
+def profile(df: pd.DataFrame, max_combination_size: int = 2, max_lhs_size: int = 2):
+    """
+    Analyze a pandas DataFrame to suggest candidate keys and discover functional dependencies.
+
+    Parameters:
+    - df: pandas.DataFrame to analyze.
+    - max_combination_size: max size of column combos to test for keys.
+    - max_lhs_size: max size of LHS in discovered FDs.
+    
+    Returns:
+    - Tuple of (fd_results, key_results, n_rows, cols, max_combination_size, max_lhs_size, normalized_tables)
+    """
+    n_rows = len(df)
+    cols = list(df.columns)
+
+    # Discover functional dependencies
+    fds = find_functional_dependencies(df, max_lhs_size)
+
+    # Prepare FD results
+    fd_results = [(", ".join(lhs), rhs) for lhs, rhs in fds]
+
+    # Profile keys (by uniqueness)
+    all_keys = []
+    for size in range(1, max_combination_size + 1):
+        for combo in itertools.combinations(cols, size):
+            unique_count = df.drop_duplicates(subset=combo).shape[0]
+            unique_ratio = unique_count / n_rows
+            is_key = unique_count == n_rows
+            if is_key:
+                all_keys.append(combo)
+    
+    # Distinguish between candidate keys and superkeys
+    candidate_keys = []
+    superkeys = []
+    
+    for key in all_keys:
+        is_candidate = True
+        # Check if any proper subset of this key is also a key
+        for i in range(1, len(key)):
+            for subset in itertools.combinations(key, i):
+                if subset in all_keys:
+                    is_candidate = False
+                    break
+            if not is_candidate:
+                break
+        
+        if is_candidate:
+            candidate_keys.append(key)
+        else:
+            superkeys.append(key)
+    
+    # Prepare results for all keys (both candidate keys and superkeys)
+    results = []
+    for size in range(1, max_combination_size + 1):
+        for combo in itertools.combinations(cols, size):
+            unique_count = df.drop_duplicates(subset=combo).shape[0]
+            unique_ratio = unique_count / n_rows
+            is_key = combo in all_keys
+            is_candidate = combo in candidate_keys
+            is_superkey = combo in superkeys
+            
+            # Use icons for different key types
+            key_type = ""
+            if is_candidate:
+                key_type = "★ Candidate Key"  # Star for candidate keys
+            elif is_superkey:
+                key_type = "⊃ Superkey"       # Superset symbol for superkeys
+            
+            results.append((combo, unique_count, unique_ratio, is_key, key_type))
+    
+    results.sort(key=lambda x: (not x[3], -x[2], len(x[0])))
+    key_results = [(", ".join(c), u, f"{u/n_rows:.2%}", k) 
+                   for c, u, _, _, k in results]
+    
+    # Propose normalized tables
+    normalized_tables = propose_normalized_tables(cols, candidate_keys, fds)
+    
+    return fd_results, key_results, n_rows, cols, max_combination_size, max_lhs_size, normalized_tables
+
+
+def visualize_profile(df: pd.DataFrame, max_combination_size: int = 2, max_lhs_size: int = 2):
+    """
+    Create a visual representation of the key profile for a dataframe.
+    
+    Parameters:
+    - df: pandas.DataFrame to analyze.
+    - max_combination_size: max size of column combos to test for keys.
+    - max_lhs_size: max size of LHS in discovered FDs.
+    
+    Returns:
+    - QMainWindow: The visualization window
+    """
+    # Get profile results
+    fd_results, key_results, n_rows, cols, max_combination_size, max_lhs_size, normalized_tables = profile(
+        df, max_combination_size, max_lhs_size
+    )
+    
+    # Create main window
+    window = QMainWindow()
+    window.setWindowTitle("Table Profile: Keys & Dependencies")
+    window.resize(900, 700)
+    
+    # Create central widget and layout
+    central_widget = QWidget()
+    window.setCentralWidget(central_widget)
+    layout = QVBoxLayout(central_widget)
+    
+    # Add header
+    header = QLabel(f"Analyzed {n_rows} rows × {len(cols)} columns; key combos up to size {max_combination_size}, FDs up to LHS size {max_lhs_size}")
+    header.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    header.setStyleSheet("font-size: 14pt; font-weight: bold; margin: 10px;")
+    layout.addWidget(header)
+    
+    # Add description
+    description = QLabel(
+        "This profile helps identify candidate keys and functional dependencies in your data. "
+        "★ Candidate keys are minimal combinations of columns that uniquely identify rows. "
+        "⊃ Superkeys are non-minimal column sets that uniquely identify rows. "
+        "Functional dependencies indicate when one column's values determine another's."
+    )
+    description.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    description.setWordWrap(True)
+    description.setStyleSheet("margin-bottom: 10px;")
+    layout.addWidget(description)
+    
+    # Add key for icons
+    icons_key = QLabel("Key: ★ = Minimal Candidate Key | ⊃ = Non-minimal Superkey")
+    icons_key.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    icons_key.setStyleSheet("font-style: italic; margin-bottom: 15px;")
+    layout.addWidget(icons_key)
+    
+    # Create tabs
+    tabs = QTabWidget()
+    
+    # Tab for Candidate Keys
+    key_tab = QWidget()
+    key_layout = QVBoxLayout()
+    
+    key_header = QLabel("Keys (Column Combinations that Uniquely Identify Rows)")
+    key_header.setStyleSheet("font-weight: bold;")
+    key_layout.addWidget(key_header)
+    
+    key_table = QTableWidget(len(key_results), 4)
+    key_table.setHorizontalHeaderLabels(["Columns", "Unique Count", "Uniqueness Ratio", "Key Type"])
+    key_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+    for row, (cols_str, count, ratio, key_type) in enumerate(key_results):
+        key_table.setItem(row, 0, QTableWidgetItem(cols_str))
+        key_table.setItem(row, 1, QTableWidgetItem(str(count)))
+        key_table.setItem(row, 2, QTableWidgetItem(ratio))
+        
+        # Create item with appropriate styling
+        type_item = QTableWidgetItem(key_type)
+        if "Candidate Key" in key_type:
+            type_item.setForeground(Qt.GlobalColor.darkGreen)
+        elif "Superkey" in key_type:
+            type_item.setForeground(Qt.GlobalColor.darkBlue)
+        key_table.setItem(row, 3, type_item)
+        
+    key_layout.addWidget(key_table)
+    key_tab.setLayout(key_layout)
+    tabs.addTab(key_tab, "Keys")
+    
+    # Tab for FDs
+    fd_tab = QWidget()
+    fd_layout = QVBoxLayout()
+    
+    fd_header = QLabel("Functional Dependencies (When Values in One Set of Columns Determine Another Column)")
+    fd_header.setStyleSheet("font-weight: bold;")
+    fd_layout.addWidget(fd_header)
+    
+    fd_table = QTableWidget(len(fd_results), 2)
+    fd_table.setHorizontalHeaderLabels(["Determinant (LHS)", "Dependent (RHS)"])
+    fd_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+    for i, (lhs, rhs) in enumerate(fd_results):
+        lhs_item = QTableWidgetItem(lhs)
+        lhs_item.setFlags(lhs_item.flags() ^ Qt.ItemFlag.ItemIsEditable)
+        fd_table.setItem(i, 0, lhs_item)
+        fd_table.setItem(i, 1, QTableWidgetItem(rhs))
+    fd_layout.addWidget(fd_table)
+    fd_tab.setLayout(fd_layout)
+    tabs.addTab(fd_tab, "Functional Dependencies")
+    
+    # Tab for Normalized Tables
+    norm_tab = QWidget()
+    norm_layout = QVBoxLayout()
+    
+    norm_header = QLabel("Proposed Normalized Tables (Based on Functional Dependencies)")
+    norm_header.setStyleSheet("font-weight: bold;")
+    norm_layout.addWidget(norm_header)
+    
+    norm_description = QLabel(
+        "These tables represent a proposed normalized schema based on the discovered functional dependencies. "
+        "Each table includes attributes that are functionally dependent on its primary key. "
+        "This is an approximate 3NF decomposition and may need further refinement."
+    )
+    norm_description.setWordWrap(True)
+    norm_description.setStyleSheet("margin-bottom: 10px;")
+    norm_layout.addWidget(norm_description)
+    
+    norm_table = QTableWidget(len(normalized_tables), 3)
+    norm_table.setHorizontalHeaderLabels(["Table Name", "Primary Key", "Attributes"])
+    norm_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+    for i, (table_name, primary_key, attributes) in enumerate(normalized_tables):
+        norm_table.setItem(i, 0, QTableWidgetItem(table_name))
+        
+        pk_item = QTableWidgetItem(primary_key)
+        pk_item.setForeground(Qt.GlobalColor.darkGreen)
+        norm_table.setItem(i, 1, pk_item)
+        
+        norm_table.setItem(i, 2, QTableWidgetItem(", ".join(attributes)))
+    
+    norm_layout.addWidget(norm_table)
+    norm_tab.setLayout(norm_layout)
+    tabs.addTab(norm_tab, "Normalized Tables")
+    
+    layout.addWidget(tabs)
+    
+    # Show the window
+    window.show()
+    return window
+
+
+def test_profile_keys(test_size=100):
+    # Generate a dataframe with some realistic examples of a customer-product-order relationship
+    # Create customer data
+    customer_ids = list(range(1, 21))  # 20 customers
+    customer_names = ["John", "Jane", "Alice", "Bob", "Charlie", "Diana", "Edward", "Fiona", "George", "Hannah"]
+    
+    # Create product data
+    product_names = ["Apple", "Banana", "Orange", "Grape", "Mango", "Strawberry", "Blueberry", "Kiwi", "Pineapple", "Watermelon"]
+    product_groups = ["Fruit"] * len(product_names)
+    
+    # Generate random orders
+    random.seed(42)  # For reproducibility
+    df_data = {
+        "customer_id": [random.choice(customer_ids) for _ in range(test_size)],
+        "customer_name": [customer_names[i % len(customer_names)] for i in range(test_size)],
+        "product_name": [random.choice(product_names) for _ in range(test_size)],
+        "product_group": ["Fruit" for _ in range(test_size)],
+        "order_date": [pd.Timestamp("2021-01-01") + pd.Timedelta(days=random.randint(0, 30)) for _ in range(test_size)],
+        "order_amount": [random.randint(100, 1000) for _ in range(test_size)]
+    }
+    
+    # Ensure consistent relationships
+    for i in range(test_size):
+        # Ensure customer_name is consistently associated with customer_id
+        customer_idx = df_data["customer_id"][i] % len(customer_names)
+        df_data["customer_name"][i] = customer_names[customer_idx]
+    
+    df = pd.DataFrame(df_data)
+    
+    # Create and show visualization
+    app = QApplication(sys.argv)
+    window = visualize_profile(df, max_combination_size=3, max_lhs_size=2)
+    sys.exit(app.exec())
+
+# Only run the test function when script is executed directly
+if __name__ == "__main__":
+    test_profile_keys()

sqlshell-0.2.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: sqlshell
+Version: 0.2.0
+Summary: A powerful SQL shell with GUI interface for data analysis
+Author: SQLShell Team
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/oyvinrog/SQLShell
+Keywords: sql,data analysis,gui,duckdb
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: PyQt6>=6.4.0
+Requires-Dist: duckdb>=0.9.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: pyarrow>=14.0.1
+Requires-Dist: fastparquet>=2023.10.1
+Requires-Dist: xlrd>=2.0.1
+Requires-Dist: deltalake
+Requires-Dist: Pillow>=10.0.0
+
+# SQLShell
+
+<div align="center">
+
+<img src="sqlshell_logo.png" alt="SQLShell Logo" width="180" height="auto">
+
+**A powerful SQL shell with GUI interface for data analysis**
+
+<img src="sqlshell_demo.png" alt="SQLShell Interface" width="80%" height="auto">
+
+</div>
+
+## 🚀 Key Features
+
+- **Interactive SQL Interface** - Rich syntax highlighting for enhanced query writing
+- **Context-Aware Suggestions** - Intelligent SQL autocompletion based on query context and schema
+- **DuckDB Integration** - Powerful analytical queries powered by DuckDB
+- **Multi-Format Support** - Import and query Excel (.xlsx, .xls), CSV, and Parquet files effortlessly
+- **Modern UI** - Clean, tabular results display with intuitive controls
+- **Table Preview** - Quick view of imported data tables
+- **Test Data Generation** - Built-in sample data for testing and learning
+- **Multiple Views** - Support for multiple concurrent table views
+- **Productivity Tools** - Streamlined workflow with keyboard shortcuts (e.g., Ctrl+Enter for query execution)
+
+## 📦 Installation
+
+### Using pip (Recommended)
+
+```bash
+pip install sqlshell
+```
+
+### Linux Setup with Virtual Environment
+
+```bash
+# Create and activate virtual environment
+python3 -m venv ~/.venv/sqlshell
+source ~/.venv/sqlshell/bin/activate
+
+# Install SQLShell
+pip install sqlshell
+
+# Configure shell alias
+echo 'alias sqls="~/.venv/sqlshell/bin/sqls"' >> ~/.bashrc  # or ~/.zshrc for Zsh
+source ~/.bashrc  # or source ~/.zshrc
+```
+
+### Development Installation
+
+```bash
+git clone https://github.com/oyvinrog/SQLShell.git
+cd SQLShell
+pip install -e .
+```
+
+## 🎯 Getting Started
+
+1. **Launch the Application**
+   ```bash
+   sqls
+   ```
+   
+   If the `sqls` command doesn't work (e.g., "access denied" on Windows), you can use this alternative:
+   ```bash
+   python -c "import sqlshell; sqlshell.start()"
+   ```
+
+2. **Database Connection**
+   - SQLShell automatically connects to a local DuckDB database named 'pool.db'
+
+3. **Working with Data Files**
+   - Click "Load Files" to select your Excel, CSV, or Parquet files
+   - File contents are loaded as queryable SQL tables
+   - Query using standard SQL syntax
+
+4. **Query Execution**
+   - Enter SQL in the editor
+   - Execute using Ctrl+Enter or the "Execute" button
+   - View results in the structured output panel
+
+5. **Test Data**
+   - Load sample test data using the "Test" button for quick experimentation
+   
+6. **Using Context-Aware Suggestions**
+   - Press Ctrl+Space to manually trigger suggestions
+   - Suggestions appear automatically as you type
+   - Context-specific suggestions based on your query position:
+     - After SELECT: columns and functions
+     - After FROM/JOIN: tables with join conditions
+     - After WHERE: columns with appropriate operators
+     - Inside functions: relevant column suggestions
+
+## 📝 Query Examples
+
+### Basic Join Operation
+```sql
+SELECT *
+FROM sample_sales_data cd
+INNER JOIN product_catalog pc ON pc.productid = cd.productid
+LIMIT 3;
+```
+
+### Multi-Statement Queries
+```sql
+-- Create a temporary view
+CREATE OR REPLACE TEMPORARY VIEW test_v AS
+SELECT *
+FROM sample_sales_data cd
+INNER JOIN product_catalog pc ON pc.productid = cd.productid;
+
+-- Query the view
+SELECT DISTINCT productid
+FROM test_v;
+```
+
+## 💡 Pro Tips
+
+- Use temporary views for complex query organization
+- Leverage keyboard shortcuts for efficient workflow
+- Explore the multi-format support for various data sources
+- Create multiple tabs for parallel query development
+- The context-aware suggestions learn from your query patterns
+- Type `table_name.` to see all columns for a specific table
+- After JOIN keyword, the system suggests relevant tables and join conditions
+
+## 📊 Column Profiler
+
+The Column Profiler provides quick statistical insights into your table columns:
+
+<img src="column_profiler.png" alt="Column Profiler" width="80%" height="auto">
+
+### Using the Column Profiler
+
+1. **Access the Profiler**
+   - Right-click on any table in the schema browser
+   - Select "Profile Table" from the context menu
+
+2. **View Column Statistics**
+   - Instantly see key metrics for each column:
+     - Data type
+     - Non-null count and percentage
+     - Unique values count
+     - Mean, median, min, and max values (for numeric columns)
+     - Most frequent values and their counts
+     - Distribution visualization
+
+3. **Benefits**
+   - Quickly understand data distribution
+   - Identify outliers and data quality issues
+   - Make informed decisions about query conditions
+   - Assess column cardinality for join operations
+
+The Column Profiler is an invaluable tool for exploratory data analysis, helping you gain insights before writing complex queries.
+
+## 📋 Requirements
+
+- Python 3.8 or higher
+- Dependencies (automatically installed):
+  - PyQt6 ≥ 6.4.0
+  - DuckDB ≥ 0.9.0
+  - Pandas ≥ 2.0.0
+  - NumPy ≥ 1.24.0
+  - openpyxl ≥ 3.1.0 (Excel support)
+  - pyarrow ≥ 14.0.1 (Parquet support)
+  - fastparquet ≥ 2023.10.1 (Alternative parquet engine)
+  - xlrd ≥ 2.0.1 (Support for older .xls files)
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

{sqlshell-0.1.9.dist-info → sqlshell-0.2.0.dist-info}/RECORD

@@ -1,15 +1,22 @@
+sqlshell/LICENSE,sha256=YFVzvqHDVzBVtEZoKwcHhashVdNy4P7tDEQ561jAdyo,1070
+sqlshell/MANIFEST.in,sha256=UautKSW4Kzjsy1Ti05-P58qRgM4ct4mmG3aserBGaX0,144
+sqlshell/README.md,sha256=UoWQzdsYThrOoajT40iOtpI73g5ANB7w12vll0eH0Ck,1357
 sqlshell/__init__.py,sha256=GAZ3g4YsExb-aFyN0a77whBxRRk4XMGJYakvpeKbxdg,164
-sqlshell/create_test_data.py,sha256=AzrEsKlZsR1H1Xlp7IKOzWQ2N6FsVISJbc6CerI8IJ0,1954
-sqlshell/editor.py,sha256=LSUu1woAXXRNx-iquYY0_tjybOdaor-wSZfoHTEz5jk,36768
-sqlshell/main.py,sha256=n6d5lYE0bfeWHB-9pbMpAm3GPz0t225EMqW1CYAqLp0,103613
-sqlshell/query_tab.py,sha256=cvuaqPdwdhPo1O5jRTyyxYoCOJx0RpFClwBb7pv-Ivw,7095
-sqlshell/setup.py,sha256=kaBlE81C38Sp7M76BinoBqbZ_XgbXc1fFFAvU6kZxVQ,1263
+sqlshell/context_suggester.py,sha256=OdfSBqwKWtf6yGj-_cNjf9RZG9cc70TWZ_7ieAVKJqk,33970
+sqlshell/create_test_data.py,sha256=uJSFyqm8zYWpyERPd29iMu-EbtvKiwK5WV0N-LibNOc,5385
+sqlshell/editor.py,sha256=iWSYUtsNCud7HWZrcqD9Ef7FEa0nt7ekeUHV6CmCgao,39635
+sqlshell/main.py,sha256=vt7s6dXmY6iw-Y3jr2YtPNMwwvdqPu1zqNRNidtIRN0,150575
+sqlshell/menus.py,sha256=hiT1CXXnsRKkai7oJlPi94du_GKtIhl5X5LOGvqcOqs,5684
+sqlshell/query_tab.py,sha256=9Yu_7MRikZXrQ003N2HOvjFEBdiz_J9ZLWgTzXPiumc,8404
 sqlshell/splash_screen.py,sha256=K0Ku_nXJWmWSnVEh2OttIthRZcnUoY_tmjIAWIWLm7Y,17604
 sqlshell/sqlshell_demo.png,sha256=dPp9J1FVqQVfrh-gekosuha2Jw2p2--wxbOmt2kr7fg,133550
+sqlshell/styles.py,sha256=EGA_Ow-XerPEQgj82ts3fnqkEPMcjSlJPblbPu9L__s,7135
+sqlshell/suggester_integration.py,sha256=w3fKuSq5ex5OHxSBzZunyq3mbGvX06-7nxgLClnK5Kw,13232
 sqlshell/syntax_highlighter.py,sha256=mPwsD8N4XzAUx0IgwlelyfjUhe0xmH0Ug3UI9hTcHz0,5861
+sqlshell/table_list.py,sha256=ET9UGxhRL2j42GC6WqocotvQIOUzRskH9BnmciVX_As,37670
 sqlshell/data/create_test_data.py,sha256=sUTcf50V8-bVwYV2VNTLK65c-iHiU4wb99By67I10zM,5404
 sqlshell/db/__init__.py,sha256=AJGRkywFCnJliwfOBvtE_ISXjdESkRea7lBFM5KjuTU,152
-sqlshell/db/database_manager.py,sha256=a3Uq8Lqxamvk4mikaZ3MNCY5Ft_Vv8v33cdToNzBLNk,29548
+sqlshell/db/database_manager.py,sha256=DRPoRYgY9DthD1YvLuMeo-aRfaAAcdAKZKXMPDmAcsg,35722
 sqlshell/resources/__init__.py,sha256=VLTJ_5pUHhctRiV8UZDvG-jnsjgT6JQvW-ZPzIJqBIY,44
 sqlshell/resources/create_icon.py,sha256=O7idVEKwmSXxLUsbeRn6zcYVQLPSdJi98nGamTgXiM4,4905
 sqlshell/resources/create_splash.py,sha256=t1KK43Y0pHKGcdRkbnZgV6_y1c1C0THHQl5_fmpC2gQ,3347
@@ -24,8 +31,11 @@ sqlshell/sqlshell/create_test_databases.py,sha256=oqryFJJahqLFsAjBFM4r9Fe1ea7djD
 sqlshell/ui/__init__.py,sha256=2CsTDAvRZJ99gkjs3-rdwkxyGVAKXX6ueOhPdP1VXQc,206
 sqlshell/ui/bar_chart_delegate.py,sha256=tbtIt2ZqPIcYWNJzpONpYa0CYURkLdjkg23TI7TmOKY,1881
 sqlshell/ui/filter_header.py,sha256=c4Mg1J1yTUfrnT9C-xDWHhcauRsgU3WNfvVInv1J814,16074
-sqlshell-0.1.9.dist-info/METADATA,sha256=xiGeZnTbFrzPbG0wtCLgxQvqFZlya9gaxRs4yc9qDhg,3518
-sqlshell-0.1.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-sqlshell-0.1.9.dist-info/entry_points.txt,sha256=Kd0fOvyOW7UiTgTVY7abVOmDIH2Y2nawGTp5kVadac4,44
-sqlshell-0.1.9.dist-info/top_level.txt,sha256=ahwsMFhvAqI97ZkT2xvHL5iZCO1p13mNiUOFkdSFwms,9
-sqlshell-0.1.9.dist-info/RECORD,,
+sqlshell/utils/__init__.py,sha256=iPKvOsKcfnV7xvhQVOz8BiQ4kbFZ7PGUW8vg0vyMqvk,225
+sqlshell/utils/profile_entropy.py,sha256=pJTcXlBkSEPzL3Fvxizf5gBkw6IsUjfa9Y6MjAqF1do,13238
+sqlshell/utils/profile_keys.py,sha256=ajdBTqvZVmAlVaY-kDmv_D8D3sKASG75PLTzf8Y8nX4,14170
+sqlshell-0.2.0.dist-info/METADATA,sha256=EihrTD_KfJTWcYr24WnHEpMBfbYNK6NRJHVhCeU8vQQ,6101
+sqlshell-0.2.0.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+sqlshell-0.2.0.dist-info/entry_points.txt,sha256=Kd0fOvyOW7UiTgTVY7abVOmDIH2Y2nawGTp5kVadac4,44
+sqlshell-0.2.0.dist-info/top_level.txt,sha256=ahwsMFhvAqI97ZkT2xvHL5iZCO1p13mNiUOFkdSFwms,9
+sqlshell-0.2.0.dist-info/RECORD,,

{sqlshell-0.1.9.dist-info → sqlshell-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sqlshell/setup.py

@@ -1,42 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="sqlshell",
-    version="0.1.1",
-    packages=find_packages(),
-    install_requires=[
-        'pandas>=2.0.0',
-        'numpy>=1.24.0',
-        'PyQt6>=6.4.0',
-        'duckdb>=0.9.0',
-        'openpyxl>=3.1.0',
-        'pyarrow>=14.0.1',
-        'fastparquet>=2023.10.1',
-        'xlrd>=2.0.1'
-    ],
-    entry_points={
-        'console_scripts': [
-            'sqls=sqlshell.main:main',
-        ],
-    },
-    author="SQLShell Team",
-    description="A powerful SQL shell with GUI interface for data analysis",
-    long_description=open('README.md', encoding='utf-8').read(),
-    long_description_content_type="text/markdown",
-    keywords="sql, data analysis, gui, duckdb",
-    url="https://github.com/yourusername/sqlshell",
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Intended Audience :: Developers",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-    ],
-    python_requires=">=3.8",
-    include_package_data=True,
-    package_data={
-        'sqlshell': ['*.db'],
-    },
-)