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

sqlshell/resources/__init__.py

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

sqlshell/resources/create_icon.py

@@ -0,0 +1,53 @@
+import os
+from PIL import Image, ImageDraw, ImageFont
+
+def create_sql_icon(output_path, size=256):
+    """Create a simple SQL icon"""
+    # 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
+    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)]
+    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:
+            font = ImageFont.truetype("DejaVuSans.ttf", font_size)
+        except IOError:
+            font = ImageFont.load_default()
+    
+    # Draw SQL text
+    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)
+    
+    # Draw a small database icon
+    db_size = size // 4
+    db_x = size // 2 - db_size // 2
+    db_y = size // 2 + text_height // 2 + db_size // 2
+    
+    # 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)
+    
+    # Save the image
+    img.save(output_path)
+    print(f"Icon created at {output_path}")
+
+if __name__ == "__main__":
+    output_dir = os.path.dirname(os.path.abspath(__file__))
+    output_path = os.path.join(output_dir, "icon.png")
+    create_sql_icon(output_path) 

sqlshell/resources/create_splash.py

@@ -0,0 +1,66 @@
+from PIL import Image, ImageDraw, ImageFont
+import os
+import math
+
+def create_frame(size, progress, text=None):  # We won't use text parameter anymore
+    # 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 subtle circular pattern
+    radius = 60
+    num_dots = 12
+    dot_size = 4
+    trail_length = 6
+    
+    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)
+                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
+                )
+    
+    return img
+
+def create_splash_gif():
+    size = (400, 300)
+    frames = []
+    
+    # Create 60 frames for smooth animation
+    for i in range(60):
+        progress = i / 60
+        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=50,  # 50ms per frame = 20fps
+        loop=0,
+        optimize=False
+    )
+    print(f"Created splash screen GIF at: {output_path}")
+
+if __name__ == "__main__":
+    create_splash_gif() 

sqlshell/splash_screen.py

