sqlshell 0.1.0__tar.gz → 0.1.2__tar.gz

sqlshell-0.1.2/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.2
+Name: sqlshell
+Version: 0.1.2
+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/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
+Dynamic: home-page
+Dynamic: requires-python
+
+# SQL Shell
+
+A GUI application that provides a SQL REPL interface for querying DuckDB databases and Excel files.
+
+
+![SQLShell Interface](sqlshell\sqlshell_demo.png)
+
+## Features
+
+- SQL query interface with syntax highlighting
+- Support for querying local DuckDB database (pool.db)
+- Import and query Excel files (.xlsx, .xls) and CSV files
+- Results displayed in a clear, tabular format
+- Keyboard shortcuts (Ctrl+Enter to execute queries)
+
+## Installation
+
+1. Make sure you have Python 3.8 or newer installed
+2. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+1. Run the application:
+   ```bash
+   python sqls.py
+   ```
+
+2. The application will automatically connect to a local DuckDB database named 'pool.db'
+
+3. To query Excel files:
+   - Click the "Browse Excel" button
+   - Select your Excel file
+   - The file will be loaded as a table named 'imported_data'
+   - Query the data using SQL commands (e.g., `SELECT * FROM imported_data`)
+
+4. Enter SQL queries in the top text area
+   - Press Ctrl+Enter or click "Execute" to run the query
+   - Results will be displayed in the bottom panel
+
+## Example Queries
+
+```sql
+select * from sample_sales_data cd inner join product_catalog pc on pc.productid = cd.productid limit 3
+```
+
+you can also do multiple statements, i.e:
+
+```sql
+create or replace temporary view test_v as 
+select * from sample_sales_data cd
+inner join product_catalog pc on pc.productid = cd.productid;
+
+select distinct productid from test_v ;
+```

sqlshell-0.1.2/README.md

@@ -0,0 +1,57 @@
+# SQL Shell
+
+A GUI application that provides a SQL REPL interface for querying DuckDB databases and Excel files.
+
+
+![SQLShell Interface](sqlshell\sqlshell_demo.png)
+
+## Features
+
+- SQL query interface with syntax highlighting
+- Support for querying local DuckDB database (pool.db)
+- Import and query Excel files (.xlsx, .xls) and CSV files
+- Results displayed in a clear, tabular format
+- Keyboard shortcuts (Ctrl+Enter to execute queries)
+
+## Installation
+
+1. Make sure you have Python 3.8 or newer installed
+2. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+1. Run the application:
+   ```bash
+   python sqls.py
+   ```
+
+2. The application will automatically connect to a local DuckDB database named 'pool.db'
+
+3. To query Excel files:
+   - Click the "Browse Excel" button
+   - Select your Excel file
+   - The file will be loaded as a table named 'imported_data'
+   - Query the data using SQL commands (e.g., `SELECT * FROM imported_data`)
+
+4. Enter SQL queries in the top text area
+   - Press Ctrl+Enter or click "Execute" to run the query
+   - Results will be displayed in the bottom panel
+
+## Example Queries
+
+```sql
+select * from sample_sales_data cd inner join product_catalog pc on pc.productid = cd.productid limit 3
+```
+
+you can also do multiple statements, i.e:
+
+```sql
+create or replace temporary view test_v as 
+select * from sample_sales_data cd
+inner join product_catalog pc on pc.productid = cd.productid;
+
+select distinct productid from test_v ;
+```

{sqlshell-0.1.0 → sqlshell-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlshell"
-version = "0.1.0"
+version = "0.1.2"
 description = "A powerful SQL shell with GUI interface for data analysis"
 readme = "README.md"
 authors = [
@@ -34,7 +34,7 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/yourusername/sqlshell"
+Homepage = "https://github.com/oyvinrog/SQLShell"
 
 [project.scripts]
 sqls = "sqlshell.main:main" 

sqlshell-0.1.2/setup.py

@@ -0,0 +1,50 @@
+from setuptools import setup, find_packages
+import os
+
+# Read version from __init__.py
+with open(os.path.join('sqlshell', '__init__.py'), 'r') as f:
+    for line in f:
+        if line.startswith('__version__'):
+            version = line.split('=')[1].strip().strip('"\'')
+            break
+
+setup(
+    name="sqlshell",
+    version=version,
+    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').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'],
+    },
+) 

