sqlshell 0.1.6__tar.gz → 0.1.8__tar.gz

sqlshell-0.1.8/MANIFEST.in

@@ -0,0 +1,10 @@
+include README.md
+include LICENSE
+include sqlshell_logo.png
+include sqlshell_demo.png
+include pool.db
+recursive-include sqlshell/resources *
+recursive-include sqlshell/data *
+recursive-include test_data *
+global-exclude __pycache__
+global-exclude *.py[cod] 

sqlshell-0.1.8/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: sqlshell
+Version: 0.1.8
+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
+
+# SQLShell
+
+<div align="center">
+
+![SQLShell Interface](sqlshell_logo.png)
+
+**A modern SQL REPL interface for seamless querying of Excel, Parquet, and SQLite databases**
+
+![SQLShell Interface](sqlshell_demo.png)
+
+</div>
+
+## 🚀 Key Features
+
+- **Interactive SQL Interface** - Rich syntax highlighting for enhanced query writing
+- **DuckDB Integration** - Built-in support for local DuckDB database (pool.db)
+- **Multi-Format Support** - Import and query Excel (.xlsx, .xls) and CSV files effortlessly
+- **Modern UI** - Clean, tabular results display with intuitive controls
+- **Productivity Tools** - Streamlined workflow with keyboard shortcuts (e.g., Ctrl+Enter for query execution)
+
+## 📦 Installation
+
+### 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
+```
+
+### Windows Quick Start
+SQLShell is immediately available via the `sqls` command after installation:
+```bash
+pip install sqlshell
+```
+
+## 🎯 Getting Started
+
+1. **Launch the Application**
+   ```bash
+   sqls
+   ```
+
+2. **Database Connection**
+   - SQLShell automatically connects to a local DuckDB database named 'pool.db'
+
+3. **Working with Excel Files**
+   - Click "Browse Excel" to select your file
+   - File contents are loaded as 'imported_data' table
+   - 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
+
+## 📝 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

sqlshell-0.1.8/README.md

@@ -0,0 +1,91 @@
+# SQLShell
+
+<div align="center">
+
+![SQLShell Interface](sqlshell_logo.png)
+
+**A modern SQL REPL interface for seamless querying of Excel, Parquet, and SQLite databases**
+
+![SQLShell Interface](sqlshell_demo.png)
+
+</div>
+
+## 🚀 Key Features
+
+- **Interactive SQL Interface** - Rich syntax highlighting for enhanced query writing
+- **DuckDB Integration** - Built-in support for local DuckDB database (pool.db)
+- **Multi-Format Support** - Import and query Excel (.xlsx, .xls) and CSV files effortlessly
+- **Modern UI** - Clean, tabular results display with intuitive controls
+- **Productivity Tools** - Streamlined workflow with keyboard shortcuts (e.g., Ctrl+Enter for query execution)
+
+## 📦 Installation
+
+### 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
+```
+
+### Windows Quick Start
+SQLShell is immediately available via the `sqls` command after installation:
+```bash
+pip install sqlshell
+```
+
+## 🎯 Getting Started
+
+1. **Launch the Application**
+   ```bash
+   sqls
+   ```
+
+2. **Database Connection**
+   - SQLShell automatically connects to a local DuckDB database named 'pool.db'
+
+3. **Working with Excel Files**
+   - Click "Browse Excel" to select your file
+   - File contents are loaded as 'imported_data' table
+   - 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
+
+## 📝 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

