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

sqlshell/menus.py

@@ -0,0 +1,171 @@
+"""
+Menu creation and management for SQLShell application.
+This module contains functions to create and manage the application's menus.
+"""
+
+def create_file_menu(main_window):
+    """Create the File menu with project management actions.
+    
+    Args:
+        main_window: The SQLShell main window instance
+        
+    Returns:
+        The created File menu
+    """
+    # Create File menu
+    file_menu = main_window.menuBar().addMenu('&File')
+    
+    # Project management actions
+    new_project_action = file_menu.addAction('New Project')
+    new_project_action.setShortcut('Ctrl+N')
+    new_project_action.triggered.connect(main_window.new_project)
+    
+    open_project_action = file_menu.addAction('Open Project...')
+    open_project_action.setShortcut('Ctrl+O')
+    open_project_action.triggered.connect(main_window.open_project)
+    
+    # Add Recent Projects submenu
+    main_window.recent_projects_menu = file_menu.addMenu('Recent Projects')
+    main_window.update_recent_projects_menu()
+    
+    # Add Quick Access submenu for files
+    main_window.quick_access_menu = file_menu.addMenu('Quick Access Files')
+    main_window.update_quick_access_menu()
+    
+    save_project_action = file_menu.addAction('Save Project')
+    save_project_action.setShortcut('Ctrl+S')
+    save_project_action.triggered.connect(main_window.save_project)
+    
+    save_project_as_action = file_menu.addAction('Save Project As...')
+    save_project_as_action.setShortcut('Ctrl+Shift+S')
+    save_project_as_action.triggered.connect(main_window.save_project_as)
+    
+    file_menu.addSeparator()
+    
+    exit_action = file_menu.addAction('Exit')
+    exit_action.setShortcut('Ctrl+Q')
+    exit_action.triggered.connect(main_window.close)
+    
+    return file_menu
+
+
+def create_view_menu(main_window):
+    """Create the View menu with window management options.
+    
+    Args:
+        main_window: The SQLShell main window instance
+        
+    Returns:
+        The created View menu
+    """
+    # Create View menu
+    view_menu = main_window.menuBar().addMenu('&View')
+    
+    # Maximized window option
+    maximize_action = view_menu.addAction('Maximize Window')
+    maximize_action.setShortcut('F11')
+    maximize_action.triggered.connect(main_window.toggle_maximize_window)
+    
+    # Zoom submenu
+    zoom_menu = view_menu.addMenu('Zoom')
+    
+    zoom_in_action = zoom_menu.addAction('Zoom In')
+    zoom_in_action.setShortcut('Ctrl++')
+    zoom_in_action.triggered.connect(lambda: main_window.change_zoom(1.1))
+    
+    zoom_out_action = zoom_menu.addAction('Zoom Out')
+    zoom_out_action.setShortcut('Ctrl+-')
+    zoom_out_action.triggered.connect(lambda: main_window.change_zoom(0.9))
+    
+    reset_zoom_action = zoom_menu.addAction('Reset Zoom')
+    reset_zoom_action.setShortcut('Ctrl+0')
+    reset_zoom_action.triggered.connect(lambda: main_window.reset_zoom())
+    
+    return view_menu
+
+
+def create_tab_menu(main_window):
+    """Create the Tab menu with tab management actions.
+    
+    Args:
+        main_window: The SQLShell main window instance
+        
+    Returns:
+        The created Tab menu
+    """
+    # Create Tab menu
+    tab_menu = main_window.menuBar().addMenu('&Tab')
+    
+    new_tab_action = tab_menu.addAction('New Tab')
+    new_tab_action.setShortcut('Ctrl+T')
+    new_tab_action.triggered.connect(main_window.add_tab)
+    
+    duplicate_tab_action = tab_menu.addAction('Duplicate Current Tab')
+    duplicate_tab_action.setShortcut('Ctrl+D')
+    duplicate_tab_action.triggered.connect(main_window.duplicate_current_tab)
+    
+    rename_tab_action = tab_menu.addAction('Rename Current Tab')
+    rename_tab_action.setShortcut('Ctrl+R')
+    rename_tab_action.triggered.connect(main_window.rename_current_tab)
+    
+    close_tab_action = tab_menu.addAction('Close Current Tab')
+    close_tab_action.setShortcut('Ctrl+W')
+    close_tab_action.triggered.connect(main_window.close_current_tab)
+    
+    return tab_menu
+
+
+def create_preferences_menu(main_window):
+    """Create the Preferences menu with user settings.
+    
+    Args:
+        main_window: The SQLShell main window instance
+        
+    Returns:
+        The created Preferences menu
+    """
+    # Create Preferences menu
+    preferences_menu = main_window.menuBar().addMenu('&Preferences')
+    
+    # Auto-load recent project option
+    auto_load_action = preferences_menu.addAction('Auto-load Most Recent Project')
+    auto_load_action.setCheckable(True)
+    auto_load_action.setChecked(main_window.auto_load_recent_project)
+    auto_load_action.triggered.connect(lambda checked: toggle_auto_load(main_window, checked))
+    
+    return preferences_menu
+
+
+def toggle_auto_load(main_window, checked):
+    """Toggle the auto-load recent project setting.
+    
+    Args:
+        main_window: The SQLShell main window instance
+        checked: Boolean indicating whether the option is checked
+    """
+    main_window.auto_load_recent_project = checked
+    main_window.save_recent_projects()  # Save the preference
+    main_window.statusBar().showMessage(
+        f"Auto-load most recent project {'enabled' if checked else 'disabled'}", 
+        2000
+    )
+
+
+def setup_menubar(main_window):
+    """Set up the complete menu bar for the application.
+    
+    Args:
+        main_window: The SQLShell main window instance
+    """
+    # Create the menu bar (in case it doesn't exist)
+    menubar = main_window.menuBar()
+    
+    # Create menus
+    file_menu = create_file_menu(main_window)
+    view_menu = create_view_menu(main_window)
+    tab_menu = create_tab_menu(main_window)
+    preferences_menu = create_preferences_menu(main_window)
+    
+    # You can add more menus here in the future
+    
+    return menubar 

