linux-copycache 1.0.1__tar.gz

linux_copycache-1.0.1/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: linux-copycache
+Version: 1.0.1
+Summary: A lightweight, fast, and reliable clipboard manager for Linux (Ubuntu) mimicking Win+V.
+Home-page: https://github.com/randhana/linux-clipboard-manager
+Author: Pulathisi Kariyawasam
+Author-email: pulathisi.kariyawasam@gmail.com
+Project-URL: Bug Tracker, https://github.com/randhana/linux-clipboard-manager/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: X11 Applications :: Qt
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6>=6.4.0
+Requires-Dist: pyperclip>=1.8.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Linux Clipboard Manager
+
+A lightweight, local-only clipboard manager for Linux built with Python and PyQt6.
+
+## Features
+- Background daemon to monitor clipboard history.
+- Popup GUI to browse and search previous items.
+- Auto-paste integration with `xdotool` (X11) or `wtype` (Wayland).
+
+## Prerequisites
+- **Python 3**
+- **xdotool** (for X11 users) or **wtype** (for Wayland users)
+
+You can install `wtype` or `xdotool` on Ubuntu using:
+```bash
+sudo apt install xdotool wtype
+```
+
+## Installation
+You can install the Clipboard Manager easily via `pip`:
+```bash
+pip install linux-clipboard-manager
+```
+
+### System Dependencies
+The auto-pasting functionality requires `xdotool` and `xclip` to be installed on your system.
+```bash
+sudo apt install xdotool xclip
+```
+
+## Running the tool
+Once installed, you can start the application from anywhere in your terminal:
+```bash
+linux-clipboard
+```
+The application will launch, dock itself to your system tray, and quietly monitor your copied text!
+
+## Setting up the `Super+V` (Win+V) Shortcut in Ubuntu
+For the native Windows experience, set up a custom shortcut:
+1. Open **Settings** -> **Keyboard**.
+2. Scroll to the bottom and click **View and Customize Shortcuts**.
+3. Select **Custom Shortcuts** and click the **+** or **Add Shortcut** button.
+4. **Name:** `Clipboard Manager`
+5. **Command:** `linux-clipboard`
+6. **Shortcut:** Press `Super + V` (Windows key + V).
+7. Click **Add**.
+
+Now, whenever you press `Super + V`, the history window will pop up!

linux_copycache-1.0.1/README.md

@@ -0,0 +1,48 @@
+# Linux Clipboard Manager
+
+A lightweight, local-only clipboard manager for Linux built with Python and PyQt6.
+
+## Features
+- Background daemon to monitor clipboard history.
+- Popup GUI to browse and search previous items.
+- Auto-paste integration with `xdotool` (X11) or `wtype` (Wayland).
+
+## Prerequisites
+- **Python 3**
+- **xdotool** (for X11 users) or **wtype** (for Wayland users)
+
+You can install `wtype` or `xdotool` on Ubuntu using:
+```bash
+sudo apt install xdotool wtype
+```
+
+## Installation
+You can install the Clipboard Manager easily via `pip`:
+```bash
+pip install linux-clipboard-manager
+```
+
+### System Dependencies
+The auto-pasting functionality requires `xdotool` and `xclip` to be installed on your system.
+```bash
+sudo apt install xdotool xclip
+```
+
+## Running the tool
+Once installed, you can start the application from anywhere in your terminal:
+```bash
+linux-clipboard
+```
+The application will launch, dock itself to your system tray, and quietly monitor your copied text!
+
+## Setting up the `Super+V` (Win+V) Shortcut in Ubuntu
+For the native Windows experience, set up a custom shortcut:
+1. Open **Settings** -> **Keyboard**.
+2. Scroll to the bottom and click **View and Customize Shortcuts**.
+3. Select **Custom Shortcuts** and click the **+** or **Add Shortcut** button.
+4. **Name:** `Clipboard Manager`
+5. **Command:** `linux-clipboard`
+6. **Shortcut:** Press `Super + V` (Windows key + V).
+7. Click **Add**.
+
+Now, whenever you press `Super + V`, the history window will pop up!

linux_copycache-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