sqlshell-0.1.2/sqlshell/__init__.py

@@ -0,0 +1,6 @@
+"""
+SQLShell - A powerful SQL shell with GUI interface for data analysis
+"""
+
+__version__ = "0.1.1"
+__author__ = "SQLShell Team" 

sqlshell-0.1.2/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
+import create_test_data  # Import the test data generation module
+
+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 → sqlshell-0.1.2/sqlshell}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="sqlshell",
-    version="0.1.0",
+    version="0.1.1",
     packages=find_packages(),
     install_requires=[
         'pandas>=2.0.0',

{sqlshell-0.1.0 → sqlshell-0.1.2/sqlshell}/sqlshell/__init__.py

@@ -2,4 +2,4 @@
 SQLShell - A powerful SQL shell with GUI interface for data analysis
 """
 
-__version__ = "0.1.0" 
+__version__ = "0.1.1" 

sqlshell-0.1.2/sqlshell.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.2
+Name: sqlshell
+Version: 0.1.2
+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/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
+Dynamic: home-page
+Dynamic: requires-python
+
+# SQL Shell
+
+A GUI application that provides a SQL REPL interface for querying DuckDB databases and Excel files.
+
+
+![SQLShell Interface](sqlshell\sqlshell_demo.png)
+
+## Features
+
+- SQL query interface with syntax highlighting
+- Support for querying local DuckDB database (pool.db)
+- Import and query Excel files (.xlsx, .xls) and CSV files
+- Results displayed in a clear, tabular format
+- Keyboard shortcuts (Ctrl+Enter to execute queries)
+
+## Installation
+
+1. Make sure you have Python 3.8 or newer installed
+2. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Usage
+
+1. Run the application:
+   ```bash
+   python sqls.py
+   ```
+
+2. The application will automatically connect to a local DuckDB database named 'pool.db'
+
+3. To query Excel files:
+   - Click the "Browse Excel" button
+   - Select your Excel file
+   - The file will be loaded as a table named 'imported_data'
+   - Query the data using SQL commands (e.g., `SELECT * FROM imported_data`)
+
+4. Enter SQL queries in the top text area
+   - Press Ctrl+Enter or click "Execute" to run the query
+   - Results will be displayed in the bottom panel
+
+## Example Queries
+
+```sql
+select * from sample_sales_data cd inner join product_catalog pc on pc.productid = cd.productid limit 3
+```
+
+you can also do multiple statements, i.e:
+
+```sql
+create or replace temporary view test_v as 
+select * from sample_sales_data cd
+inner join product_catalog pc on pc.productid = cd.productid;
+
+select distinct productid from test_v ;
+```

{sqlshell-0.1.0 → sqlshell-0.1.2}/sqlshell.egg-info/SOURCES.txt

@@ -1,14 +1,15 @@
-LICENSE
-MANIFEST.in
 README.md
 pyproject.toml
 setup.py
 sqlshell/__init__.py
-sqlshell/create_test_data.py
 sqlshell/main.py
+sqlshell/setup.py
 sqlshell.egg-info/PKG-INFO
 sqlshell.egg-info/SOURCES.txt
 sqlshell.egg-info/dependency_links.txt
 sqlshell.egg-info/entry_points.txt
 sqlshell.egg-info/requires.txt
-sqlshell.egg-info/top_level.txt
+sqlshell.egg-info/top_level.txt
+sqlshell/sqlshell/__init__.py
+sqlshell/sqlshell/create_test_data.py
+sqlshell/sqlshell/main.py

sqlshell-0.1.0/LICENSE

@@ -1,21 +0,0 @@
-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/MANIFEST.in

@@ -1,5 +0,0 @@
-include README.md
-include LICENSE
-recursive-include sqlshell *.py
-recursive-include sqlshell *.db
-recursive-include sqlshell/test_data * 

sqlshell-0.1.0/PKG-INFO

@@ -1,85 +0,0 @@
-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/README.md

@@ -1,55 +0,0 @@
-# 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/sqlshell.egg-info/PKG-INFO

@@ -1,85 +0,0 @@
-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.