sqlshell 0.1.0__py3-none-any.whl

sqlshell/__init__.py

@@ -0,0 +1,5 @@
+"""
+SQLShell - A powerful SQL shell with GUI interface for data analysis
+"""
+
+__version__ = "0.1.0" 

sqlshell/create_test_data.py

@@ -0,0 +1,137 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import os
+
+# Set random seed for reproducibility
+np.random.seed(42)
+
+# Define output directory
+OUTPUT_DIR = 'test_data'
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def create_sales_data(num_records=1000):
+    # Generate dates for the last 365 days
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = [start_date + timedelta(days=x) for x in range(366)]
+    random_dates = np.random.choice(dates, num_records)
+
+    # Create product data
+    products = ['Laptop', 'Smartphone', 'Tablet', 'Monitor', 'Keyboard', 'Mouse', 'Headphones', 'Printer']
+    product_prices = {
+        'Laptop': (800, 2000),
+        'Smartphone': (400, 1200),
+        'Tablet': (200, 800),
+        'Monitor': (150, 500),
+        'Keyboard': (20, 150),
+        'Mouse': (10, 80),
+        'Headphones': (30, 300),
+        'Printer': (100, 400)
+    }
+
+    # Generate random data
+    data = {
+        'OrderID': range(1, num_records + 1),
+        'Date': random_dates,
+        'ProductID': np.random.randint(1, len(products) + 1, num_records),  # Changed to ProductID for joining
+        'Quantity': np.random.randint(1, 11, num_records),
+        'CustomerID': np.random.randint(1, 201, num_records),
+        'Region': np.random.choice(['North', 'South', 'East', 'West'], num_records)
+    }
+
+    # Calculate prices based on product
+    product_list = [products[pid-1] for pid in data['ProductID']]
+    data['Price'] = [np.random.uniform(product_prices[p][0], product_prices[p][1]) 
+                     for p in product_list]
+    data['TotalAmount'] = [price * qty for price, qty in zip(data['Price'], data['Quantity'])]
+
+    # Create DataFrame
+    df = pd.DataFrame(data)
+
+    # Round numerical columns
+    df['Price'] = df['Price'].round(2)
+    df['TotalAmount'] = df['TotalAmount'].round(2)
+
+    # Sort by Date
+    return df.sort_values('Date')
+
+def create_customer_data(num_customers=200):
+    # Generate customer data
+    data = {
+        'CustomerID': range(1, num_customers + 1),
+        'FirstName': [f'Customer{i}' for i in range(1, num_customers + 1)],
+        'LastName': [f'Lastname{i}' for i in range(1, num_customers + 1)],
+        'Email': [f'customer{i}@example.com' for i in range(1, num_customers + 1)],
+        'JoinDate': [datetime.now() - timedelta(days=np.random.randint(1, 1000)) 
+                     for _ in range(num_customers)],
+        'CustomerType': np.random.choice(['Regular', 'Premium', 'VIP'], num_customers),
+        'CreditScore': np.random.randint(300, 851, num_customers)
+    }
+    
+    return pd.DataFrame(data)
+
+def create_product_data():
+    # Create detailed product information
+    products = {
+        'ProductID': range(1, 9),
+        'ProductName': ['Laptop', 'Smartphone', 'Tablet', 'Monitor', 'Keyboard', 'Mouse', 'Headphones', 'Printer'],
+        'Category': ['Computers', 'Mobile', 'Mobile', 'Accessories', 'Accessories', 'Accessories', 'Audio', 'Peripherals'],
+        'Brand': ['TechPro', 'MobileX', 'TabletCo', 'ViewMax', 'TypeMaster', 'ClickPro', 'SoundMax', 'PrintPro'],
+        'StockQuantity': np.random.randint(50, 500, 8),
+        'MinPrice': [800, 400, 200, 150, 20, 10, 30, 100],
+        'MaxPrice': [2000, 1200, 800, 500, 150, 80, 300, 400],
+        'Weight_kg': [2.5, 0.2, 0.5, 3.0, 0.8, 0.1, 0.3, 5.0],
+        'WarrantyMonths': [24, 12, 12, 36, 12, 12, 24, 12]
+    }
+    
+    return pd.DataFrame(products)
+
+if __name__ == '__main__':
+    # Create and save sales data
+    sales_df = create_sales_data()
+    sales_output = os.path.join(OUTPUT_DIR, 'sample_sales_data.xlsx')
+    sales_df.to_excel(sales_output, index=False)
+    print(f"Created sales data in '{sales_output}'")
+    print(f"Number of sales records: {len(sales_df)}")
+    
+    # Create and save customer data as parquet
+    customer_df = create_customer_data()
+    customer_output = os.path.join(OUTPUT_DIR, 'customer_data.parquet')
+    customer_df.to_parquet(customer_output, index=False)
+    print(f"\nCreated customer data in '{customer_output}'")
+    print(f"Number of customers: {len(customer_df)}")
+    
+    # Create and save product data
+    product_df = create_product_data()
+    product_output = os.path.join(OUTPUT_DIR, 'product_catalog.xlsx')
+    product_df.to_excel(product_output, index=False)
+    print(f"\nCreated product catalog in '{product_output}'")
+    print(f"Number of products: {len(product_df)}")
+    
+    # Print sample queries
+    print("\nSample SQL queries for joining the data:")
+    print("""
+    -- Join sales with customer data
+    SELECT s.*, c.FirstName, c.LastName, c.CustomerType
+    FROM test_data.sample_sales_data s
+    JOIN test_data.customer_data c ON s.CustomerID = c.CustomerID;
+    
+    -- Join sales with product data
+    SELECT s.*, p.ProductName, p.Category, p.Brand
+    FROM test_data.sample_sales_data s
+    JOIN test_data.product_catalog p ON s.ProductID = p.ProductID;
+    
+    -- Three-way join with aggregation
+    SELECT 
+        p.Category,
+        c.CustomerType,
+        COUNT(*) as NumOrders,
+        SUM(s.TotalAmount) as TotalRevenue,
+        AVG(s.Quantity) as AvgQuantity
+    FROM test_data.sample_sales_data s
+    JOIN test_data.customer_data c ON s.CustomerID = c.CustomerID
+    JOIN test_data.product_catalog p ON s.ProductID = p.ProductID
+    GROUP BY p.Category, c.CustomerType
+    ORDER BY p.Category, c.CustomerType;
+    """) 