@@ -0,0 +1,177 @@
+from PyQt6.QtWidgets import QWidget, QLabel, QVBoxLayout
+from PyQt6.QtCore import Qt, QTimer, QPropertyAnimation, QEasingCurve, QPoint, QRect, pyqtProperty
+from PyQt6.QtGui import QPainter, QColor, QFont, QMovie, QPainterPath, QLinearGradient
+import os
+
+class AnimatedSplashScreen(QWidget):
+    def __init__(self):
+        super().__init__()
+        
+        # Initialize properties for animations first
+        self._opacity = 0.0
+        self._progress = 0.0
+        self.next_widget = None
+        
+        # Set up the window properties
+        self.setWindowFlags(
+            Qt.WindowType.WindowStaysOnTopHint |
+            Qt.WindowType.FramelessWindowHint |
+            Qt.WindowType.SplashScreen
+        )
+        
+        # Set widget attributes for proper compositing
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_NoSystemBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, False)
+        
+        # Set fixed size
+        self.setFixedSize(400, 300)
+        
+        # Center the splash screen on the screen
+        screen_geometry = self.screen().geometry()
+        self.move(
+            (screen_geometry.width() - self.width()) // 2,
+            (screen_geometry.height() - self.height()) // 2
+        )
+
+        # Create layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(20, 20, 20, 20)
+        layout.setSpacing(10)
+        
+        # Create background container for the title and subtitle
+        self.content_container = QWidget(self)
+        content_layout = QVBoxLayout(self.content_container)
+        content_layout.setContentsMargins(20, 20, 20, 20)
+        content_layout.setSpacing(10)
+        
+        # Create title label
+        self.title_label = QLabel("SQLShell", self.content_container)
+        self.title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.title_label.setStyleSheet("""
+            QLabel {
+                color: #3498DB;
+                font-size: 32px;
+                font-weight: bold;
+                font-family: 'Segoe UI', Arial, sans-serif;
+                background: transparent;
+            }
+        """)
+        content_layout.addWidget(self.title_label)
+        
+        # Create subtitle label
+        self.subtitle_label = QLabel("Loading...", self.content_container)
+        self.subtitle_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.subtitle_label.setStyleSheet("""
+            QLabel {
+                color: #2C3E50;
+                font-size: 16px;
+                font-family: 'Segoe UI', Arial, sans-serif;
+                background: transparent;
+            }
+        """)
+        content_layout.addWidget(self.subtitle_label)
+        
+        # Add content container to main layout
+        layout.addWidget(self.content_container)
+        
+        # Create movie label (background)
+        self.movie_label = QLabel(self)
+        self.movie_label.setGeometry(0, 0, self.width(), self.height())
+        self.movie_label.lower()  # Put it at the back
+        
+        # Create overlay for fade effect (between movie and content)
+        self.overlay = QLabel(self)
+        self.overlay.setStyleSheet("background-color: rgba(0, 0, 0, 0);")
+        self.overlay.setGeometry(0, 0, self.width(), self.height())
+        self.overlay.lower()  # Put it behind the content but above the movie
+        
+        # Create text label for animated text
+        self.text_label = QLabel(self)
+        self.text_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.text_label.setStyleSheet("color: rgba(255, 255, 255, 0); background: transparent;")
+        self.text_label.setGeometry(0, 0, self.width(), self.height())
+        self.text_label.lower()  # Put it behind the content
+        
+        # Create progress bar (always on top)
+        self.progress_bar = QLabel(self)
+        self.progress_bar.setFixedHeight(4)
+        self.progress_bar.setStyleSheet("background-color: #3498DB; border-radius: 2px;")
+        self.progress_bar.move(100, self.height() - 40)
+        self.progress_bar.setFixedWidth(0)
+        self.progress_bar.raise_()  # Ensure it's on top
+        
+        # Set up the loading animation
+        self.movie = QMovie(os.path.join(os.path.dirname(__file__), "resources", "splash_screen.gif"))
+        self.movie.setScaledSize(self.size())
+        self.movie_label.setMovie(self.movie)
+        
+        # Set up fade animation
+        self.fade_anim = QPropertyAnimation(self, b"opacity")
+        self.fade_anim.setDuration(1000)
+        self.fade_anim.setStartValue(0.0)
+        self.fade_anim.setEndValue(1.0)
+        self.fade_anim.setEasingCurve(QEasingCurve.Type.InOutQuad)
+        
+        # Set up progress animation
+        self.progress_anim = QPropertyAnimation(self, b"progress")
+        self.progress_anim.setDuration(2000)
+        self.progress_anim.setStartValue(0.0)
+        self.progress_anim.setEndValue(1.0)
+        self.progress_anim.setEasingCurve(QEasingCurve.Type.InOutQuad)
+        
+        # Start animations after everything is initialized
+        QTimer.singleShot(100, self.start_animations)  # Small delay to ensure everything is ready
+
+    def start_animations(self):
+        """Start all animations"""
+        self.movie.start()
+        self.fade_anim.start()
+        self.progress_anim.start()
+        self.progress_anim.finished.connect(self._on_animation_finished)
+
+    @pyqtProperty(float)
+    def opacity(self):
+        return self._opacity
+
+    @opacity.setter
+    def opacity(self, value):
+        self._opacity = value
+        # Update opacity of overlay and text
+        self.overlay.setStyleSheet(f"background-color: rgba(0, 0, 0, {int(100 * value)});")
+        self.text_label.setStyleSheet(f"""
+            QLabel {{
+                color: rgba(255, 255, 255, {int(255 * value)});
+                background: transparent;
+                text-shadow: 2px 2px 4px rgba(0, 0, 0, {int(180 * value)}),
+                            0px 0px 10px rgba(52, 152, 219, {int(160 * value)});
+            }}
+        """)
+
+    @pyqtProperty(float)
+    def progress(self):
+        return self._progress
+
+    @progress.setter
+    def progress(self, value):
+        self._progress = value
+        # Update progress bar width
+        self.progress_bar.setFixedWidth(int(200 * value))
+
+    def _on_animation_finished(self):
+        """Handle animation completion"""
+        if self.next_widget:
+            QTimer.singleShot(500, self._finish_splash)
+
+    def _finish_splash(self):
+        """Clean up and show the main window"""
+        self.movie.stop()
+        self.fade_anim.stop()
+        self.progress_anim.stop()
+        self.close()
+        if self.next_widget:
+            self.next_widget.show()
+
+    def finish(self, widget):
+        """Store the widget to show after animation completes"""
+        self.next_widget = widget 