linux_copycache-1.0.1/setup.py

@@ -0,0 +1,36 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="linux-copycache",
+    version="1.0.1",
+    author="Pulathisi Kariyawasam",
+    author_email="pulathisi.kariyawasam@gmail.com",
+    description="A lightweight, fast, and reliable clipboard manager for Linux (Ubuntu) mimicking Win+V.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/randhana/linux-clipboard-manager",
+    project_urls={
+        "Bug Tracker": "https://github.com/randhana/linux-clipboard-manager/issues",
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX :: Linux",
+        "Environment :: X11 Applications :: Qt",
+    ],
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.8",
+    install_requires=[
+        "PyQt6>=6.4.0",
+        "pyperclip>=1.8.2",
+    ],
+    entry_points={
+        "console_scripts": [
+            "linux-clipboard=linux_clipboard_manager.clipboard_gui:main",
+        ],
+    },
+)

linux_copycache-1.0.1/src/linux_clipboard_manager/__init__.py

@@ -0,0 +1,5 @@
+"""
+Linux Clipboard Manager
+A lightweight PyQT6 based clipboard manager for linux.
+"""
+__version__ = "1.0.0"

linux_copycache-1.0.1/src/linux_clipboard_manager/clipboard_daemon.py

@@ -0,0 +1,34 @@
+import sys
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtGui import QClipboard
+import db
+
+class ClipboardDaemon:
+    def __init__(self, app):
+        self.app = app
+        self.clipboard = app.clipboard()
+        self.clipboard.dataChanged.connect(self.on_clipboard_change)
+        
+        # Store initial value
+        text = self.clipboard.text()
+        if text:
+            db.add_item(text)
+
+    def on_clipboard_change(self):
+        text = self.clipboard.text()
+        if text:
+            db.add_item(text)
+
+def main():
+    app = QApplication(sys.argv)
+    app.setQuitOnLastWindowClosed(False)
+    
+    # Initialize DB before starting
+    db.init_db()
+    
+    daemon = ClipboardDaemon(app)
+    print("Clipboard daemon started.")
+    sys.exit(app.exec())
+
+if __name__ == '__main__':
+    main()

linux_copycache-1.0.1/src/linux_clipboard_manager/clipboard_gui.py