sqlshell/main.py

@@ -0,0 +1,346 @@
+import sys
+import os
+import duckdb
+import pandas as pd
+from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
+                           QHBoxLayout, QTextEdit, QPushButton, QFileDialog,
+                           QLabel, QSplitter, QListWidget, QTableWidget,
+                           QTableWidgetItem, QHeaderView)
+from PyQt6.QtCore import Qt, QAbstractTableModel
+from PyQt6.QtGui import QFont, QColor
+import numpy as np
+from datetime import datetime
+from . import create_test_data  # Import from the same package
+
+class SQLShell(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.conn = duckdb.connect('pool.db')
+        self.loaded_tables = {}  # Keep track of loaded tables
+        self.init_ui()
+
+    def init_ui(self):
+        self.setWindowTitle('SQL Shell')
+        self.setGeometry(100, 100, 1400, 800)
+
+        # Create central widget and layout
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        main_layout = QHBoxLayout(central_widget)
+
+        # Left panel for table list
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        
+        tables_label = QLabel("Loaded Tables:")
+        left_layout.addWidget(tables_label)
+        
+        self.tables_list = QListWidget()
+        self.tables_list.itemClicked.connect(self.show_table_preview)
+        left_layout.addWidget(self.tables_list)
+        
+        # Buttons for table management
+        table_buttons_layout = QHBoxLayout()
+        self.browse_btn = QPushButton('Load Files')
+        self.browse_btn.clicked.connect(self.browse_files)
+        self.remove_table_btn = QPushButton('Remove Selected')
+        self.remove_table_btn.clicked.connect(self.remove_selected_table)
+        self.test_btn = QPushButton('Test')
+        self.test_btn.clicked.connect(self.load_test_data)
+        
+        table_buttons_layout.addWidget(self.browse_btn)
+        table_buttons_layout.addWidget(self.remove_table_btn)
+        table_buttons_layout.addWidget(self.test_btn)
+        left_layout.addLayout(table_buttons_layout)
+
+        # Right panel for query and results
+        right_panel = QWidget()
+        right_layout = QVBoxLayout(right_panel)
+        
+        # Create splitter for query and results
+        splitter = QSplitter(Qt.Orientation.Vertical)
+        
+        # Top part - Query section
+        query_widget = QWidget()
+        query_layout = QVBoxLayout(query_widget)
+        
+        # Button row
+        button_layout = QHBoxLayout()
+        self.execute_btn = QPushButton('Execute (Ctrl+Enter)')
+        self.execute_btn.clicked.connect(self.execute_query)
+        self.clear_btn = QPushButton('Clear')
+        self.clear_btn.clicked.connect(self.clear_query)
+        
+        button_layout.addWidget(self.execute_btn)
+        button_layout.addWidget(self.clear_btn)
+        button_layout.addStretch()
+        
+        query_layout.addLayout(button_layout)
+
+        # Query input
+        self.query_edit = QTextEdit()
+        self.query_edit.setPlaceholderText("Enter your SQL query here...")
+        query_layout.addWidget(self.query_edit)
+
+        # Bottom part - Results section
+        results_widget = QWidget()
+        results_layout = QVBoxLayout(results_widget)
+        
+        # Results header with row count
+        results_header = QWidget()
+        results_header_layout = QHBoxLayout(results_header)
+        self.results_label = QLabel("Results:")
+        self.row_count_label = QLabel("")
+        results_header_layout.addWidget(self.results_label)
+        results_header_layout.addWidget(self.row_count_label)
+        results_header_layout.addStretch()
+        results_layout.addWidget(results_header)
+        
+        # Table widget for results
+        self.results_table = QTableWidget()
+        self.results_table.setSortingEnabled(True)
+        self.results_table.setAlternatingRowColors(True)
+        self.results_table.horizontalHeader().setStretchLastSection(True)
+        self.results_table.horizontalHeader().setSectionsMovable(True)
+        self.results_table.verticalHeader().setVisible(False)
+        results_layout.addWidget(self.results_table)
+
+        # Add widgets to splitter
+        splitter.addWidget(query_widget)
+        splitter.addWidget(results_widget)
+        
+        # Set initial sizes for splitter
+        splitter.setSizes([300, 500])
+        
+        right_layout.addWidget(splitter)
+
+        # Add panels to main layout
+        main_layout.addWidget(left_panel, 1)
+        main_layout.addWidget(right_panel, 4)
+
+        # Status bar
+        self.statusBar().showMessage('Ready')
+
+    def format_value(self, value):
+        """Format values for display"""
+        if pd.isna(value):
+            return 'NULL'
+        elif isinstance(value, (int, np.integer)):
+            return f"{value:,}"
+        elif isinstance(value, (float, np.floating)):
+            return f"{value:,.2f}"
+        elif isinstance(value, (datetime, pd.Timestamp)):
+            return value.strftime('%Y-%m-%d %H:%M:%S')
+        return str(value)
+
+    def populate_table(self, df):
+        """Populate the table widget with DataFrame content"""
+        if len(df) == 0:
+            self.results_table.setRowCount(0)
+            self.results_table.setColumnCount(0)
+            self.row_count_label.setText("No results")
+            return
+
+        # Set dimensions
+        self.results_table.setRowCount(len(df))
+        self.results_table.setColumnCount(len(df.columns))
+        
+        # Set headers
+        self.results_table.setHorizontalHeaderLabels(df.columns)
+        
+        # Populate data
+        for i, (_, row) in enumerate(df.iterrows()):
+            for j, value in enumerate(row):
+                formatted_value = self.format_value(value)
+                item = QTableWidgetItem(formatted_value)
+                
+                # Set alignment based on data type
+                if isinstance(value, (int, float, np.integer, np.floating)):
+                    item.setTextAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+                else:
+                    item.setTextAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+                
+                # Make cells read-only
+                item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable)
+                
+                self.results_table.setItem(i, j, item)
+        
+        # Auto-adjust column widths while ensuring minimum and maximum sizes
+        self.results_table.resizeColumnsToContents()
+        for i in range(len(df.columns)):
+            width = self.results_table.columnWidth(i)
+            self.results_table.setColumnWidth(i, min(max(width, 50), 300))
+        
+        # Update row count
+        row_text = "row" if len(df) == 1 else "rows"
+        self.row_count_label.setText(f"{len(df):,} {row_text}")
+
+    def browse_files(self):
+        file_names, _ = QFileDialog.getOpenFileNames(
+            self,
+            "Open Data Files",
+            "",
+            "Data Files (*.xlsx *.xls *.csv *.parquet);;Excel Files (*.xlsx *.xls);;CSV Files (*.csv);;Parquet Files (*.parquet);;All Files (*)"
+        )
+        
+        for file_name in file_names:
+            try:
+                if file_name.endswith(('.xlsx', '.xls')):
+                    df = pd.read_excel(file_name)
+                elif file_name.endswith('.csv'):
+                    df = pd.read_csv(file_name)
+                elif file_name.endswith('.parquet'):
+                    df = pd.read_parquet(file_name)
+                else:
+                    raise ValueError("Unsupported file format")
+                
+                # Generate table name from file name
+                base_name = os.path.splitext(os.path.basename(file_name))[0]
+                table_name = self.sanitize_table_name(base_name)
+                
+                # Ensure unique table name
+                original_name = table_name
+                counter = 1
+                while table_name in self.loaded_tables:
+                    table_name = f"{original_name}_{counter}"
+                    counter += 1
+                
+                # Register table in DuckDB
+                self.conn.register(table_name, df)
+                self.loaded_tables[table_name] = file_name
+                
+                # Update UI
+                self.tables_list.addItem(f"{table_name} ({os.path.basename(file_name)})")
+                self.statusBar().showMessage(f'Loaded {file_name} as table "{table_name}"')
+                
+                # Show preview of loaded data
+                preview_df = df.head()
+                self.populate_table(preview_df)
+                self.results_label.setText(f"Preview of {table_name}:")
+                
+            except Exception as e:
+                self.statusBar().showMessage(f'Error loading file: {str(e)}')
+                self.results_table.setRowCount(0)
+                self.results_table.setColumnCount(0)
+                self.row_count_label.setText("")
+                self.results_label.setText(f"Error loading file: {str(e)}")
+
+    def sanitize_table_name(self, name):
+        # Replace invalid characters with underscores
+        import re
+        name = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+        # Ensure it starts with a letter
+        if not name[0].isalpha():
+            name = 'table_' + name
+        return name.lower()
+
+    def remove_selected_table(self):
+        current_item = self.tables_list.currentItem()
+        if current_item:
+            table_name = current_item.text().split(' (')[0]
+            if table_name in self.loaded_tables:
+                # Remove from DuckDB
+                self.conn.execute(f'DROP VIEW IF EXISTS {table_name}')
+                # Remove from our tracking
+                del self.loaded_tables[table_name]
+                # Remove from list widget
+                self.tables_list.takeItem(self.tables_list.row(current_item))
+                self.statusBar().showMessage(f'Removed table "{table_name}"')
+                self.results_table.setRowCount(0)
+                self.results_table.setColumnCount(0)
+                self.row_count_label.setText("")
+                self.results_label.setText(f"Removed table: {table_name}")
+
+    def execute_query(self):
+        query = self.query_edit.toPlainText().strip()
+        if not query:
+            return
+        
+        try:
+            result = self.conn.execute(query).fetchdf()
+            self.populate_table(result)
+            self.results_label.setText("Query Results:")
+            self.statusBar().showMessage('Query executed successfully')
+        except Exception as e:
+            self.results_table.setRowCount(0)
+            self.results_table.setColumnCount(0)
+            self.row_count_label.setText("")
+            self.results_label.setText(f"Error executing query: {str(e)}")
+            self.statusBar().showMessage('Error executing query')
+
+    def clear_query(self):
+        self.query_edit.clear()
+
+    def show_table_preview(self, item):
+        """Show a preview of the selected table"""
+        if item:
+            table_name = item.text().split(' (')[0]
+            try:
+                preview_df = self.conn.execute(f'SELECT * FROM {table_name} LIMIT 5').fetchdf()
+                self.populate_table(preview_df)
+                self.results_label.setText(f"Preview of {table_name}:")
+                self.statusBar().showMessage(f'Showing preview of table "{table_name}"')
+            except Exception as e:
+                self.results_table.setRowCount(0)
+                self.results_table.setColumnCount(0)
+                self.row_count_label.setText("")
+                self.results_label.setText(f"Error showing preview: {str(e)}")
+                self.statusBar().showMessage('Error showing table preview')
+
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key.Key_Return and event.modifiers() == Qt.KeyboardModifier.ControlModifier:
+            self.execute_query()
+        else:
+            super().keyPressEvent(event)
+
+    def load_test_data(self):
+        """Generate and load test data"""
+        try:
+            # Create test data directory if it doesn't exist
+            os.makedirs('test_data', exist_ok=True)
+            
+            # Generate test data
+            sales_df = create_test_data.create_sales_data()
+            customer_df = create_test_data.create_customer_data()
+            product_df = create_test_data.create_product_data()
+            
+            # Save test data
+            sales_df.to_excel('test_data/sample_sales_data.xlsx', index=False)
+            customer_df.to_parquet('test_data/customer_data.parquet', index=False)
+            product_df.to_excel('test_data/product_catalog.xlsx', index=False)
+            
+            # Load the files into DuckDB
+            self.conn.register('sample_sales_data', sales_df)
+            self.conn.register('product_catalog', product_df)
+            self.conn.register('customer_data', customer_df)
+            
+            # Update loaded tables tracking
+            self.loaded_tables['sample_sales_data'] = 'test_data/sample_sales_data.xlsx'
+            self.loaded_tables['product_catalog'] = 'test_data/product_catalog.xlsx'
+            self.loaded_tables['customer_data'] = 'test_data/customer_data.parquet'
+            
+            # Update UI
+            self.tables_list.clear()
+            for table_name, file_path in self.loaded_tables.items():
+                self.tables_list.addItem(f"{table_name} ({os.path.basename(file_path)})")
+            
+            # Set the sample query
+            self.query_edit.setText("select * from sample_sales_data cd inner join product_catalog pc on pc.productid = cd.productid limit 3")
+            
+            self.statusBar().showMessage('Test data loaded successfully')
+            
+        except Exception as e:
+            self.statusBar().showMessage(f'Error loading test data: {str(e)}')
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # Set application style
+    app.setStyle('Fusion')
+    
+    sql_shell = SQLShell()
+    sql_shell.show()
+    sys.exit(app.exec())
+
+if __name__ == '__main__':
+    main() 