sqlshell/sqlshell/create_test_data.py

@@ -110,28 +110,9 @@ if __name__ == '__main__':
     print(f"Number of products: {len(product_df)}")
     
     # Print sample queries
-    print("\nSample SQL queries for joining the data:")
+    print("\nSample SQL queries")
     print("""
-    -- Join sales with customer data
-    SELECT s.*, c.FirstName, c.LastName, c.CustomerType
-    FROM test_data.sample_sales_data s
-    JOIN test_data.customer_data c ON s.CustomerID = c.CustomerID;
-    
-    -- Join sales with product data
-    SELECT s.*, p.ProductName, p.Category, p.Brand
-    FROM test_data.sample_sales_data s
-    JOIN test_data.product_catalog p ON s.ProductID = p.ProductID;
-    
-    -- Three-way join with aggregation
-    SELECT 
-        p.Category,
-        c.CustomerType,
-        COUNT(*) as NumOrders,
-        SUM(s.TotalAmount) as TotalRevenue,
-        AVG(s.Quantity) as AvgQuantity
-    FROM test_data.sample_sales_data s
-    JOIN test_data.customer_data c ON s.CustomerID = c.CustomerID
-    JOIN test_data.product_catalog p ON s.ProductID = p.ProductID
-    GROUP BY p.Category, c.CustomerType
-    ORDER BY p.Category, c.CustomerType;
+    select * from product_catalog;
+    select * from customer_data;
+    select * from sample_sales_data;
     """) 

sqlshell/syntax_highlighter.py