@@ -0,0 +1,268 @@
+import sys
+import os
+import subprocess
+import time
+from PyQt6.QtWidgets import (
+    QApplication, QWidget, QVBoxLayout, QListWidget, QListWidgetItem, QLabel,
+    QSystemTrayIcon, QMenu
+)
+from PyQt6.QtCore import Qt, pyqtSignal, QTimer
+from PyQt6.QtGui import QFont, QKeyEvent, QIcon, QClipboard
+
+from . import db
+
+def simulate_paste():
+    # Wait a tiny bit for the GUI window to close and focus to return to previous window
+    time.sleep(0.1)
+    
+    session_type = os.environ.get('XDG_SESSION_TYPE', '').lower()
+    
+    try:
+        if session_type == 'wayland':
+            # wtype simulates keystrokes in Wayland
+            subprocess.run(['wtype', '-M', 'ctrl', '-k', 'v', '-m', 'ctrl'], check=False)
+            # fallback if wtype isn't installed: skip or try ydotool
+        else:
+            # X11 fallback
+            subprocess.run(['xdotool', 'key', 'ctrl+v'], check=False)
+    except FileNotFoundError:
+        print("wtype or xdotool not found. Auto-paste will not work.")
+
+class ClipboardGUI(QWidget):
+    def __init__(self):
+        super().__init__()
+        # Frameless, kept on top, and doesn't steal focus from other apps
+        self.setWindowFlags(
+            Qt.WindowType.FramelessWindowHint | 
+            Qt.WindowType.WindowStaysOnTopHint |
+            Qt.WindowType.Tool
+        )
+        self.resize(400, 500)
+        self.setStyleSheet("""
+            QWidget {
+                background-color: #1e1e2e;
+                color: #cdd6f4;
+                border: 1px solid #45475a;
+                border-radius: 8px;
+            }
+            QLabel {
+                padding: 10px;
+                font-weight: bold;
+                font-size: 14px;
+                background-color: #313244;
+                border-bottom: 1px solid #45475a;
+                border-top-left-radius: 8px;
+                border-top-right-radius: 8px;
+            }
+            QListWidget {
+                border: none;
+                outline: none;
+                margin: 5px;
+            }
+            QListWidget::item {
+                padding: 10px;
+                border-bottom: 1px solid #313244;
+            }
+            QListWidget::item:selected {
+                background-color: #89b4fa;
+                color: #1e1e2e;
+                border-radius: 4px;
+            }
+        """)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        title = QLabel("Clipboard History")
+        layout.addWidget(title)
+
+        self.list_widget = QListWidget()
+        font = QFont("Sans Serif", 11)
+        self.list_widget.setFont(font)
+        self.list_widget.itemClicked.connect(self.on_item_clicked)
+        self.list_widget.currentItemChanged.connect(self.on_current_item_changed)
+        self.load_items()
+
+        # Flag for tracking internal updates so we don't reload list
+        self.internal_clipboard_update_text = None
+        layout.addWidget(self.list_widget)
+
+        # Auto-hide timer
+        self.hide_timer = QTimer(self)
+        self.hide_timer.timeout.connect(self.hide)
+        self.hide_timer.setInterval(60000) # 1 minute of inactivity
+
+        # Add old_pos for window dragging
+        self.old_pos = None
+
+    def on_current_item_changed(self, current, previous):
+        if current:
+            self.reset_hide_timer()
+            content = current.data(Qt.ItemDataRole.UserRole)
+            self.internal_clipboard_update_text = content
+            
+            # Update clipboard silently
+            clipboard = QApplication.clipboard()
+            clipboard.setText(content, QClipboard.Mode.Clipboard)
+            if clipboard.supportsSelection():
+                clipboard.setText(content, QClipboard.Mode.Selection)
+            
+            import pyperclip
+            try:
+                pyperclip.copy(content)
+            except Exception:
+                pass
+
+    def mousePressEvent(self, event):
+        self.reset_hide_timer()
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.old_pos = event.globalPosition().toPoint()
+
+    def mouseMoveEvent(self, event):
+        self.reset_hide_timer()
+        if self.old_pos is not None:
+            delta = event.globalPosition().toPoint() - self.old_pos
+            self.move(self.pos() + delta)
+            self.old_pos = event.globalPosition().toPoint()
+
+    def mouseReleaseEvent(self, event):
+        self.reset_hide_timer()
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.old_pos = None
+
+    def on_clipboard_change(self):
+        text = self.clipboard.text()
+        if text:
+            db.add_item(text)
+            if self.isVisible():
+                self.load_items()
+
+    def showEvent(self, event):
+        self.reset_hide_timer()
+        self.load_items()
+        super().showEvent(event)
+
+    def reset_hide_timer(self):
+        if self.isVisible():
+            self.hide_timer.start()
+
+    def hideEvent(self, event):
+        self.hide_timer.stop()
+        super().hideEvent(event)
+
+    def load_items(self):
+        self.list_widget.clear()
+        items = db.get_items(50)
+        for item_id, content in items:
+            # Truncate content for display if too long, replace newlines
+            display_text = content.replace('\n', ' \N{RETURN SYMBOL} ')
+            if len(display_text) > 200:
+                display_text = display_text[:200] + "..."
+            
+            list_item = QListWidgetItem(display_text)
+            list_item.setData(Qt.ItemDataRole.UserRole, content)
+            self.list_widget.addItem(list_item)
+            
+        if self.list_widget.count() > 0:
+            self.list_widget.setCurrentRow(0)
+
+    def on_item_clicked(self, item):
+        self.perform_paste(item)
+
+    def keyPressEvent(self, event: QKeyEvent):
+        self.reset_hide_timer()
+        if event.key() == Qt.Key.Key_Escape:
+            self.hide()
+        elif event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
+            item = self.list_widget.currentItem()
+            if item:
+                self.perform_paste(item)
+        else:
+            super().keyPressEvent(event)
+
+    def perform_paste(self, item):
+        content = item.data(Qt.ItemDataRole.UserRole)
+        # Update DB to bring it to top
+        db.add_item(content)
+        
+        self.on_current_item_changed(item, None)
+        
+        # We no longer hide automatically or auto-paste natively here
+        # so the user can easily select multiple items and paste manually
+        # whenever they decide to switch back to their app.
+
+class ClipboardMonitor:
+    def __init__(self, clipboard, gui_instance):
+        self.clipboard = clipboard
+        self.gui = gui_instance
+        self.clipboard.dataChanged.connect(self.on_clipboard_change)
+        
+        # Initial save
+        text = self.clipboard.text()
+        if text:
+            db.add_item(text)
+
+    def on_clipboard_change(self):
+        text = self.clipboard.text()
+        if text:
+            # Ignore clipboard updates that were triggered by us selecting an item
+            if getattr(self.gui, 'internal_clipboard_update_text', None) == text:
+                return
+                
+            db.add_item(text)
+            if self.gui.isVisible():
+                self.gui.load_items()
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # Keep the application running even if the window is closed
+    app.setQuitOnLastWindowClosed(False)
+    
+    # Initialize DB in case GUI runs before daemon
+    db.init_db()
+    
+    gui = ClipboardGUI()
+    
+    # Initialize Clipboard Monitor
+    # we assign it to a variable so it doesn't get garbage collected
+    monitor = ClipboardMonitor(app.clipboard(), gui)
+    
+    # Setup System Tray Icon
+    # We use a standard system icon like 'edit-paste' or generic document
+    tray_icon = QSystemTrayIcon(QIcon.fromTheme('edit-paste'), app)
+    if not tray_icon.icon().isNull():
+        pass
+    else:
+        # Fallback to another standard icon if 'edit-paste' is not found
+        tray_icon = QSystemTrayIcon(QIcon.fromTheme('document-properties'), app)
+    
+    tray_icon.setToolTip("Clipboard Manager")
+    
+    # Create tray menu
+    menu = QMenu()
+    show_action = menu.addAction("Show History")
+    show_action.triggered.connect(gui.show)
+    quit_action = menu.addAction("Quit")
+    quit_action.triggered.connect(app.quit)
+    tray_icon.setContextMenu(menu)
+    
+    # Show window when clicking the tray icon
+    tray_icon.activated.connect(
+        lambda reason: gui.show() if reason == QSystemTrayIcon.ActivationReason.Trigger else None
+    )
+    
+    tray_icon.show()
+    
+    # Center on screen
+    screen_geometry = app.primaryScreen().geometry()
+    x = (screen_geometry.width() - gui.width()) // 2
+    y = (screen_geometry.height() - gui.height()) // 2
+    gui.move(x, y)
+    
+    gui.show()
+    sys.exit(app.exec())
+
+if __name__ == '__main__':
+    main()