{sqlshell-0.1.6 → sqlshell-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlshell"
-version = "0.1.6"
+version = "0.1.8"
 description = "A powerful SQL shell with GUI interface for data analysis"
 readme = "README.md"
 authors = [

{sqlshell-0.1.6 → sqlshell-0.1.8}/setup.py

@@ -45,6 +45,13 @@ setup(
     python_requires=">=3.8",
     include_package_data=True,
     package_data={
-        'sqlshell': ['*.db'],
+        'sqlshell': [
+            '*.db',
+            'resources/*',
+            'data/*',
+            'test_data/*',
+            '*.png',
+            '*.ico'
+        ],
     },
 ) 

sqlshell-0.1.8/sqlshell/__init__.py

@@ -0,0 +1,8 @@
+"""
+SQLShell - A powerful SQL shell with GUI interface for data analysis
+"""
+
+__version__ = "0.1.8"
+__author__ = "SQLShell Team"
+
+# SQLShell package initialization 

sqlshell-0.1.8/sqlshell/create_test_data.py

@@ -0,0 +1,50 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+
+def create_sales_data(num_records=1000):
+    """Create sample sales data"""
+    # Generate random dates within the last year
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = pd.date_range(start=start_date, end=end_date, periods=num_records)
+    
+    # Generate random data
+    data = {
+        'orderid': range(1, num_records + 1),
+        'orderdate': dates,
+        'customerid': np.random.randint(1, 101, num_records),
+        'productid': np.random.randint(1, 51, num_records),
+        'quantity': np.random.randint(1, 11, num_records),
+        'unitprice': np.random.uniform(10.0, 1000.0, num_records).round(2)
+    }
+    
+    return pd.DataFrame(data)
+
+def create_customer_data(num_customers=100):
+    """Create sample customer data"""
+    # Generate random customer data
+    data = {
+        'customerid': range(1, num_customers + 1),
+        'customername': [f"Customer {i}" for i in range(1, num_customers + 1)],
+        'email': [f"customer{i}@example.com" for i in range(1, num_customers + 1)],
+        'country': np.random.choice(['USA', 'UK', 'Canada', 'Australia', 'Germany'], num_customers),
+        'joindate': pd.date_range(start='2020-01-01', periods=num_customers).tolist()
+    }
+    
+    return pd.DataFrame(data)
+
+def create_product_data(num_products=50):
+    """Create sample product data"""
+    categories = ['Electronics', 'Books', 'Clothing', 'Home & Garden', 'Sports']
+    
+    # Generate random product data
+    data = {
+        'productid': range(1, num_products + 1),
+        'productname': [f"Product {i}" for i in range(1, num_products + 1)],
+        'category': np.random.choice(categories, num_products),
+        'baseprice': np.random.uniform(5.0, 500.0, num_products).round(2),
+        'instock': np.random.choice([True, False], num_products, p=[0.8, 0.2])
+    }
+    
+    return pd.DataFrame(data) 

sqlshell-0.1.8/sqlshell/editor.py

@@ -0,0 +1,355 @@
+from PyQt6.QtWidgets import QPlainTextEdit, QWidget, QCompleter
+from PyQt6.QtCore import Qt, QSize, QRect, QStringListModel
+from PyQt6.QtGui import QFont, QColor, QTextCursor, QPainter, QBrush
+
+class LineNumberArea(QWidget):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.editor = editor
+
+    def sizeHint(self):
+        return QSize(self.editor.line_number_area_width(), 0)
+
+    def paintEvent(self, event):
+        self.editor.line_number_area_paint_event(event)
+
+class SQLEditor(QPlainTextEdit):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.line_number_area = LineNumberArea(self)
+        
+        # Set monospaced font
+        font = QFont("Consolas", 12)  # Increased font size for better readability
+        font.setFixedPitch(True)
+        self.setFont(font)
+        
+        # Connect signals
+        self.blockCountChanged.connect(self.update_line_number_area_width)
+        self.updateRequest.connect(self.update_line_number_area)
+        
+        # Initialize
+        self.update_line_number_area_width(0)
+        
+        # Set tab width to 4 spaces
+        self.setTabStopDistance(4 * self.fontMetrics().horizontalAdvance(' '))
+        
+        # Set placeholder text
+        self.setPlaceholderText("Enter your SQL query here...")
+        
+        # Initialize completer
+        self.completer = None
+        
+        # SQL Keywords for autocomplete
+        self.sql_keywords = [
+            "SELECT", "FROM", "WHERE", "AND", "OR", "INNER", "OUTER", "LEFT", "RIGHT", "JOIN",
+            "ON", "GROUP", "BY", "HAVING", "ORDER", "LIMIT", "OFFSET", "UNION", "EXCEPT", "INTERSECT",
+            "CREATE", "TABLE", "INDEX", "VIEW", "INSERT", "INTO", "VALUES", "UPDATE", "SET", "DELETE",
+            "TRUNCATE", "ALTER", "ADD", "DROP", "COLUMN", "CONSTRAINT", "PRIMARY", "KEY", "FOREIGN", "REFERENCES",
+            "UNIQUE", "NOT", "NULL", "IS", "DISTINCT", "CASE", "WHEN", "THEN", "ELSE", "END",
+            "AS", "WITH", "BETWEEN", "LIKE", "IN", "EXISTS", "ALL", "ANY", "SOME", "DESC", "ASC",
+            "AVG", "COUNT", "SUM", "MAX", "MIN", "COALESCE", "CAST", "CONVERT"
+        ]
+        
+        # Initialize with SQL keywords
+        self.set_completer(QCompleter(self.sql_keywords))
+        
+        # Set modern selection color
+        self.selection_color = QColor("#3498DB")
+        self.selection_color.setAlpha(50)  # Make it semi-transparent
+
+    def set_completer(self, completer):
+        """Set the completer for the editor"""
+        if self.completer:
+            self.completer.disconnect(self)
+            
+        self.completer = completer
+        
+        if not self.completer:
+            return
+            
+        self.completer.setWidget(self)
+        self.completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
+        self.completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
+        self.completer.activated.connect(self.insert_completion)
+        
+    def update_completer_model(self, words):
+        """Update the completer model with new words"""
+        if not self.completer:
+            return
+            
+        # Combine SQL keywords with table/column names
+        all_words = self.sql_keywords + words
+        
+        # Create a model with all words
+        model = QStringListModel()
+        model.setStringList(all_words)
+        
+        # Set the model to the completer
+        self.completer.setModel(model)
+        
+    def text_under_cursor(self):
+        """Get the text under the cursor for completion"""
+        tc = self.textCursor()
+        tc.select(QTextCursor.SelectionType.WordUnderCursor)
+        return tc.selectedText()
+        
+    def insert_completion(self, completion):
+        """Insert the completion text"""
+        if self.completer.widget() != self:
+            return
+            
+        tc = self.textCursor()
+        extra = len(completion) - len(self.completer.completionPrefix())
+        tc.movePosition(QTextCursor.MoveOperation.Left)
+        tc.movePosition(QTextCursor.MoveOperation.EndOfWord)
+        tc.insertText(completion[-extra:] + " ")
+        self.setTextCursor(tc)
+        
+    def complete(self):
+        """Show completion popup"""
+        prefix = self.text_under_cursor()
+        
+        if not prefix or len(prefix) < 2:  # Only show completions for words with at least 2 characters
+            if self.completer.popup().isVisible():
+                self.completer.popup().hide()
+            return
+            
+        self.completer.setCompletionPrefix(prefix)
+        
+        # If no completions, hide popup
+        if self.completer.completionCount() == 0:
+            self.completer.popup().hide()
+            return
+            
+        # Get popup and position it under the current text
+        popup = self.completer.popup()
+        popup.setCurrentIndex(self.completer.completionModel().index(0, 0))
+        
+        # Calculate position for the popup
+        cr = self.cursorRect()
+        cr.setWidth(self.completer.popup().sizeHintForColumn(0) + 
+                   self.completer.popup().verticalScrollBar().sizeHint().width())
+        
+        # Show the popup
+        self.completer.complete(cr)
+
+    def keyPressEvent(self, event):
+        # Handle completer popup navigation
+        if self.completer and self.completer.popup().isVisible():
+            # Handle navigation keys for the popup
+            if event.key() in [Qt.Key.Key_Enter, Qt.Key.Key_Return, Qt.Key.Key_Tab, 
+                              Qt.Key.Key_Escape, Qt.Key.Key_Up, Qt.Key.Key_Down]:
+                event.ignore()
+                return
+        
+        # Handle special key combinations
+        if event.key() == Qt.Key.Key_Tab:
+            # Insert 4 spaces instead of a tab character
+            self.insertPlainText("    ")
+            return
+            
+        # Auto-indentation for new lines
+        if event.key() in [Qt.Key.Key_Return, Qt.Key.Key_Enter]:
+            cursor = self.textCursor()
+            block = cursor.block()
+            text = block.text()
+            
+            # Get the indentation of the current line
+            indentation = ""
+            for char in text:
+                if char.isspace():
+                    indentation += char
+                else:
+                    break
+            
+            # Check if line ends with an opening bracket or keywords that should increase indentation
+            increase_indent = ""
+            if text.strip().endswith("(") or any(text.strip().upper().endswith(keyword) for keyword in 
+                                               ["SELECT", "FROM", "WHERE", "GROUP BY", "ORDER BY", "HAVING"]):
+                increase_indent = "    "
+                
+            # Insert new line with proper indentation
+            super().keyPressEvent(event)
+            self.insertPlainText(indentation + increase_indent)
+            return
+            
+        # Handle keyboard shortcuts
+        if event.modifiers() == Qt.KeyboardModifier.ControlModifier:
+            if event.key() == Qt.Key.Key_Space:
+                # Show completion popup
+                self.complete()
+                return
+            elif event.key() == Qt.Key.Key_K:
+                # Comment/uncomment the selected lines
+                self.toggle_comment()
+                return
+                
+        # For normal key presses
+        super().keyPressEvent(event)
+        
+        # Check for autocomplete after typing
+        if event.text() and not event.text().isspace():
+            self.complete()
+
+    def paintEvent(self, event):
+        # Call the parent's paintEvent first
+        super().paintEvent(event)
+        
+        # Get the current cursor
+        cursor = self.textCursor()
+        
+        # If there's a selection, paint custom highlight
+        if cursor.hasSelection():
+            # Create a painter for this widget
+            painter = QPainter(self.viewport())
+            
+            # Get the selection start and end positions
+            start = cursor.selectionStart()
+            end = cursor.selectionEnd()
+            
+            # Create temporary cursor to get the rectangles
+            temp_cursor = QTextCursor(cursor)
+            
+            # Move to start and get the starting position
+            temp_cursor.setPosition(start)
+            start_pos = self.cursorRect(temp_cursor)
+            
+            # Move to end and get the ending position
+            temp_cursor.setPosition(end)
+            end_pos = self.cursorRect(temp_cursor)
+            
+            # Set the highlight color with transparency
+            painter.setBrush(QBrush(self.selection_color))
+            painter.setPen(Qt.PenStyle.NoPen)
+            
+            # Draw the highlight rectangle
+            if start_pos.top() == end_pos.top():
+                # Single line selection
+                painter.drawRect(QRect(start_pos.left(), start_pos.top(),
+                                     end_pos.right() - start_pos.left(), start_pos.height()))
+            else:
+                # Multi-line selection
+                # First line
+                painter.drawRect(QRect(start_pos.left(), start_pos.top(),
+                                     self.viewport().width() - start_pos.left(), start_pos.height()))
+                
+                # Middle lines (if any)
+                if end_pos.top() > start_pos.top() + start_pos.height():
+                    painter.drawRect(QRect(0, start_pos.top() + start_pos.height(),
+                                         self.viewport().width(),
+                                         end_pos.top() - (start_pos.top() + start_pos.height())))
+                
+                # Last line
+                painter.drawRect(QRect(0, end_pos.top(), end_pos.right(), end_pos.height()))
+            
+            painter.end()
+
+    def focusInEvent(self, event):
+        super().focusInEvent(event)
+        # Show temporary hint in status bar when editor gets focus
+        if hasattr(self.parent(), 'statusBar'):
+            self.parent().parent().parent().statusBar().showMessage('Press Ctrl+Space for autocomplete', 2000)
+
+    def toggle_comment(self):
+        cursor = self.textCursor()
+        if cursor.hasSelection():
+            # Get the selected text
+            start = cursor.selectionStart()
+            end = cursor.selectionEnd()
+            
+            # Remember the selection
+            cursor.setPosition(start)
+            start_block = cursor.blockNumber()
+            cursor.setPosition(end)
+            end_block = cursor.blockNumber()
+            
+            # Process each line in the selection
+            cursor.setPosition(start)
+            cursor.beginEditBlock()
+            
+            for _ in range(start_block, end_block + 1):
+                # Move to start of line
+                cursor.movePosition(cursor.MoveOperation.StartOfLine)
+                
+                # Check if the line is already commented
+                line_text = cursor.block().text().lstrip()
+                if line_text.startswith('--'):
+                    # Remove comment
+                    pos = cursor.block().text().find('--')
+                    cursor.setPosition(cursor.block().position() + pos)
+                    cursor.deleteChar()
+                    cursor.deleteChar()
+                else:
+                    # Add comment
+                    cursor.insertText('--')
+                
+                # Move to next line if not at the end
+                if not cursor.atEnd():
+                    cursor.movePosition(cursor.MoveOperation.NextBlock)
+            
+            cursor.endEditBlock()
+        else:
+            # Comment/uncomment current line
+            cursor.movePosition(cursor.MoveOperation.StartOfLine)
+            cursor.movePosition(cursor.MoveOperation.EndOfLine, cursor.MoveMode.KeepAnchor)
+            line_text = cursor.selectedText().lstrip()
+            
+            cursor.movePosition(cursor.MoveOperation.StartOfLine)
+            if line_text.startswith('--'):
+                # Remove comment
+                pos = cursor.block().text().find('--')
+                cursor.setPosition(cursor.block().position() + pos)
+                cursor.deleteChar()
+                cursor.deleteChar()
+            else:
+                # Add comment
+                cursor.insertText('--')
+
+    def line_number_area_width(self):
+        digits = 1
+        max_num = max(1, self.blockCount())
+        while max_num >= 10:
+            max_num //= 10
+            digits += 1
+        
+        space = 3 + self.fontMetrics().horizontalAdvance('9') * digits
+        return space
+
+    def update_line_number_area_width(self, _):
+        self.setViewportMargins(self.line_number_area_width(), 0, 0, 0)
+
+    def update_line_number_area(self, rect, dy):
+        if dy:
+            self.line_number_area.scroll(0, dy)
+        else:
+            self.line_number_area.update(0, rect.y(), self.line_number_area.width(), rect.height())
+        
+        if rect.contains(self.viewport().rect()):
+            self.update_line_number_area_width(0)
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        cr = self.contentsRect()
+        self.line_number_area.setGeometry(QRect(cr.left(), cr.top(), self.line_number_area_width(), cr.height()))
+
+    def line_number_area_paint_event(self, event):
+        painter = QPainter(self.line_number_area)
+        painter.fillRect(event.rect(), QColor("#f0f0f0"))  # Light gray background
+        
+        block = self.firstVisibleBlock()
+        block_number = block.blockNumber()
+        top = round(self.blockBoundingGeometry(block).translated(self.contentOffset()).top())
+        bottom = top + round(self.blockBoundingRect(block).height())
+        
+        while block.isValid() and top <= event.rect().bottom():
+            if block.isVisible() and bottom >= event.rect().top():
+                number = str(block_number + 1)
+                painter.setPen(QColor("#808080"))  # Gray text
+                painter.drawText(0, top, self.line_number_area.width() - 5, 
+                                self.fontMetrics().height(),
+                                Qt.AlignmentFlag.AlignRight, number)
+            
+            block = block.next()
+            top = bottom
+            bottom = top + round(self.blockBoundingRect(block).height())
+            block_number += 1