@@ -0,0 +1,123 @@
+from PyQt6.QtCore import Qt, QRegularExpression
+from PyQt6.QtGui import QFont, QColor, QSyntaxHighlighter, QTextCharFormat
+
+class SQLSyntaxHighlighter(QSyntaxHighlighter):
+    def __init__(self, document):
+        super().__init__(document)
+        self.highlighting_rules = []
+
+        # SQL Keywords
+        keyword_format = QTextCharFormat()
+        keyword_format.setForeground(QColor("#0000FF"))  # Blue
+        keyword_format.setFontWeight(QFont.Weight.Bold)
+        keywords = [
+            "\\bSELECT\\b", "\\bFROM\\b", "\\bWHERE\\b", "\\bAND\\b", "\\bOR\\b",
+            "\\bINNER\\b", "\\bOUTER\\b", "\\bLEFT\\b", "\\bRIGHT\\b", "\\bJOIN\\b",
+            "\\bON\\b", "\\bGROUP\\b", "\\bBY\\b", "\\bHAVING\\b", "\\bORDER\\b",
+            "\\bLIMIT\\b", "\\bOFFSET\\b", "\\bUNION\\b", "\\bEXCEPT\\b", "\\bINTERSECT\\b",
+            "\\bCREATE\\b", "\\bTABLE\\b", "\\bINDEX\\b", "\\bVIEW\\b", "\\bINSERT\\b",
+            "\\bINTO\\b", "\\bVALUES\\b", "\\bUPDATE\\b", "\\bSET\\b", "\\bDELETE\\b",
+            "\\bTRUNCATE\\b", "\\bALTER\\b", "\\bADD\\b", "\\bDROP\\b", "\\bCOLUMN\\b",
+            "\\bCONSTRAINT\\b", "\\bPRIMARY\\b", "\\bKEY\\b", "\\bFOREIGN\\b", "\\bREFERENCES\\b",
+            "\\bUNIQUE\\b", "\\bNOT\\b", "\\bNULL\\b", "\\bIS\\b", "\\bDISTINCT\\b",
+            "\\bCASE\\b", "\\bWHEN\\b", "\\bTHEN\\b", "\\bELSE\\b", "\\bEND\\b",
+            "\\bAS\\b", "\\bWITH\\b", "\\bBETWEEN\\b", "\\bLIKE\\b", "\\bIN\\b",
+            "\\bEXISTS\\b", "\\bALL\\b", "\\bANY\\b", "\\bSOME\\b", "\\bDESC\\b", "\\bASC\\b"
+        ]
+        for pattern in keywords:
+            regex = QRegularExpression(pattern, QRegularExpression.PatternOption.CaseInsensitiveOption)
+            self.highlighting_rules.append((regex, keyword_format))
+
+        # Functions
+        function_format = QTextCharFormat()
+        function_format.setForeground(QColor("#AA00AA"))  # Purple
+        functions = [
+            "\\bAVG\\b", "\\bCOUNT\\b", "\\bSUM\\b", "\\bMAX\\b", "\\bMIN\\b",
+            "\\bCOALESCE\\b", "\\bNVL\\b", "\\bNULLIF\\b", "\\bCAST\\b", "\\bCONVERT\\b",
+            "\\bLOWER\\b", "\\bUPPER\\b", "\\bTRIM\\b", "\\bLTRIM\\b", "\\bRTRIM\\b",
+            "\\bLENGTH\\b", "\\bSUBSTRING\\b", "\\bREPLACE\\b", "\\bCONCAT\\b",
+            "\\bROUND\\b", "\\bFLOOR\\b", "\\bCEIL\\b", "\\bABS\\b", "\\bMOD\\b",
+            "\\bCURRENT_DATE\\b", "\\bCURRENT_TIME\\b", "\\bCURRENT_TIMESTAMP\\b",
+            "\\bEXTRACT\\b", "\\bDATE_PART\\b", "\\bTO_CHAR\\b", "\\bTO_DATE\\b"
+        ]
+        for pattern in functions:
+            regex = QRegularExpression(pattern, QRegularExpression.PatternOption.CaseInsensitiveOption)
+            self.highlighting_rules.append((regex, function_format))
+
+        # Numbers
+        number_format = QTextCharFormat()
+        number_format.setForeground(QColor("#009900"))  # Green
+        self.highlighting_rules.append((
+            QRegularExpression("\\b[0-9]+\\b"),
+            number_format
+        ))
+
+        # Single-line string literals
+        string_format = QTextCharFormat()
+        string_format.setForeground(QColor("#CC6600"))  # Orange/Brown
+        self.highlighting_rules.append((
+            QRegularExpression("'[^']*'"),
+            string_format
+        ))
+        self.highlighting_rules.append((
+            QRegularExpression("\"[^\"]*\""),
+            string_format
+        ))
+
+        # Comments
+        comment_format = QTextCharFormat()
+        comment_format.setForeground(QColor("#777777"))  # Gray
+        comment_format.setFontItalic(True)
+        self.highlighting_rules.append((
+            QRegularExpression("--[^\n]*"),
+            comment_format
+        ))
+        
+        # Multi-line comments
+        self.comment_start_expression = QRegularExpression("/\\*")
+        self.comment_end_expression = QRegularExpression("\\*/")
+        self.multi_line_comment_format = comment_format
+
+    def highlightBlock(self, text):
+        # Apply regular expression highlighting rules
+        for pattern, format in self.highlighting_rules:
+            match_iterator = pattern.globalMatch(text)
+            while match_iterator.hasNext():
+                match = match_iterator.next()
+                self.setFormat(match.capturedStart(), match.capturedLength(), format)
+
+        # Handle multi-line comments
+        self.setCurrentBlockState(0)
+        
+        # If previous block was inside a comment, check if this block continues it
+        start_index = 0
+        if self.previousBlockState() != 1:
+            # Find the start of a comment
+            start_match = self.comment_start_expression.match(text)
+            if start_match.hasMatch():
+                start_index = start_match.capturedStart()
+            else:
+                return
+            
+        while start_index >= 0:
+            # Find the end of the comment
+            end_match = self.comment_end_expression.match(text, start_index)
+            
+            # If end match found
+            if end_match.hasMatch():
+                end_index = end_match.capturedStart()
+                comment_length = end_index - start_index + end_match.capturedLength()
+                self.setFormat(start_index, comment_length, self.multi_line_comment_format)
+                
+                # Look for next comment
+                start_match = self.comment_start_expression.match(text, start_index + comment_length)
+                if start_match.hasMatch():
+                    start_index = start_match.capturedStart()
+                else:
+                    start_index = -1
+            else:
+                # No end found, comment continues to next block
+                self.setCurrentBlockState(1)  # Still inside comment
+                comment_length = len(text) - start_index
+                self.setFormat(start_index, comment_length, self.multi_line_comment_format)
+                start_index = -1 