sqlshell-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SQLShell Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

sqlshell-0.1.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.2
+Name: sqlshell
+Version: 0.1.0
+Summary: A powerful SQL shell with GUI interface for data analysis
+Home-page: https://github.com/yourusername/sqlshell
+Author: SQLShell Team
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/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
+License-File: LICENSE
+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
+Dynamic: home-page
+Dynamic: requires-python
+
+# SQLShell
+
+A powerful SQL shell with GUI interface for data analysis. SQLShell provides an intuitive interface for working with various data formats (CSV, Excel, Parquet) using SQL queries powered by DuckDB.
+
+## Features
+
+- Load and analyze data from CSV, Excel (.xlsx, .xls), and Parquet files
+- Interactive GUI with syntax highlighting
+- Real-time query results
+- Table preview functionality
+- Built-in test data generation
+- Support for multiple concurrent table views
+
+## Installation
+
+You can install SQLShell using pip:
+
+```bash
+pip install sqlshell
+```
+
+For development installation:
+
+```bash
+git clone https://github.com/yourusername/sqlshell.git
+cd sqlshell
+pip install -e .
+```
+
+## Usage
+
+After installation, you can start SQLShell from anywhere in your terminal by running:
+
+```bash
+sqls
+```
+
+This will open the GUI interface where you can:
+1. Load data files using the "Load Files" button
+2. Write SQL queries in the query editor
+3. Execute queries using the "Execute" button or Ctrl+Enter
+4. View results in the table view below
+5. Load sample test data using the "Test" button
+
+## Requirements
+
+- Python 3.8 or higher
+- PyQt6
+- DuckDB
+- Pandas
+- Other dependencies will be automatically installed
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details. 

