snip2text.py

import tkinter as tk
from tkinter import ttk, messagebox
from PIL import ImageGrab, Image
import pytesseract
import requests
import base64
import json
import io
import threading

# Configure pytesseract path if needed
# pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

# Configuration for Claude API
CLAUDE_API_ENDPOINT = "https://api.anthropic.com/v1/messages"
CLAUDE_API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
ANTHROPIC_VERSION = "2023-06-01"

class SnippetTool:
    def __init__(self, root):
        self.root = root
        self.root.title("Screen Snippet Tool")
        self.root.geometry("800x600")
        self.root.minsize(600, 400)

        # Style configuration
        self.style = ttk.Style()
        self.style.theme_use('clam')
        self.style.configure("TButton", padding=6, relief="flat", background="#ccc")
        self.style.configure("TLabel", padding=6)
        self.style.configure("TNotebook.Tab", padding=[12, 4])

        # Main container
        self.main_frame = ttk.Frame(root)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        # Create notebook for tabs
        self.notebook = ttk.Notebook(self.main_frame)
        self.notebook.pack(fill=tk.BOTH, expand=True)

        # Create tabs
        self.capture_tab = ttk.Frame(self.notebook)
        self.text_tab = ttk.Frame(self.notebook)
        self.analysis_tab = ttk.Frame(self.notebook)

        self.notebook.add(self.capture_tab, text="Capture")
        self.notebook.add(self.text_tab, text="OCR Text")
        self.notebook.add(self.analysis_tab, text="Claude Analysis")

        # Initialize tabs
        self.setup_capture_tab()
        self.setup_text_tab()
        self.setup_analysis_tab()

        # Status bar
        self.status = tk.StringVar()
        self.status.set("Ready")
        self.status_bar = ttk.Label(root, textvariable=self.status, relief="sunken", anchor='w')
        self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)

        # Store the latest capture
        self.current_image = None
        self.current_text = None

    def setup_capture_tab(self):
        # Instructions
        instruction_label = ttk.Label(
            self.capture_tab,
            text="Capture a region of your screen to extract text.\n"
                 "Press the button below and select the area to capture.",
            justify=tk.CENTER
        )
        instruction_label.pack(pady=20)

        # Capture button
        self.capture_button = ttk.Button(
            self.capture_tab,
            text="Capture Screen Region",
            command=self.start_capture
        )
        self.capture_button.pack(pady=10)

    def setup_text_tab(self):
        self.text_tab.columnconfigure(0, weight=1)
        self.text_tab.rowconfigure(1, weight=1)

        # Label
        ttk.Label(self.text_tab, text="Extracted Text:").grid(row=0, column=0, sticky='w', padx=10, pady=(10, 0))

        # Text area with scrollbar
        text_frame = ttk.Frame(self.text_tab)
        text_frame.grid(row=1, column=0, sticky='nsew', padx=10, pady=5)

        self.text_scrollbar = ttk.Scrollbar(text_frame)
        self.text_area = tk.Text(
            text_frame,
            wrap='word',
            yscrollcommand=self.text_scrollbar.set,
            font=("Segoe UI", 10)
        )
        self.text_scrollbar.config(command=self.text_area.yview)
        
        self.text_area.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        self.text_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        # Buttons
        button_frame = ttk.Frame(self.text_tab)
        button_frame.grid(row=2, column=0, pady=10)

        ttk.Button(
            button_frame,
            text="Copy to Clipboard",
            command=lambda: self.copy_to_clipboard(self.text_area.get("1.0", tk.END))
        ).pack(side=tk.LEFT, padx=5)

        ttk.Button(
            button_frame,
            text="Analyze with Claude",
            command=self.start_claude_analysis
        ).pack(side=tk.LEFT, padx=5)

        # Context menu
        self.setup_context_menu(self.text_area)

    def setup_analysis_tab(self):
        self.analysis_tab.columnconfigure(0, weight=1)
        self.analysis_tab.rowconfigure(1, weight=1)

        # Label
        ttk.Label(self.analysis_tab, text="Claude Analysis:").grid(row=0, column=0, sticky='w', padx=10, pady=(10, 0))

        # Analysis text area
        analysis_frame = ttk.Frame(self.analysis_tab)
        analysis_frame.grid(row=1, column=0, sticky='nsew', padx=10, pady=5)

        self.analysis_scrollbar = ttk.Scrollbar(analysis_frame)
        self.analysis_area = tk.Text(
            analysis_frame,
            wrap='word',
            yscrollcommand=self.analysis_scrollbar.set,
            font=("Segoe UI", 10)
        )
        self.analysis_scrollbar.config(command=self.analysis_area.yview)
        
        self.analysis_area.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        self.analysis_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        # Buttons
        button_frame = ttk.Frame(self.analysis_tab)
        button_frame.grid(row=2, column=0, pady=10)

        ttk.Button(
            button_frame,
            text="Copy to Clipboard",
            command=lambda: self.copy_to_clipboard(self.analysis_area.get("1.0", tk.END))
        ).pack(side=tk.LEFT, padx=5)

        # Context menu
        self.setup_context_menu(self.analysis_area)

    def setup_context_menu(self, widget):
        context_menu = tk.Menu(widget, tearoff=0)
        context_menu.add_command(
            label="Copy",
            command=lambda: self.copy_selection(widget)
        )

        widget.bind("<Button-3>", lambda e: context_menu.tk_popup(e.x_root, e.y_root))

    def copy_selection(self, widget):
        try:
            selection = widget.selection_get()
            self.root.clipboard_clear()
            self.root.clipboard_append(selection)
        except tk.TclError:
            pass

    def start_capture(self):
        self.root.withdraw()
        self.status.set("Preparing to capture...")
        self.root.after(500, self.select_region)

    def select_region(self):
        self.selection_window = tk.Toplevel(self.root)
        self.selection_window.attributes('-fullscreen', True, '-alpha', 0.3)
        self.selection_window.configure(background='black')

        self.canvas = tk.Canvas(self.selection_window, cursor="cross", bg="black")
        self.canvas.pack(fill=tk.BOTH, expand=True)

        self.start_x = self.start_y = self.rect = None

        self.canvas.bind("<ButtonPress-1>", self.on_mouse_down)
        self.canvas.bind("<B1-Motion>", self.on_mouse_drag)
        self.canvas.bind("<ButtonRelease-1>", self.on_mouse_up)

    def on_mouse_down(self, event):
        self.start_x = self.canvas.canvasx(event.x)
        self.start_y = self.canvas.canvasy(event.y)
        self.rect = self.canvas.create_rectangle(
            self.start_x, self.start_y, self.start_x, self.start_y,
            outline='red', width=2
        )

    def on_mouse_drag(self, event):
        cur_x, cur_y = (self.canvas.canvasx(event.x), self.canvas.canvasy(event.y))
        self.canvas.coords(self.rect, self.start_x, self.start_y, cur_x, cur_y)

    def on_mouse_up(self, event):
        self.end_x = self.canvas.canvasx(event.x)
        self.end_y = self.canvas.canvasy(event.y)
        self.selection_window.destroy()
        self.capture_region()

    def capture_region(self):
        self.status.set("Capturing screen region...")
        x1, y1 = min(self.start_x, self.end_x), min(self.start_y, self.end_y)
        x2, y2 = max(self.start_x, self.end_x), max(self.start_y, self.end_y)

        try:
            self.current_image = ImageGrab.grab(bbox=(x1, y1, x2, y2))
            
            self.status.set("Performing OCR...")
            self.current_text = pytesseract.image_to_string(self.current_image)

            # Update text tab
            self.text_area.config(state=tk.NORMAL)
            self.text_area.delete(1.0, tk.END)
            self.text_area.insert(tk.END, self.current_text)
            self.text_area.config(state=tk.DISABLED)

            # Switch to text tab
            self.notebook.select(1)

            # Copy to clipboard
            self.root.clipboard_clear()
            self.root.clipboard_append(self.current_text)

        except Exception as e:
            messagebox.showerror("Error", f"An error occurred: {e}")
            self.status.set("Error occurred.")
        finally:
            self.root.deiconify()
            self.status.set("Ready")

    def copy_to_clipboard(self, text):
        self.root.clipboard_clear()
        self.root.clipboard_append(text)
        messagebox.showinfo("Copied", "Text has been copied to the clipboard.")

    def start_claude_analysis(self):
        if not self.current_image:
            messagebox.showwarning("No Image", "Please capture an image first.")
            return
            
        proceed = messagebox.askyesno(
            "Claude Analysis",
            "Do you want to analyze the captured image with Claude for further insights?"
        )
        if proceed:
            self.status.set("Analyzing with Claude...")
            thread = threading.Thread(target=self.analyze_with_claude, daemon=True)
            thread.start()

    def analyze_with_claude(self):
        try:
            # Convert image to base64
            buffered = io.BytesIO()
            self.current_image.save(buffered, format="PNG")
            img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")

            # Prepare the data payload
            data = {
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "text",
                                "text": "Extract all visible text from this image exactly as it appears, including punctuation and line breaks. Do not add any analysis, interpretation, or comments—only provide the raw text."
                            },
                            {
                                "type": "image",
                                "source": {
                                    "type": "base64",
                                    "media_type": "image/png",
                                    "data": img_base64
                                }
                            }
                        ]
                    }
                ],
                "model": "claude-3-5-sonnet-20240620",
                "max_tokens": 4096
            }

            headers = {
                "Content-Type": "application/json",
                "x-api-key": CLAUDE_API_KEY,
                "anthropic-version": ANTHROPIC_VERSION
            }

            response = requests.post(CLAUDE_API_ENDPOINT, headers=headers, json=data, timeout=60)
            response.raise_for_status()
            response_json = response.json()

            # Extract analysis text
            if 'content' in response_json and isinstance(response_json['content'], list):
                analysis_text = ""
                for message in response_json['content']:
                    if 'text' in message:
                        analysis_text += message['text'] + "\n"
            else:
                analysis_text = "No analysis provided."

            # Update analysis tab
            self.analysis_area.config(state=tk.NORMAL)
            self.analysis_area.delete(1.0, tk.END)
            self.analysis_area.insert(tk.END, analysis_text)
            self.analysis_area.config(state=tk.DISABLED)

            # Switch to analysis tab
            self.notebook.select(2)

        except Exception as e:
            messagebox.showerror("Error", f"An error occurred while communicating with Claude API:\n{e}")
        finally:
            self.status.set("Ready")

if __name__ == "__main__":
    root = tk.Tk()
    app = SnippetTool(root)
    root.mainloop()