linux_copycache-1.0.1/src/linux_clipboard_manager/db.py

@@ -0,0 +1,70 @@
+import sqlite3
+import os
+
+DB_PATH = os.path.expanduser('~/.local/share/clipboard_history.db')
+
+def get_connection():
+    # Ensure directory exists
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    return sqlite3.connect(DB_PATH)
+
+def init_db():
+    conn = get_connection()
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS clipboard_items (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            content TEXT UNIQUE NOT NULL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def add_item(content: str):
+    if not content or not content.strip():
+        return
+    
+    conn = get_connection()
+    cursor = conn.cursor()
+    # Insert or update timestamp if it already exists to bring it to top
+    cursor.execute('''
+        INSERT INTO clipboard_items (content, timestamp)
+        VALUES (?, CURRENT_TIMESTAMP)
+        ON CONFLICT(content) DO UPDATE SET timestamp = CURRENT_TIMESTAMP
+    ''', (content,))
+    conn.commit()
+    
+    # Keep only the latest 100 items to prevent db from growing indefinitely
+    cursor.execute('''
+        DELETE FROM clipboard_items 
+        WHERE id NOT IN (
+            SELECT id FROM clipboard_items 
+            ORDER BY timestamp DESC 
+            LIMIT 100
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def get_items(limit=50):
+    conn = get_connection()
+    cursor = conn.cursor()
+    cursor.execute('''
+        SELECT id, content FROM clipboard_items
+        ORDER BY timestamp DESC
+        LIMIT ?
+    ''', (limit,))
+    items = cursor.fetchall()
+    conn.close()
+    return items
+
+def delete_item(item_id: int):
+    conn = get_connection()
+    cursor = conn.cursor()
+    cursor.execute('DELETE FROM clipboard_items WHERE id = ?', (item_id,))
+    conn.commit()
+    conn.close()
+
+if __name__ == '__main__':
+    init_db()

linux_copycache-1.0.1/src/linux_copycache.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: linux-copycache
+Version: 1.0.1
+Summary: A lightweight, fast, and reliable clipboard manager for Linux (Ubuntu) mimicking Win+V.
+Home-page: https://github.com/randhana/linux-clipboard-manager
+Author: Pulathisi Kariyawasam
+Author-email: pulathisi.kariyawasam@gmail.com
+Project-URL: Bug Tracker, https://github.com/randhana/linux-clipboard-manager/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: X11 Applications :: Qt
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6>=6.4.0
+Requires-Dist: pyperclip>=1.8.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Linux Clipboard Manager
+
+A lightweight, local-only clipboard manager for Linux built with Python and PyQt6.
+
+## Features
+- Background daemon to monitor clipboard history.
+- Popup GUI to browse and search previous items.
+- Auto-paste integration with `xdotool` (X11) or `wtype` (Wayland).
+
+## Prerequisites
+- **Python 3**
+- **xdotool** (for X11 users) or **wtype** (for Wayland users)
+
+You can install `wtype` or `xdotool` on Ubuntu using:
+```bash
+sudo apt install xdotool wtype
+```
+
+## Installation
+You can install the Clipboard Manager easily via `pip`:
+```bash
+pip install linux-clipboard-manager
+```
+
+### System Dependencies
+The auto-pasting functionality requires `xdotool` and `xclip` to be installed on your system.
+```bash
+sudo apt install xdotool xclip
+```
+
+## Running the tool
+Once installed, you can start the application from anywhere in your terminal:
+```bash
+linux-clipboard
+```
+The application will launch, dock itself to your system tray, and quietly monitor your copied text!
+
+## Setting up the `Super+V` (Win+V) Shortcut in Ubuntu
+For the native Windows experience, set up a custom shortcut:
+1. Open **Settings** -> **Keyboard**.
+2. Scroll to the bottom and click **View and Customize Shortcuts**.
+3. Select **Custom Shortcuts** and click the **+** or **Add Shortcut** button.
+4. **Name:** `Clipboard Manager`
+5. **Command:** `linux-clipboard`
+6. **Shortcut:** Press `Super + V` (Windows key + V).
+7. Click **Add**.
+
+Now, whenever you press `Super + V`, the history window will pop up!

linux_copycache-1.0.1/src/linux_copycache.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+src/linux_clipboard_manager/__init__.py
+src/linux_clipboard_manager/clipboard_daemon.py
+src/linux_clipboard_manager/clipboard_gui.py
+src/linux_clipboard_manager/db.py
+src/linux_copycache.egg-info/PKG-INFO
+src/linux_copycache.egg-info/SOURCES.txt
+src/linux_copycache.egg-info/dependency_links.txt
+src/linux_copycache.egg-info/entry_points.txt
+src/linux_copycache.egg-info/requires.txt
+src/linux_copycache.egg-info/top_level.txt

linux_copycache-1.0.1/src/linux_copycache.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

linux_copycache-1.0.1/src/linux_copycache.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linux-clipboard = linux_clipboard_manager.clipboard_gui:main

linux_copycache-1.0.1/src/linux_copycache.egg-info/requires.txt

@@ -0,0 +1,2 @@
+PyQt6>=6.4.0
+pyperclip>=1.8.2

linux_copycache-1.0.1/src/linux_copycache.egg-info/top_level.txt

@@ -0,0 +1 @@
+linux_clipboard_manager