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

sqlshell/query_tab.py

@@ -0,0 +1,172 @@
+from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
+                             QPushButton, QFrame, QHeaderView, QTableWidget, QSplitter, QApplication)
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QIcon
+
+from sqlshell.editor import SQLEditor
+from sqlshell.syntax_highlighter import SQLSyntaxHighlighter
+from sqlshell.ui import FilterHeader
+
+class QueryTab(QWidget):
+    def __init__(self, parent, results_title="RESULTS"):
+        super().__init__()
+        self.parent = parent
+        self.current_df = None
+        self.filter_widgets = []
+        self.results_title_text = results_title
+        self.init_ui()
+        
+    def init_ui(self):
+        """Initialize the tab's UI components"""
+        # Set main layout
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+        
+        # Create splitter for query and results
+        self.splitter = QSplitter(Qt.Orientation.Vertical)
+        self.splitter.setHandleWidth(8)
+        self.splitter.setChildrenCollapsible(False)
+        
+        # Top part - Query section
+        query_widget = QFrame()
+        query_widget.setObjectName("content_panel")
+        query_layout = QVBoxLayout(query_widget)
+        query_layout.setContentsMargins(16, 16, 16, 16)
+        query_layout.setSpacing(12)
+        
+        # Query input
+        self.query_edit = SQLEditor()
+        # Apply syntax highlighting to the query editor
+        self.sql_highlighter = SQLSyntaxHighlighter(self.query_edit.document())
+        
+        # Ensure a default completer is available
+        if not self.query_edit.completer:
+            from PyQt6.QtCore import QStringListModel
+            from PyQt6.QtWidgets import QCompleter
+            
+            # Create a basic completer with SQL keywords if one doesn't exist
+            if hasattr(self.query_edit, 'all_sql_keywords'):
+                model = QStringListModel(self.query_edit.all_sql_keywords)
+                completer = QCompleter()
+                completer.setModel(model)
+                self.query_edit.set_completer(completer)
+        
+        query_layout.addWidget(self.query_edit)
+        
+        # Button row
+        button_layout = QHBoxLayout()
+        button_layout.setSpacing(8)
+        
+        self.execute_btn = QPushButton('Execute Query')
+        self.execute_btn.setObjectName("primary_button")
+        self.execute_btn.setIcon(QIcon.fromTheme("media-playback-start"))
+        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()
+        
+        self.export_excel_btn = QPushButton('Export to Excel')
+        self.export_excel_btn.setIcon(QIcon.fromTheme("x-office-spreadsheet"))
+        self.export_excel_btn.clicked.connect(self.export_to_excel)
+        
+        self.export_parquet_btn = QPushButton('Export to Parquet')
+        self.export_parquet_btn.setIcon(QIcon.fromTheme("application-octet-stream"))
+        self.export_parquet_btn.clicked.connect(self.export_to_parquet)
+        
+        button_layout.addWidget(self.export_excel_btn)
+        button_layout.addWidget(self.export_parquet_btn)
+        
+        query_layout.addLayout(button_layout)
+        
+        # Bottom part - Results section
+        results_widget = QWidget()
+        results_layout = QVBoxLayout(results_widget)
+        results_layout.setContentsMargins(16, 16, 16, 16)
+        results_layout.setSpacing(12)
+        
+        # Results header with row count
+        header_layout = QHBoxLayout()
+        self.results_title = QLabel(self.results_title_text)
+        self.results_title.setObjectName("header_label")
+        header_layout.addWidget(self.results_title)
+        
+        header_layout.addStretch()
+        
+        self.row_count_label = QLabel("")
+        self.row_count_label.setStyleSheet("color: #7F8C8D; font-style: italic;")
+        header_layout.addWidget(self.row_count_label)
+        
+        results_layout.addLayout(header_layout)
+        
+        # Results table with customized header
+        self.results_table = QTableWidget()
+        self.results_table.setAlternatingRowColors(True)
+        
+        # Use custom FilterHeader for filtering
+        header = FilterHeader(self.results_table)
+        header.set_main_window(self.parent)  # Set reference to main window
+        self.results_table.setHorizontalHeader(header)
+        
+        # Set table properties for better performance with large datasets
+        self.results_table.setShowGrid(True)
+        self.results_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        self.results_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
+        self.results_table.horizontalHeader().setStretchLastSection(True)
+        self.results_table.verticalHeader().setVisible(True)
+        
+        results_layout.addWidget(self.results_table)
+        
+        # Add widgets to splitter
+        self.splitter.addWidget(query_widget)
+        self.splitter.addWidget(results_widget)
+        
+        # Set initial sizes - default 40% query, 60% results
+        # This will be better for most uses of the app
+        screen = QApplication.primaryScreen()
+        if screen:
+            # Get available screen height
+            available_height = screen.availableGeometry().height()
+            # Calculate reasonable query pane size (25-35% depending on screen size)
+            if available_height >= 1080:  # Large screens
+                query_height = int(available_height * 0.3)  # 30% for query area
+                self.splitter.setSizes([query_height, available_height - query_height])
+            else:  # Smaller screens
+                self.splitter.setSizes([300, 500])  # Default values for smaller screens
+        else:
+            # Fallback to fixed values if screen detection fails
+            self.splitter.setSizes([300, 500])
+        
+        main_layout.addWidget(self.splitter)
+        
+    def get_query_text(self):
+        """Get the current query text"""
+        return self.query_edit.toPlainText()
+        
+    def set_query_text(self, text):
+        """Set the query text"""
+        self.query_edit.setPlainText(text)
+        
+    def execute_query(self):
+        """Execute the current query"""
+        if hasattr(self.parent, 'execute_query'):
+            self.parent.execute_query()
+        
+    def clear_query(self):
+        """Clear the query editor"""
+        if hasattr(self.parent, 'clear_query'):
+            self.parent.clear_query()
+        
+    def export_to_excel(self):
+        """Export results to Excel"""
+        if hasattr(self.parent, 'export_to_excel'):
+            self.parent.export_to_excel()
+        
+    def export_to_parquet(self):
+        """Export results to Parquet"""
+        if hasattr(self.parent, 'export_to_parquet'):
+            self.parent.export_to_parquet() 