sqlshell/query_tab.py

@@ -0,0 +1,201 @@
+import os
+from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
+                             QPushButton, QFrame, QHeaderView, QTableWidget, QSplitter, QApplication, 
+                             QToolButton, QMenu)
+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
+from sqlshell.styles import get_row_count_label_stylesheet
+
+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)
+        
+        # Connect keyboard events for direct handling of Ctrl+Enter
+        self.query_edit.installEventFilter(self)
+        
+        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(get_row_count_label_stylesheet())
+        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()
+            
+    def eventFilter(self, obj, event):
+        """Event filter to intercept Ctrl+Enter and send it to the main window"""
+        from PyQt6.QtCore import QEvent, Qt
+        
+        # Check if it's a key press event
+        if event.type() == QEvent.Type.KeyPress:
+            # Check for Ctrl+Enter specifically
+            if (event.key() == Qt.Key.Key_Return and 
+                event.modifiers() & Qt.KeyboardModifier.ControlModifier):
+                
+                # Hide any autocomplete popup if it's visible
+                if hasattr(obj, 'completer') and obj.completer and obj.completer.popup().isVisible():
+                    obj.completer.popup().hide()
+                
+                # Execute the query via the parent (main window)
+                if hasattr(self.parent, 'execute_query'):
+                    self.parent.execute_query()
+                    # Mark event as handled
+                    return True
+                    
+        # Default - let the event propagate normally
+        return super().eventFilter(obj, event) 

sqlshell/resources/create_icon.py

@@ -1,53 +1,131 @@
 import os
+import sys
 from PIL import Image, ImageDraw, ImageFont
 
 def create_sql_icon(output_path, size=256):
-    """Create a simple SQL icon"""
+    """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
+    primary_color = (44, 62, 80, 255)      # Dark blue-gray
     secondary_color = (52, 152, 219, 255)  # Bright blue
-    accent_color = (26, 188, 156, 255)  # Teal
+    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 // 10
-    rect = [(size//8, size//8), (size - size//8, size - size//8)]
+    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 a font, fall back to default if not available
-    try:
-        font_size = size // 3
-        font = ImageFont.truetype("arial.ttf", font_size)
-    except IOError:
+    # 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("DejaVuSans.ttf", font_size)
+            font = ImageFont.truetype(font_name, font_size)
+            break
         except IOError:
-            font = ImageFont.load_default()
+            continue
     
-    # Draw SQL text
+    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"
-    text_width, text_height = draw.textsize(text, font=font) if hasattr(draw, 'textsize') else font.getsize(text)
-    position = ((size - text_width) // 2, (size - text_height) // 2)
-    draw.text(position, text, fill=accent_color, font=font)
+    
+    # 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 // 4
+    db_size = size // 3
     db_x = size // 2 - db_size // 2
-    db_y = size // 2 + text_height // 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)
     
-    # Draw database cylinder
-    draw.ellipse([(db_x, db_y - db_size//3), (db_x + db_size, db_y)], fill=secondary_color)
-    draw.ellipse([(db_x, db_y + db_size//3), (db_x + db_size, db_y + db_size//1.5)], fill=secondary_color)
-    draw.rectangle([(db_x, db_y), (db_x + db_size, db_y + db_size//3)], 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
-    img.save(output_path)
-    print(f"Icon created at {output_path}")
+    # Save the image with compression
+    img.save(output_path, optimize=True)
+    print(f"Professional SQL icon created at {output_path}")
+    return img
 
-if __name__ == "__main__":
+def create_logo(size=512):
+    """Create a properly sized logo for different uses"""
     output_dir = os.path.dirname(os.path.abspath(__file__))
-    output_path = os.path.join(output_dir, "icon.png")
-    create_sql_icon(output_path) 
+    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

@@ -2,7 +2,7 @@ from PIL import Image, ImageDraw, ImageFont
 import os
 import math
 
-def create_frame(size, progress, text=None):  # We won't use text parameter anymore
+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)
@@ -12,12 +12,31 @@ def create_frame(size, progress, text=None):  # We won't use text parameter anym
     center_x = width // 2
     center_y = height // 2
     
-    # Create a subtle circular pattern
-    radius = 60
+    # Create a more visible circular pattern
+    radius = 80  # Larger radius
     num_dots = 12
-    dot_size = 4
-    trail_length = 6
+    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
@@ -32,21 +51,32 @@ def create_frame(size, progress, text=None):  # We won't use text parameter anym
             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=(52, 152, 219, current_opacity)  # Bright blue with fading opacity
+                    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 60 frames for smooth animation
-    for i in range(60):
-        progress = i / 60
+    # 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)
     
@@ -56,9 +86,9 @@ def create_splash_gif():
         output_path,
         save_all=True,
         append_images=frames[1:],
-        duration=50,  # 50ms per frame = 20fps
+        duration=66,  # 66ms per frame = ~15fps (reduced from 20fps for smaller file size)
         loop=0,
-        optimize=False
+        optimize=True  # Enable optimization
     )
     print(f"Created splash screen GIF at: {output_path}")