sqlshell-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+sqlshell/__init__.py,sha256=SBcXRHWYh9_DIAHkP1cFlru3Qwv6qVZ5u3jiNb32W6E,100
+sqlshell/create_test_data.py,sha256=sUTcf50V8-bVwYV2VNTLK65c-iHiU4wb99By67I10zM,5404
+sqlshell/main.py,sha256=MlkjWh5vlAAAZ8SYE8j0ChJmQFOJ_qqUmW5iH8HiGg8,14184
+sqlshell-0.1.0.dist-info/LICENSE,sha256=YFVzvqHDVzBVtEZoKwcHhashVdNy4P7tDEQ561jAdyo,1070
+sqlshell-0.1.0.dist-info/METADATA,sha256=18zo0VjjP3Bdtsomm4ym5Ir_S5CUYTBMZnySa5aOdpE,2328
+sqlshell-0.1.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+sqlshell-0.1.0.dist-info/entry_points.txt,sha256=Kd0fOvyOW7UiTgTVY7abVOmDIH2Y2nawGTp5kVadac4,44
+sqlshell-0.1.0.dist-info/top_level.txt,sha256=ahwsMFhvAqI97ZkT2xvHL5iZCO1p13mNiUOFkdSFwms,9
+sqlshell-0.1.0.dist-info/RECORD,,

sqlshell-0.1.0.dist-info/WHEEL

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

sqlshell-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sqls = sqlshell.main:main

sqlshell-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlshell