sqlbench 0.1.1__tar.gz → 0.1.2__tar.gz

{sqlbench-0.1.1 → sqlbench-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbench
-Version: 0.1.1
+Version: 0.1.2
 Summary: A multi-database SQL workbench with support for IBM i, MySQL, and PostgreSQL
 Project-URL: Homepage, https://github.com/jpsteil/sqlbench
 Project-URL: Repository, https://github.com/jpsteil/sqlbench

{sqlbench-0.1.1 → sqlbench-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbench"
-version = "0.1.1"
+version = "0.1.2"
 description = "A multi-database SQL workbench with support for IBM i, MySQL, and PostgreSQL"
 readme = "README.md"
 license = "MIT"
@@ -60,6 +60,7 @@ Issues = "https://github.com/jpsteil/sqlbench/issues"
 
 [tool.hatch.build.targets.wheel]
 packages = ["sqlbench"]
+include = ["sqlbench/resources/*"]
 
 [tool.ruff]
 line-length = 100

sqlbench-0.1.2/sqlbench/__main__.py

@@ -0,0 +1,40 @@
+"""Entry point for sqlbench."""
+
+import sys
+
+
+def main():
+    """Main entry point with argument handling."""
+    if len(sys.argv) > 1:
+        arg = sys.argv[1].lower()
+
+        if arg in ("--install-launcher", "--create-launcher"):
+            from sqlbench.launcher import create_launcher
+            success = create_launcher()
+            sys.exit(0 if success else 1)
+
+        elif arg in ("--remove-launcher", "--uninstall-launcher"):
+            from sqlbench.launcher import remove_launcher
+            success = remove_launcher()
+            sys.exit(0 if success else 1)
+
+        elif arg in ("--help", "-h"):
+            print("SQLBench - Multi-database SQL Workbench")
+            print()
+            print("Usage: sqlbench [options]")
+            print()
+            print("Options:")
+            print("  --install-launcher   Create a desktop launcher for this OS")
+            print("  --remove-launcher    Remove the desktop launcher")
+            print("  --help, -h           Show this help message")
+            print()
+            print("Run without arguments to start the application.")
+            sys.exit(0)
+
+    # Start the GUI application
+    from sqlbench.app import main as app_main
+    app_main()
+
+
+if __name__ == "__main__":
+    main()

{sqlbench-0.1.1 → sqlbench-0.1.2}/sqlbench/app.py

@@ -41,6 +41,9 @@ class SQLBenchApp:
         # Restore last connection and tabs after UI is ready
         self.root.after(100, self._restore_session)
 
+        # Check for updates in background
+        self.root.after(500, self._check_for_updates)
+
     def _create_menu(self):
         menubar = tk.Menu(self.root)
         self.root.config(menu=menubar)
@@ -939,8 +942,112 @@ class SQLBenchApp:
                 self.db.delete_connection(conn["id"])
             self._refresh_connections()
 
+    def _install_launcher(self):
+        """Install desktop launcher for the current OS."""
+        from sqlbench.launcher import create_launcher
+        try:
+            success = create_launcher()
+            if success:
+                tk.messagebox.showinfo(
+                    "Launcher Installed",
+                    "Desktop launcher installed successfully.\n\n"
+                    "You may need to log out and back in for it to appear in your application menu."
+                )
+            else:
+                tk.messagebox.showwarning(
+                    "Installation Failed",
+                    "Could not install desktop launcher for this operating system."
+                )
+        except Exception as e:
+            tk.messagebox.showerror("Error", f"Failed to install launcher:\n{e}")
+
+    def _remove_launcher(self):
+        """Remove desktop launcher for the current OS."""
+        from sqlbench.launcher import remove_launcher
+        try:
+            success = remove_launcher()
+            if success:
+                tk.messagebox.showinfo(
+                    "Launcher Removed",
+                    "Desktop launcher removed successfully."
+                )
+            else:
+                tk.messagebox.showinfo(
+                    "No Launcher Found",
+                    "No desktop launcher was found to remove."
+                )
+        except Exception as e:
+            tk.messagebox.showerror("Error", f"Failed to remove launcher:\n{e}")
+
+    def _check_for_updates(self):
+        """Check for updates in background."""
+        from sqlbench.version import check_for_updates, __version__
+
+        def on_update_check(has_update, latest_version):
+            if has_update:
+                self.root.after(0, lambda: self._show_update_dialog(latest_version))
+
+        check_for_updates(on_update_check)
+
+    def _show_update_dialog(self, latest_version):
+        """Show update available dialog."""
+        from sqlbench.version import __version__
+
+        result = tk.messagebox.askyesno(
+            "Update Available",
+            f"A new version of SQLBench is available.\n\n"
+            f"Installed: {__version__}\n"
+            f"Latest: {latest_version}\n\n"
+            f"Would you like to upgrade now?\n\n"
+            f"(This will run: pipx upgrade sqlbench)"
+        )
+
+        if result:
+            self._run_upgrade()
+
+    def _run_upgrade(self):
+        """Run pipx upgrade in background."""
+        import subprocess
+        import threading
+
+        def do_upgrade():
+            try:
+                result = subprocess.run(
+                    ["pipx", "upgrade", "sqlbench"],
+                    capture_output=True,
+                    text=True
+                )
+                if result.returncode == 0:
+                    self.root.after(0, lambda: tk.messagebox.showinfo(
+                        "Upgrade Complete",
+                        "SQLBench has been upgraded.\n\n"
+                        "Please restart the application to use the new version."
+                    ))
+                else:
+                    error = result.stderr or result.stdout or "Unknown error"
+                    self.root.after(0, lambda: tk.messagebox.showerror(
+                        "Upgrade Failed",
+                        f"Failed to upgrade:\n{error}"
+                    ))
+            except FileNotFoundError:
+                self.root.after(0, lambda: tk.messagebox.showerror(
+                    "Upgrade Failed",
+                    "pipx not found. Please upgrade manually:\n\n"
+                    "pipx upgrade sqlbench"
+                ))
+            except Exception as e:
+                self.root.after(0, lambda: tk.messagebox.showerror(
+                    "Upgrade Failed",
+                    f"Failed to upgrade:\n{e}"
+                ))
+
+        self.statusbar.config(text="Upgrading SQLBench...")
+        thread = threading.Thread(target=do_upgrade, daemon=True)
+        thread.start()
+
     def _show_about(self):
-        tk.messagebox.showinfo("About", "IBM i Utility\nVersion 0.2")
+        from sqlbench.version import __version__
+        tk.messagebox.showinfo("About", f"SQLBench v{__version__}\nMulti-database SQL Workbench")
 
     def _show_settings(self):
         """Show settings dialog."""
@@ -950,10 +1057,10 @@ class SQLBenchApp:
         settings_win.grab_set()
 
         # Center on parent
-        settings_win.geometry("300x150")
+        settings_win.geometry("350x200")
         settings_win.update_idletasks()
-        x = self.root.winfo_x() + (self.root.winfo_width() - 300) // 2
-        y = self.root.winfo_y() + (self.root.winfo_height() - 150) // 2
+        x = self.root.winfo_x() + (self.root.winfo_width() - 350) // 2
+        y = self.root.winfo_y() + (self.root.winfo_height() - 200) // 2
         settings_win.geometry(f"+{x}+{y}")
 
         # Apply dark mode
@@ -968,7 +1075,7 @@ class SQLBenchApp:
 
         # Font size setting
         font_frame = ttk.Frame(settings_win)
-        font_frame.pack(fill=tk.X, padx=20, pady=20)
+        font_frame.pack(fill=tk.X, padx=20, pady=(20, 10))
 
         ttk.Label(font_frame, text="Font Size:").pack(side=tk.LEFT)
 
@@ -977,6 +1084,16 @@ class SQLBenchApp:
                                 textvariable=font_size_var)
         font_spin.pack(side=tk.LEFT, padx=(10, 0))
 
+        # Desktop launcher
+        launcher_frame = ttk.Frame(settings_win)
+        launcher_frame.pack(fill=tk.X, padx=20, pady=10)
+
+        ttk.Label(launcher_frame, text="Desktop:").pack(side=tk.LEFT)
+        ttk.Button(launcher_frame, text="Install Launcher",
+                   command=self._install_launcher).pack(side=tk.LEFT, padx=(10, 0))
+        ttk.Button(launcher_frame, text="Remove Launcher",
+                   command=self._remove_launcher).pack(side=tk.LEFT, padx=(5, 0))
+
         # Buttons
         btn_frame = ttk.Frame(settings_win)
         btn_frame.pack(fill=tk.X, padx=20, pady=10)

sqlbench-0.1.2/sqlbench/launcher.py

@@ -0,0 +1,278 @@
+"""Desktop launcher creation for SQLBench."""
+
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+
+
+def get_executable_path():
+    """Get the path to the sqlbench executable."""
+    # When installed via pipx, the executable is in the PATH
+    return shutil.which("sqlbench") or sys.executable
+
+
+def get_icon_path():
+    """Get the path to the bundled icon."""
+    # Icon is in the resources subdirectory of the package
+    package_dir = Path(__file__).parent
+    return package_dir / "resources" / "sqlbench.png"
+
+
+def install_icon_linux():
+    """Install the icon to the standard Linux icon location."""
+    icon_source = get_icon_path()
+    if not icon_source.exists():
+        print(f"Warning: Icon not found at {icon_source}")
+        return None
+
+    # Install to user's icon directory
+    icon_dir = Path.home() / ".local" / "share" / "icons" / "hicolor" / "256x256" / "apps"
+    icon_dir.mkdir(parents=True, exist_ok=True)
+
+    icon_dest = icon_dir / "sqlbench.png"
+    shutil.copy2(icon_source, icon_dest)
+
+    # Update icon cache (optional, may not work without root)
+    try:
+        os.system("gtk-update-icon-cache -f -t ~/.local/share/icons/hicolor 2>/dev/null")
+    except Exception:
+        pass
+
+    return "sqlbench"  # Return icon name for .desktop file
+
+
+def create_linux_launcher():
+    """Create a .desktop file for Linux."""
+    desktop_dir = os.path.expanduser("~/.local/share/applications")
+    os.makedirs(desktop_dir, exist_ok=True)
+
+    desktop_file = os.path.join(desktop_dir, "sqlbench.desktop")
+
+    # Get executable path
+    exec_path = shutil.which("sqlbench")
+    if not exec_path:
+        # Fallback to python -m sqlbench
+        exec_path = f"{sys.executable} -m sqlbench"
+
+    # Install icon and get icon name/path
+    icon_name = install_icon_linux()
+    if not icon_name:
+        # Fallback to bundled icon path or generic icon
+        icon_path = get_icon_path()
+        icon_name = str(icon_path) if icon_path.exists() else "utilities-terminal"
+
+    content = f"""[Desktop Entry]
+Name=SQLBench
+Comment=Multi-database SQL Workbench
+Exec={exec_path}
+Icon={icon_name}
+Type=Application
+Categories=Development;Database;
+Terminal=false
+StartupWMClass=sqlbench
+"""
+
+    with open(desktop_file, "w") as f:
+        f.write(content)
+
+    # Make executable
+    os.chmod(desktop_file, 0o755)
+
+    print(f"Created Linux desktop launcher: {desktop_file}")
+    print("Icon installed to ~/.local/share/icons/hicolor/256x256/apps/sqlbench.png")
+    print("You may need to log out and back in for it to appear in your application menu.")
+    return True
+
+
+def create_macos_launcher():
+    """Create an application launcher for macOS."""
+    app_base = os.path.expanduser("~/Applications/SQLBench.app/Contents")
+    app_dir = os.path.join(app_base, "MacOS")
+    resources_dir = os.path.join(app_base, "Resources")
+    os.makedirs(app_dir, exist_ok=True)
+    os.makedirs(resources_dir, exist_ok=True)
+
+    # Get executable path
+    exec_path = shutil.which("sqlbench")
+    if not exec_path:
+        exec_path = f"{sys.executable} -m sqlbench"
+
+    # Create the launcher script
+    launcher_script = os.path.join(app_dir, "SQLBench")
+    content = f"""#!/bin/bash
+exec {exec_path}
+"""
+
+    with open(launcher_script, "w") as f:
+        f.write(content)
+    os.chmod(launcher_script, 0o755)
+
+    # Copy icon to Resources
+    icon_source = get_icon_path()
+    icon_dest = os.path.join(resources_dir, "sqlbench.png")
+    if icon_source.exists():
+        shutil.copy2(icon_source, icon_dest)
+        # Also try to create .icns for better macOS integration
+        # (PNG works but .icns is preferred)
+
+    # Create Info.plist
+    plist_file = os.path.join(app_base, "Info.plist")
+    plist_content = """<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>SQLBench</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.sqlbench.app</string>
+    <key>CFBundleName</key>
+    <string>SQLBench</string>
+    <key>CFBundleVersion</key>
+    <string>1.0</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleIconFile</key>
+    <string>sqlbench.png</string>
+</dict>
+</plist>
+"""
+
+    with open(plist_file, "w") as f:
+        f.write(plist_content)
+
+    print(f"Created macOS application: ~/Applications/SQLBench.app")
+    print("You can drag it to your Dock or find it in ~/Applications.")
+    return True
+
+
+def create_windows_launcher():
+    """Create a Start Menu shortcut for Windows."""
+    try:
+        import winreg
+        from pathlib import Path
+
+        # Get Start Menu path
+        start_menu = Path(os.environ.get("APPDATA", "")) / "Microsoft" / "Windows" / "Start Menu" / "Programs"
+
+        if not start_menu.exists():
+            print(f"Could not find Start Menu folder: {start_menu}")
+            return False
+
+        # Get executable path
+        exec_path = shutil.which("sqlbench.exe") or shutil.which("sqlbench")
+        if not exec_path:
+            exec_path = f'"{sys.executable}" -m sqlbench'
+
+        # Create .bat launcher (simpler than .lnk without pywin32)
+        bat_file = start_menu / "SQLBench.bat"
+        content = f"""@echo off
+start "" {exec_path}
+"""
+
+        with open(bat_file, "w") as f:
+            f.write(content)
+
+        print(f"Created Windows Start Menu launcher: {bat_file}")
+        print("You can find SQLBench in your Start Menu.")
+        return True
+
+    except Exception as e:
+        print(f"Failed to create Windows launcher: {e}")
+
+        # Fallback: create on Desktop
+        desktop = os.path.expanduser("~/Desktop")
+        if os.path.exists(desktop):
+            exec_path = shutil.which("sqlbench.exe") or shutil.which("sqlbench")
+            if not exec_path:
+                exec_path = f'"{sys.executable}" -m sqlbench'
+
+            bat_file = os.path.join(desktop, "SQLBench.bat")
+            content = f"""@echo off
+start "" {exec_path}
+"""
+            with open(bat_file, "w") as f:
+                f.write(content)
+
+            print(f"Created Desktop launcher instead: {bat_file}")
+            return True
+
+        return False
+
+
+def create_launcher():
+    """Create a desktop launcher appropriate for the current OS."""
+    system = platform.system().lower()
+
+    print(f"Detected OS: {platform.system()}")
+
+    if system == "linux":
+        return create_linux_launcher()
+    elif system == "darwin":
+        return create_macos_launcher()
+    elif system == "windows":
+        return create_windows_launcher()
+    else:
+        print(f"Unsupported operating system: {system}")
+        return False
+
+
+def remove_launcher():
+    """Remove the desktop launcher for the current OS."""
+    system = platform.system().lower()
+
+    if system == "linux":
+        removed = False
+        desktop_file = os.path.expanduser("~/.local/share/applications/sqlbench.desktop")
+        if os.path.exists(desktop_file):
+            os.remove(desktop_file)
+            print(f"Removed: {desktop_file}")
+            removed = True
+
+        # Also remove the icon
+        icon_file = os.path.expanduser("~/.local/share/icons/hicolor/256x256/apps/sqlbench.png")
+        if os.path.exists(icon_file):
+            os.remove(icon_file)
+            print(f"Removed: {icon_file}")
+            removed = True
+
+        if not removed:
+            print("No Linux launcher found.")
+            return False
+        return True
+
+    elif system == "darwin":
+        app_dir = os.path.expanduser("~/Applications/SQLBench.app")
+        if os.path.exists(app_dir):
+            shutil.rmtree(app_dir)
+            print(f"Removed: {app_dir}")
+            return True
+        else:
+            print("No macOS launcher found.")
+            return False
+
+    elif system == "windows":
+        start_menu = os.path.join(
+            os.environ.get("APPDATA", ""),
+            "Microsoft", "Windows", "Start Menu", "Programs", "SQLBench.bat"
+        )
+        desktop = os.path.expanduser("~/Desktop/SQLBench.bat")
+
+        removed = False
+        if os.path.exists(start_menu):
+            os.remove(start_menu)
+            print(f"Removed: {start_menu}")
+            removed = True
+        if os.path.exists(desktop):
+            os.remove(desktop)
+            print(f"Removed: {desktop}")
+            removed = True
+
+        if not removed:
+            print("No Windows launcher found.")
+        return removed
+
+    else:
+        print(f"Unsupported operating system: {system}")
+        return False

sqlbench-0.1.2/sqlbench/version.py

@@ -0,0 +1,57 @@
+"""Version checking for SQLBench."""
+
+import threading
+import urllib.request
+import json
+
+__version__ = "0.1.2"
+
+
+def get_installed_version():
+    """Get the currently installed version."""
+    return __version__
+
+
+def get_pypi_version():
+    """Fetch the latest version from PyPI."""
+    try:
+        url = "https://pypi.org/pypi/sqlbench/json"
+        with urllib.request.urlopen(url, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return data["info"]["version"]
+    except Exception:
+        return None
+
+
+def parse_version(version_str):
+    """Parse version string into tuple for comparison."""
+    try:
+        parts = version_str.split(".")
+        return tuple(int(p) for p in parts)
+    except (ValueError, AttributeError):
+        return (0, 0, 0)
+
+
+def is_newer_version(pypi_version, installed_version):
+    """Check if PyPI version is newer than installed version."""
+    return parse_version(pypi_version) > parse_version(installed_version)
+
+
+def check_for_updates(callback):
+    """Check for updates in background thread.
+
+    Args:
+        callback: Function to call with (has_update, latest_version) or (False, None) on error
+    """
+    def do_check():
+        try:
+            latest = get_pypi_version()
+            if latest and is_newer_version(latest, __version__):
+                callback(True, latest)
+            else:
+                callback(False, latest)
+        except Exception:
+            callback(False, None)
+
+    thread = threading.Thread(target=do_check, daemon=True)
+    thread.start()

sqlbench-0.1.1/sqlbench/__main__.py

@@ -1,7 +0,0 @@
-"""Entry point for sqlbench."""
-
-from sqlbench.app import main
-
-
-if __name__ == "__main__":
-    main()