liveConsole 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

{liveconsole-1.4.0.dist-info → liveconsole-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liveConsole
-Version: 1.4.0
+Version: 1.5.0
 Summary: An IDLE-like debugger to allow for real-time command injection for debugging and testing python code
 Author-email: Tzur Soffer <tzur.soffer@gmail.com>
 License: MIT
@@ -11,9 +11,10 @@ Requires-Dist: customtkinter
 Requires-Dist: pygments
 Dynamic: license-file
 
-# Live Interactive Python Console
+# PYSOLE
 
 ## You can finally test your code in real time without using idle!
+### If you found [this repository](https://github.com/TzurSoffer/LiveDebugger) useful, please give it a ⭐!.
 
 A fully-featured, **live Python console GUI** built with **CustomTkinter** and **Tkinter**, featuring:
 
@@ -27,7 +28,10 @@ A fully-featured, **live Python console GUI** built with **CustomTkinter** and *
     
 *   Multi-line input with auto-indentation
     
-*   Clickable history of previous commands
+*   History of previous commands
+
+* **Integrated Help Panel** for quick access to Python object documentation
+
 
 ## Installation
 
@@ -77,6 +81,17 @@ A fully-featured, **live Python console GUI** built with **CustomTkinter** and *
 *   Click to copy them back to the prompt for editing or re-execution.
     
 
+### Help Panel
+
+*   A resizable right-hand panel that displays Python documentation (help()) for any object.
+
+*   Opens when clicking ctrl+click on a function/method and can be closed with the "X" button.
+
+*   Scrollable and syntax-styled.
+
+*   Perfect for quick reference without leaving the console.
+
+
 ### Easy Integration
 
 *   Automatically grabs **caller frame globals and locals** if not provided.
@@ -86,8 +101,8 @@ A fully-featured, **live Python console GUI** built with **CustomTkinter** and *
 ## Usage
 
 ```
-from liveConsole import InteractiveConsole
-InteractiveConsole().probe()
+import pysole
+pysole.probe()
 ```
 
 *   Type Python commands in the `>>>` prompt and see live output.

liveconsole-1.5.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+__init__.py,sha256=YbwIrtllO_QzxGjBzZfQp45oA2xI0sU9mXRyCq28wVE,44
+commandHistory.py,sha256=xJtWbJ_vgJo2QGgaZJsApTOi_Hm8Yz0V9_zqQUCItj8,1084
+helpTab.py,sha256=5Fxj_wTNTbuF6sBIN8GdbE6i_zbAEdlrFnbfhnDk5ms,2360
+liveConsole.py,sha256=dqYaCvBs_aDfqrbhXYBp5vLkksmAiUv0DWwsbu1R3B4,167
+mainConsole.py,sha256=MxgJJihgbPtKZ8FqXSFczj5neRVGRiM8RX4lcm0ewk0,12973
+pysole.py,sha256=WFN08BWn9qyhwM7IAa51kCqsYVnuNXVDb1zfv2xw-NE,3924
+styledTextbox.py,sha256=pc-7gaq_pGTZGZmtr_ARbPuKlKgJYqzD6HTR7tFhx7k,1989
+suggestionManager.py,sha256=GRde3c1gFAWt_3rvBoFt_-Xl0aOzzloBMD7MHJA2W8U,6256
+liveconsole-1.5.0.dist-info/licenses/LICENSE,sha256=7dZ0zL72aGaFE0C9DxacOpnaSkC5jajhG6iL7lqhWmU,1064
+liveconsole-1.5.0.dist-info/METADATA,sha256=YLJyN0amuDNkmjan5MvPum-Dz-w04AeNt0lPI7kOS9Y,3681
+liveconsole-1.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+liveconsole-1.5.0.dist-info/entry_points.txt,sha256=IxAXIuGYHQpRflT9VoCLq1eZ3fOXrY_azhk8hcl8eGY,49
+liveconsole-1.5.0.dist-info/top_level.txt,sha256=yEmcEVam34LgZbQWtT6RdrdJVzsXwElx6Wpsn3eR2as,95
+liveconsole-1.5.0.dist-info/RECORD,,

liveconsole-1.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+liveconsole = liveConsole:main

liveconsole-1.5.0.dist-info/top_level.txt

@@ -0,0 +1,8 @@
+__init__
+commandHistory
+helpTab
+liveConsole
+mainConsole
+pysole
+styledTextbox
+suggestionManager

mainConsole.py

@@ -0,0 +1,354 @@
+import threading
+import traceback
+from suggestionManager import CodeSuggestionManager
+from commandHistory import CommandHistory
+from styledTextbox import StyledTextWindow
+
+import tkinter as tk
+
+class InteractiveConsoleText(StyledTextWindow):
+    """TBD"""
+    
+    PROMPT = ">>> "
+    PROMPT_LENGTH = 4
+    
+    def __init__(self, master, helpTab, userLocals=None, userGlobals=None, **kwargs):
+        super().__init__(master, **kwargs)
+        
+        # Initialize components
+        self.suggestionManager = CodeSuggestionManager(self, userLocals=userLocals, userGlobals=userGlobals)
+        self.helpTab = helpTab
+        
+        self.navigatingHistory = False
+        self.history = CommandHistory()
+        
+        self.inputVar = tk.StringVar()
+        self.waitingForInput = False
+
+        # Track current command
+        self.currentCommandLine = 1
+        self.isExecuting = False
+        
+        # Setup bindings
+        self._setupBindings()
+        
+        # Initialize with first prompt
+        self.addPrompt()
+
+    def _setupBindings(self):
+        """Setup all key and mouse bindings."""
+        self.bind("<Return>", self.onEnter)
+        self.bind("<Shift-Return>", self.onShiftEnter)
+        self.bind("<Control-c>", self.cancel)
+        self.bind("<Tab>", self.onTab)
+        self.bind("<BackSpace>", self.onBackspace)
+        self.bind("<KeyRelease>", self.onKeyRelease)
+        self.bind("<KeyPress>", self.onKeyPress)
+        self.bind("<Button-1>", self.onClick)
+        self.bind("<Up>", self.onUp)
+        self.bind("<Down>", self.onDown)
+
+    def getCurrentLineNumber(self):
+        """Get the line number where current command starts."""
+        return(int(self.index("end-1c").split(".")[0]))
+    
+    def getCommandStartPosition(self):
+        """Get the starting position of the current command."""
+        return(f"{self.currentCommandLine}.0")
+    
+    def replaceCurrentCommand(self, newCommand):
+        """Replace the current command with new text."""
+        if self.isExecuting:
+            return
+        
+        start = self.getPromptPosition()
+        end = "end-1c"
+        
+        self.delete(start, end)
+        self.insert(start, newCommand)
+        self.see("end")
+    
+    def isCursorInEditableArea(self):
+        """Check if cursor is in the editable command area."""
+        if self.isExecuting:
+            return(False)
+        
+        cursorLine = int(self.index("insert").split(".")[0])
+        cursorCol = int(self.index("insert").split(".")[1])
+        
+        return((cursorLine >= self.currentCommandLine and 
+                (cursorLine > self.currentCommandLine or cursorCol >= self.PROMPT_LENGTH)))
+
+    def onEnter(self, event):
+        """Handle Enter key - execute command."""
+        self.suggestionManager.hideSuggestions()
+        
+        if self.waitingForInput:
+            line = self.get("insert linestart", "insert lineend").strip()
+            self.insert("end", "\n")  # move to next line like normal console
+            self.inputVar.set(line)
+            self.waitingForInput = False
+            return("break")
+        
+        if self.isExecuting:
+            return("break")
+        
+        command = self.getCurrentCommand()
+        
+        if not command.strip():
+            return("break")
+        
+        # Check if statement is incomplete
+        if self.isIncompleteStatement(command):
+            return(self.onShiftEnter(event))
+        
+        # Execute the command
+        self.history.add(command)
+        self.mark_set("insert", "end")
+        self.insert("end", "\n")
+        self.see("end")
+        
+        # Execute in thread
+        self.isExecuting = True
+        threading.Thread(
+            target=self.executeCommandThreaded,
+            args=(command,),
+            daemon=True
+        ).start()
+        
+        return("break")
+
+    def readInput(self):
+        """Return the last entered line when input() is called."""
+        self.waitingForInput = True
+        self.wait_variable(self.inputVar)  #< waits until Enter is pressed
+        line = self.inputVar.get()
+        self.inputVar.set("")  #< reset
+        return(line)
+
+    def onShiftEnter(self, event):
+        """Handle Shift+Enter - new line with auto-indent."""
+        self.suggestionManager.hideSuggestions()
+        
+        if self.isExecuting:
+            return("break")
+        
+        # Get current line for indent calculation
+        cursorPos = self.index("insert")
+        lineStart = self.index(f"{cursorPos} linestart")
+        lineEnd = self.index(f"{cursorPos} lineend")
+        currentLine = self.get(lineStart, lineEnd)
+        
+        # Calculate indentation
+        indent = self.calculateIndent(currentLine)
+        
+        # Insert newline with indent
+        self.insert("insert", "\n" + " " * indent)
+        self.see("end")
+        
+        return("break")
+    
+    def onTab(self, event):
+        """Handle Tab key for autocompletion."""
+        if self.isExecuting:
+            return("break")
+        
+        if self.suggestionManager.suggestionWindow and \
+           self.suggestionManager.suggestionWindow.winfo_viewable():
+            self.suggestionManager.applySuggestion()
+        else:
+            self.suggestionManager.showSuggestions()
+        
+        return("break")
+    
+    def onBackspace(self, event):
+        """Prevent backspace from deleting the prompt."""
+        if not self.isCursorInEditableArea():
+            return("break")
+        
+        # Check if we're at the prompt boundary
+        cursorPos = self.index("insert")
+        promptPos = self.getPromptPosition()
+        
+        if self.compare(cursorPos, "<=", promptPos):
+            return("break")
+
+    def onClick(self, event):
+        """Handle mouse clicks - Ctrl+Click opens help for the clicked word."""
+        self.suggestionManager.hideSuggestions()
+
+        if event.state & 0x4:  #< Ctrl pressed
+            clickIndex = self.index(f"@{event.x},{event.y}")  # mouse index
+
+            # Get the full line
+            i = int(clickIndex.split('.')[1])
+            lineNum = clickIndex.split('.')[0]
+            lineStart = f"{lineNum}.0"
+            lineEnd = f"{lineNum}.end"
+            lineText = self.get(lineStart, lineEnd)
+            
+            wordEndIndex = self.index(f"{clickIndex} wordend")
+            # obj = self.get(f"{clickIndex} wordstart", f"{clickIndex} wordend").strip() #< Get the word at that index
+            obj = ""
+            for i in range (i-1,2, -1):
+                letter = lineText[i]
+                if (not (letter.isalnum() or letter == "_" or letter == ".")): #<  or (letter in " \n\t\r")
+                    obj = lineText[i+1: int(wordEndIndex.split('.')[1])]
+                    break
+            
+            
+            if obj:
+                self.helpTab.updateHelp(obj)
+                self.helpTab.open()
+            
+            return("break")  #< Prevent default cursor behavior
+
+        return(None)   #< Normal click behavior
+
+    def onKeyPress(self, event):
+        """Handle key press events."""
+        # print(event.keysym)
+        if self.suggestionManager.suggestionWindow and \
+           self.suggestionManager.suggestionWindow.winfo_viewable():
+            if event.keysym == "Escape":
+                self.suggestionManager.hideSuggestions()
+                return("break")
+
+        # Prevent editing outside command area
+        if not event.keysym in ["Shift_L", "Shift_R", "Control_L", "Control_R"]:
+            self.navigatingHistory = False
+            if not self.isCursorInEditableArea():
+                self.mark_set("insert", "end")
+
+        if event.keysym in ["Left", "Right"]:
+            if self.index("insert") == self.getPromptPosition():
+                self.mark_set("insert", "1.4")
+                return("break")
+
+    def onKeyRelease(self, event):
+        """Handle key release events."""
+        if event.keysym in ["Return", "Escape", "Left", "Right", "Home", "End"]:
+            self.suggestionManager.hideSuggestions()
+        elif event.keysym not in ["Up", "Down", "Shift_L", "Shift_R", "Control_L", "Control_R"]:
+            if not self.isExecuting:
+                self.after_idle(self.suggestionManager.showSuggestions)
+                if not self.isExecuting:
+                    self.after_idle(lambda: self.updateStyling(start=self.getPromptPosition()))
+
+    def cancel(self, event):
+        self.history.add(self.getCurrentCommand())
+        self.replaceCurrentCommand("")
+
+    def historyReplace(self, command):
+        if self.getCurrentCommand() == "" or self.navigatingHistory:
+            if self.isExecuting:
+                return("break")
+
+            if self.history.index == len(self.history.history):
+                self.history.setTemp(self.getCurrentCommand())
+
+            if command is not None:
+                self.replaceCurrentCommand(command)
+                self.navigatingHistory = True
+            return("break")
+
+    def onUp(self, event):
+        if self.suggestionManager.suggestionWindow and \
+           self.suggestionManager.suggestionWindow.winfo_viewable():
+            if event.keysym == "Up":
+                self.suggestionManager.handleNavigation("up")
+                return("break")
+        command = self.history.navigateUp()
+        return(self.historyReplace(command))
+        # self.mark_set("insert", "insert -1 line")
+
+    def onDown(self, event):
+        if self.suggestionManager.suggestionWindow and \
+           self.suggestionManager.suggestionWindow.winfo_viewable():
+            if event.keysym == "Down":
+                self.suggestionManager.handleNavigation("down")
+                return("break")
+        command = self.history.navigateDown()
+        return(self.historyReplace(command))
+
+    def isIncompleteStatement(self, code):
+        """Check if the code is an incomplete statement."""
+        lines = code.split("\n")
+        if not lines[-1].strip():
+            return(False)
+        
+        # Check for line ending with colon
+        for line in lines:
+            if line.strip().endswith(":"):
+                return(True)
+        
+        return(False)
+    
+    def calculateIndent(self, line):
+        """Calculate the indentation level for the next line."""
+        currentIndent = len(line) - len(line.lstrip())
+        
+        # If line ends with colon, increase indent
+        if line.strip().endswith(":"):
+            return(currentIndent + 4)
+        
+        return(currentIndent)
+
+    def writeOutput(self, text, tag="output"):
+        """Write output to the console (thread-safe)."""
+        def _write():
+            self.insert("end", text + "\n", tag)
+            self.see("end")
+        
+        self.after(0, _write)
+
+    def getPromptPosition(self):
+        """Get the position right after the prompt on current command line."""
+        return(f"{self.currentCommandLine}.{self.PROMPT_LENGTH}")
+
+    def getCurrentCommand(self):
+        """Extract the current command text (without prompt)."""
+        start = self.getPromptPosition()
+        end = "end-1c"
+        return(self.get(start, end))
+
+    def addPrompt(self):
+        """Add a new command prompt."""
+        def _add():
+            # Store the line number for the new command
+            self.currentCommandLine = self.getCurrentLineNumber()
+            
+            # Insert prompt
+            self.insert("end", self.PROMPT)
+            promptStart = f"{self.currentCommandLine}.0"
+            promptEnd = f"{self.currentCommandLine}.{self.PROMPT_LENGTH}"
+            self.tag_add("prompt", promptStart, promptEnd)
+            
+            self.mark_set("insert", "end")
+            self.see("end")
+            self.isExecuting = False
+        
+        if self.isExecuting:
+            self.after(0, _add)
+        else:
+            _add()
+    
+    def executeCommandThreaded(self, command):
+        """Execute a command in a separate thread."""
+        try:
+            # Try eval first for expressions
+            result = eval(command, self.master.userGlobals, self.master.userLocals)
+            if result is not None:
+                self.writeOutput(str(result), "result")
+                self.master.userLocals["_"] = result
+        except SyntaxError:
+            try:
+                # Try exec for statements
+                exec(command, self.master.userGlobals, self.master.userLocals)
+            except Exception:
+                self.writeOutput(traceback.format_exc(), "error")
+        except Exception:
+            self.writeOutput(traceback.format_exc(), "error")
+        
+        # Add new prompt after execution
+        self.addPrompt()

pysole.py

@@ -0,0 +1,132 @@
+import customtkinter as ctk
+import inspect
+import sys
+import io
+
+from helpTab import HelpTab
+from mainConsole import InteractiveConsoleText
+
+
+class StdoutRedirect(io.StringIO):
+    """Redirects stdout/stderr to a callback function."""
+    
+    def __init__(self, writeCallback):
+        super().__init__()
+        self.writeCallback = writeCallback
+
+    def write(self, s):
+        if s.strip():
+            self.writeCallback(s, "output")
+
+    def flush(self):
+        pass
+
+class StdinRedirect(io.StringIO):
+    """Redirects stdin to capture input() from the console."""
+    def __init__(self, readCallback):
+        super().__init__()
+        self.readCallback = readCallback
+
+    def readline(self, *args, **kwargs):
+        return(self.readCallback())
+
+
+class InteractiveConsole(ctk.CTk):
+    """Main console window application."""
+    
+    def __init__(self, userGlobals=None, userLocals=None):
+        super().__init__()
+        
+        # Window setup
+        self.title("Live Interactive Console")
+        self.geometry("900x600")
+        
+        ctk.set_appearance_mode("dark")
+        ctk.set_default_color_theme("blue")
+        
+        # Get namespace from caller if not provided
+        if userGlobals is None or userLocals is None:
+            callerFrame = inspect.currentframe().f_back
+            if userGlobals is None:
+                userGlobals = callerFrame.f_globals
+            if userLocals is None:
+                userLocals = callerFrame.f_locals
+        
+        self.userGlobals = userGlobals
+        self.userLocals = userLocals
+        
+        # Create UI
+        self._createUi()
+        
+        # Redirect stdout/stderr
+        self._setupOutputRedirect()
+        self._setupInputRedirect()
+    
+    def _createUi(self):
+        """Create UI with console and help tab."""
+        frame = ctk.CTkFrame(self)
+        frame.pack(padx=10, pady=10, fill="both", expand=True)
+
+        # Horizontal frame
+        self.horizFrame = ctk.CTkFrame(frame)
+        self.horizFrame.pack(fill="both", expand=True)
+
+        # Right: Help Tab
+        self.helpTab = HelpTab(self.horizFrame, width=500)
+
+        # Left: Console
+        self.consoleFrame = ctk.CTkFrame(self.horizFrame, width=600)
+        self.consoleFrame.pack(side="left", fill="both", expand=True)
+        self.consoleFrame.pack_propagate(False)  # prevent shrinking to fit contents
+
+        self.console = InteractiveConsoleText(
+            self.consoleFrame,
+            self.helpTab,
+            userGlobals=self.userGlobals,
+            userLocals=self.userLocals,
+            wrap="word",
+            bg="#1e1e1e",
+            fg="white",
+            insertbackground="white",
+            font=("Consolas", 12)
+        )
+        self.console.pack(fill="both", expand=True, padx=5, pady=5)
+        self.console.master = self
+
+    
+    def _setupOutputRedirect(self):
+        """Setup stdout/stderr redirection to console."""
+        sys.stdout = StdoutRedirect(self.console.writeOutput)
+        sys.stderr = StdoutRedirect(
+            lambda text, tag: self.console.writeOutput(text, "error")
+        )
+
+    def _setupInputRedirect(self):
+        """Setup stdin redirection to console."""
+        sys.stdin = StdinRedirect(self.console.readInput)
+    
+    def probe(self, *args, **kwargs):
+        """Start the console main loop."""
+        self.mainloop(*args, **kwargs)
+
+def probe():
+    InteractiveConsole().probe()
+
+def main():
+    from pysole import probe
+    probe()
+
+# Example usage
+if __name__ == "__main__":
+    # Example variables and functions for testing
+    foo = 42
+    
+    def greet(name):
+        print(f"Hello {name}!")
+        return(f"Greeted {name}")
+    
+    # Create the list for testing autocomplete
+    exampleList = [1, 2, 3, 4, 5]
+    
+    # Start the console
+    probe()

styledTextbox.py

@@ -0,0 +1,51 @@
+import tkinter as tk
+import pygments
+from pygments.lexers import PythonLexer
+from pygments.styles import get_style_by_name
+
+class StyledTextWindow(tk.Text):
+    def __init__(self, master,  **kwargs):
+        super().__init__(master, **kwargs)
+       
+        # Syntax highlighting setup
+        self.lexer = PythonLexer()
+        self.style = get_style_by_name("monokai")
+        
+        # Setup tags
+        self._setupTags()
+
+    def _setupTags(self):
+        """Configure text tags for different output types."""
+        self.tag_configure("prompt", foreground="#00ff00", font=("Consolas", 12, "bold"))
+        self.tag_configure("output", foreground="#ffffff", font=("Consolas", 12))
+        self.tag_configure("error", foreground="#ff6666", font=("Consolas", 12))
+        self.tag_configure("result", foreground="#66ccff", font=("Consolas", 12))
+        
+        # Configure syntax highlighting tags
+        for token, style in self.style:
+            if style["color"]:
+                fg = f"#{style['color']}"
+                font = ("Consolas", 12, "bold" if style["bold"] else "normal")
+                self.tag_configure(str(token), foreground=fg, font=font)
+
+
+    def updateStyling(self, start="1.0"):
+        """Apply syntax highlighting to the current command."""
+        end = "end-1c"
+        
+        for token, _ in self.style:
+            self.tag_remove(str(token), start, end)
+        
+        # Get and highlight the command
+        command = self.get(start, "end-1c")
+        if not command:
+            return(-1)
+
+        self.mark_set("highlight_pos", start)
+        
+        for token, content in pygments.lex(command, self.lexer):
+            if content:
+                endPos = f"highlight_pos + {len(content)}c"
+                if content.strip():  # Only highlight non-whitespace
+                    self.tag_add(str(token), "highlight_pos", endPos)
+                self.mark_set("highlight_pos", endPos)