sqlshell/resources/__init__.py

@@ -0,0 +1 @@
+# SQLShell resources package initialization 

sqlshell/resources/create_icon.py

@@ -0,0 +1,131 @@
+import os
+import sys
+from PIL import Image, ImageDraw, ImageFont
+
+def create_sql_icon(output_path, size=256):
+    """Create a professional SQL icon with improved readability"""
+    # Create a new image with a transparent background
+    img = Image.new('RGBA', (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    
+    # Define colors
+    primary_color = (44, 62, 80, 255)      # Dark blue-gray
+    secondary_color = (52, 152, 219, 255)  # Bright blue
+    text_color = (236, 240, 241, 255)      # Light gray for better readability
+    accent_color = (26, 188, 156, 255)     # Teal
+    
+    # Draw a rounded rectangle background
+    radius = size // 8
+    rect = [(size//12, size//12), (size - size//12, size - size//12)]
+    draw.rounded_rectangle(rect, radius, fill=primary_color)
+    
+    # Try to load fonts in order of preference
+    font_size = size // 4  # Slightly smaller for better readability
+    font = None
+    
+    # Common fonts list to try
+    font_options = [
+        "Arial Bold", "Arial", "Helvetica Bold", "Helvetica",
+        "DejaVuSans-Bold.ttf", "DejaVuSans.ttf", 
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+    ]
+    
+    for font_name in font_options:
+        try:
+            font = ImageFont.truetype(font_name, font_size)
+            break
+        except IOError:
+            continue
+    
+    if font is None:
+        font = ImageFont.load_default()
+        font_size = size // 5  # Adjust size for default font
+    
+    # Draw "SQL" text with improved visibility
+    text = "SQL"
+    
+    # Handle different PIL versions for text size calculation
+    if hasattr(draw, 'textsize'):
+        text_width, text_height = draw.textsize(text, font=font)
+    elif hasattr(font, 'getsize'):
+        text_width, text_height = font.getsize(text)
+    else:
+        # Fallback for newer PIL versions
+        try:
+            text_width, text_height = font.getbbox(text)[2:]
+        except:
+            text_width, text_height = font_size * 3, font_size
+    
+    # Position text slightly higher
+    position = ((size - text_width) // 2, (size - text_height) // 2 - size//12)
+    
+    # Draw text with subtle shadow for better readability
+    shadow_offset = max(1, size // 64)
+    draw.text((position[0] + shadow_offset, position[1] + shadow_offset), 
+              text, fill=(0, 0, 0, 100), font=font)
+    draw.text(position, text, fill=text_color, font=font)
+    
+    # Draw a small database icon
+    db_size = size // 3
+    db_x = size // 2 - db_size // 2
+    db_y = size // 2 + text_height // 2 + db_size // 4
+    
+    # Draw database cylinder with improved shape
+    # Top ellipse
+    draw.ellipse([(db_x, db_y - db_size//4), (db_x + db_size, db_y)], 
+                fill=secondary_color)
+    # Bottom ellipse
+    draw.ellipse([(db_x, db_y + db_size//2), (db_x + db_size, db_y + db_size//1.5)], 
+                fill=secondary_color)
+    # Rectangle body
+    draw.rectangle([(db_x, db_y), (db_x + db_size, db_y + db_size//2)], 
+                  fill=secondary_color)
+    
+    # Add subtle details to database
+    highlight_color = (72, 172, 240, 150)  # Lighter blue for highlight
+    # Database line details
+    line_y1 = db_y + db_size//6
+    line_y2 = db_y + db_size//3
+    draw.line([(db_x + db_size//6, line_y1), (db_x + db_size - db_size//6, line_y1)], 
+             fill=highlight_color, width=max(1, size//128))
+    draw.line([(db_x + db_size//6, line_y2), (db_x + db_size - db_size//6, line_y2)], 
+             fill=highlight_color, width=max(1, size//128))
+    
+    # Save the image with compression
+    img.save(output_path, optimize=True)
+    print(f"Professional SQL icon created at {output_path}")
+    return img
+
+def create_logo(size=512):
+    """Create a properly sized logo for different uses"""
+    output_dir = os.path.dirname(os.path.abspath(__file__))
+    project_dir = os.path.abspath(os.path.join(output_dir, '..', '..'))
+    
+    # Create different sizes
+    sizes = {
+        'icon': 128,           # For app icon
+        'logo_small': 256,     # For UI elements
+        'logo_medium': 512,    # For documentation
+        'logo_large': 1024     # For high-res displays
+    }
+    
+    for name, icon_size in sizes.items():
+        output_path = os.path.join(output_dir, f"{name}.png")
+        create_sql_icon(output_path, icon_size)
+    
+    # Create the main logo file at the root directory
+    main_logo_path = os.path.join(project_dir, "sqlshell_logo.png")
+    logo = create_sql_icon(main_logo_path, size)
+    print(f"Main logo created at {main_logo_path}")
+
+if __name__ == "__main__":
+    # Default size is 512 if no argument provided
+    size = 512
+    if len(sys.argv) > 1:
+        try:
+            size = int(sys.argv[1])
+        except ValueError:
+            print(f"Invalid size argument: {sys.argv[1]}. Using default size {size}.")
+    
+    create_logo(size) 

sqlshell/resources/create_splash.py

@@ -0,0 +1,96 @@
+from PIL import Image, ImageDraw, ImageFont
+import os
+import math
+
+def create_frame(size, progress, text=None):
+    # Create a new image with a dark background
+    img = Image.new('RGBA', size, (44, 62, 80, 255))  # Dark blue-gray background
+    draw = ImageDraw.Draw(img)
+    
+    # Calculate dimensions
+    width, height = size
+    center_x = width // 2
+    center_y = height // 2
+    
+    # Create a more visible circular pattern
+    radius = 80  # Larger radius
+    num_dots = 12
+    dot_size = 6  # Larger dots
+    trail_length = 8  # Longer trail
+    
+    # Add a subtle gradient background
+    for y in range(height):
+        # Create a vertical gradient
+        gradient_factor = y / height
+        r = int(44 + (52 - 44) * gradient_factor)
+        g = int(62 + (152 - 62) * gradient_factor)
+        b = int(80 + (219 - 80) * gradient_factor)
+        draw.line([(0, y), (width, y)], fill=(r, g, b, 255))
+    
+    # Draw a pulsing circle
+    pulse_size = 40 + 15 * math.sin(progress * 2 * math.pi)
+    draw.ellipse(
+        (center_x - pulse_size, center_y - pulse_size,
+         center_x + pulse_size, center_y + pulse_size),
+        outline=(52, 152, 219, 100),
+        width=2
+    )
+    
+    # Draw orbiting dots with trails
+    for i in range(num_dots):
+        # Calculate dot position
+        angle = (progress * 360 - i * (360 / num_dots)) % 360
+        x = center_x + radius * math.cos(math.radians(angle))
+        y = center_y + radius * math.sin(math.radians(angle))
+        
+        # Calculate dot opacity based on position in trail
+        opacity = int(255 * (1 - (i / trail_length))) if i < trail_length else 0
+        
+        if opacity > 0:
+            # Draw dot with gradient effect
+            for size_mult in [1.0, 0.8, 0.6]:
+                current_size = int(dot_size * size_mult)
+                current_opacity = int(opacity * size_mult)
+                
+                # Use more vibrant color for dots
+                draw.ellipse(
+                    (x - current_size, y - current_size,
+                     x + current_size, y + current_size),
+                    fill=(41, 128, 185, current_opacity)  # Brighter blue with fading opacity
+                )
+    
+    # Add a subtle glow effect in the center
+    glow_radius = 60 + 10 * math.sin(progress * 4 * math.pi)
+    for r in range(int(glow_radius), 0, -5):
+        opacity = int(100 * (r / glow_radius))
+        draw.ellipse(
+            (center_x - r, center_y - r, center_x + r, center_y + r),
+            fill=(52, 152, 219, opacity // 8)  # Very transparent blue
+        )
+    
+    return img
+
+def create_splash_gif():
+    size = (400, 300)
+    frames = []
+    
+    # Create 30 frames for smooth animation (reduced from 60 for smaller file size)
+    for i in range(30):
+        progress = i / 30
+        frame = create_frame(size, progress)
+        frames.append(frame)
+    
+    # Save the animated GIF
+    output_path = os.path.join(os.path.dirname(__file__), "splash_screen.gif")
+    frames[0].save(
+        output_path,
+        save_all=True,
+        append_images=frames[1:],
+        duration=66,  # 66ms per frame = ~15fps (reduced from 20fps for smaller file size)
+        loop=0,
+        optimize=True  # Enable optimization
+    )
+    print(f"Created splash screen GIF at: {output_path}")
+
+if __name__ == "__main__":
+    create_splash_gif() 

sqlshell/setup.py

@@ -21,7 +21,7 @@ setup(
     },
     author="SQLShell Team",
     description="A powerful SQL shell with GUI interface for data analysis",
-    long_description=open('README.md').read(),
+    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",