sqlshell-0.1.8.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,21 @@
+sqlshell/__init__.py,sha256=DqhqqdKdvfwO2iUG1Yd7WPmInpG-OcGhqP8LgblopgI,164
+sqlshell/create_test_data.py,sha256=AzrEsKlZsR1H1Xlp7IKOzWQ2N6FsVISJbc6CerI8IJ0,1954
+sqlshell/editor.py,sha256=4252dxINzJd1jr7CqgSI6IxUYHdkZ1OGZ1qBYN5-MKM,14396
+sqlshell/main.py,sha256=0eQlAQnRkFV14Ot8vJikG7Vq_zkSAqqohu50Y8UREyQ,75480
+sqlshell/setup.py,sha256=bAIXTpgAHhBRmPdT13Klzq16cjd4w4NOYSbyV_rxjlQ,1245
+sqlshell/splash_screen.py,sha256=XkXvSURgQzZfxJvP231Ue4J2E49ph21tWbvfGU03Ogk,6914
+sqlshell/sqlshell_demo.png,sha256=dPp9J1FVqQVfrh-gekosuha2Jw2p2--wxbOmt2kr7fg,133550
+sqlshell/syntax_highlighter.py,sha256=mPwsD8N4XzAUx0IgwlelyfjUhe0xmH0Ug3UI9hTcHz0,5861
+sqlshell/data/create_test_data.py,sha256=sUTcf50V8-bVwYV2VNTLK65c-iHiU4wb99By67I10zM,5404
+sqlshell/resources/__init__.py,sha256=VLTJ_5pUHhctRiV8UZDvG-jnsjgT6JQvW-ZPzIJqBIY,44
+sqlshell/resources/create_icon.py,sha256=ubNYyBYx5HtYpV8eiGY8Fb1VWUoQt-npaqUckiCimnQ,2030
+sqlshell/resources/create_splash.py,sha256=cj6BpMtD1crBkcSxt-ssJIFIZv43UDqLME8FF0fgkoA,2104
+sqlshell/resources/splash_screen.gif,sha256=H24DQBdK1EsqQTWZkgInjM5ouOzY4cMesUoza10auNg,3070484
+sqlshell/sqlshell/__init__.py,sha256=6Wp5nabfTzH5rkC-2jYo_ZjCuw8utmj21Jpy8vBuliI,100
+sqlshell/sqlshell/create_test_data.py,sha256=TFXgWeK1l3l_c4Dg38yS8Df4sBUfOZcBucXngtpThvk,4624
+sqlshell/sqlshell/create_test_databases.py,sha256=oqryFJJahqLFsAjBFM4r9Fe1ea7djDcRpT9U_aBf7PU,3573
+sqlshell-0.1.8.dist-info/METADATA,sha256=bIt-ocCENwgCT7ZxBMOUOaABM0PWonDQ7x2rYy2j2fU,3323
+sqlshell-0.1.8.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+sqlshell-0.1.8.dist-info/entry_points.txt,sha256=Kd0fOvyOW7UiTgTVY7abVOmDIH2Y2nawGTp5kVadac4,44
+sqlshell-0.1.8.dist-info/top_level.txt,sha256=ahwsMFhvAqI97ZkT2xvHL5iZCO1p13mNiUOFkdSFwms,9
+sqlshell-0.1.8.dist-info/RECORD,,

{sqlshell-0.1.6.dist-info → sqlshell-0.1.8.dist-info}/WHEEL

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