liveConsole 1.6.1__py3-none-any.whl → 1.7.11__py3-none-any.whl

liveConsole/__init__.py

@@ -0,0 +1 @@
+from pysole import *

liveconsole-1.7.11.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: liveConsole
+Version: 1.7.11
+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
+Project-URL: Homepage, https://github.com/TzurSoffer/Pysole
+Project-URL: Repository, https://github.com/TzurSoffer/Pysole
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: customtkinter
+Requires-Dist: pygments
+Dynamic: license-file
+
+# PYSOLE
+
+## You can finally test your code in real time without using idle!
+### If you found [this repository](https://github.com/TzurSoffer/Pysole) useful, please give it a ⭐!.
+
+## Showcase (click to watch on Youtube)
+[![Watch the demo](Showcase/thumbnail.png)](https://www.youtube.com/shorts/pjoelNjc3O0)
+
+
+Table of contents
+
+- Features
+- Installation
+- Usage
+- Parameters
+- Keyboard Shortcuts
+- Troubleshooting/Notes
+- Contributing
+- License
+
+## Features
+
+Pysole provides a compact but powerful set of features designed to make interactive debugging and live testing fast and pleasant.
+
+1. Live GUI console (syntax highlighting)
+    - Real-time syntax highlighting using Pygments.
+    - Monokai style by default, configurable through themes.
+
+2. Autocomplete & suggestions
+    - Autocomplete for Python keywords, built-ins and variables in scope.
+    - Popup suggestions after typing (configurable behavior) and insert-on-confirm.
+
+3. Run remaining script code at startup
+    - `runRemainingCode=True` will execute the remainder of the calling script after `probe()` is invoked.
+    - `printStartupCode=True` prints the captured code chunks as they execute.
+
+4. Thread-safe execution + output capture
+    - User code runs in a background thread to avoid blocking the GUI.
+    - `stdout` and `stderr` are redirected into the GUI console output area.
+
+5. Multi-line input, indentation & history
+    - Shift+Enter inserts a newline with proper indentation.
+    - Command history with clickable entries for easy reuse.
+
+6. Integrated Help Panel and Features tab
+    - Right-hand help panel shows `help(obj)` output.
+    - A Features view is available from the File menu and shows the built-in features summary.
+
+7. Themes & persistent settings
+    - Theme picker in the File menu; selected theme is written to `settings.json`.
+    - Settings (THEME, BEHAVIOR, FONT) are loaded at startup from `src/pysole/settings.json`.
+
+
+## Installation
+
+Quick install
+
+```powershell
+pip install liveConsole
+```
+
+Notes: the package is published under the name `liveConsole` (see `pyproject.toml`).
+
+If you prefer to install from source, clone this repo and run:
+
+```powershell
+pip install -e .
+```
+
+Command-line entry points
+
+After installation, two console commands are provided:
+
+- `pysole` — open the GUI console (same as `liveconsole`)
+- `liveconsole` — open the GUI console
+
+
+## Usage
+
+Programmatic usage (embed in scripts):
+
+- Basic, automatic caller capture:
+```python
+import pysole
+pysole.probe()
+```
+
+- Run the remaining code in the current file inside the console and print the code as it executes
+```python
+pysole.probe(runRemainingCode=True, printStartupCode=True)
+```
+
+- Override appearance and prompt
+```python
+pysole.probe(primaryPrompt='PY> ', font='Consolas', fontSize=14)
+```
+
+## Parameters
+
+This section documents the parameters accepted by `pysole.probe()` and the `InteractiveConsole` constructor in `src/pysole/pysole.py`. Most of these parameters are optional; reasonable defaults are taken from the calling frame and `settings.json`.
+
+Note: `probe(...)` forwards its arguments to `InteractiveConsole(...)` so you can pass any of the parameters below to `probe()` directly.
+
+runRemainingCode
+- Meaning: When `True`, Pysole will read the remainder of the source file that contains the `probe()` call and run those lines inside the console's namespace.
+- Type: bool
+- Default: `False`
+- Behavior: The implementation inspects `callerFrame.f_code.co_filename` for the filename and `callerFrame.f_lineno` for the line number where `probe()` was called. Lines after that line are captured into `startupCode` and executed on console startup.
+- Caution: This requires the source file to be readable from disk (not packaged/compiled away). Large files will be read into memory.
+
+printStartupCode
+- Meaning: Controls how the startup code (captured by `runRemainingCode=True`) is executed: printed chunk-by-chunk to the console and executed interactively, or executed silently.
+- Type: bool
+- Default: `False`
+- Behavior: If `True`, the startup code is split into logical top-level chunks (top-level statements and their indented blocks). Each chunk is printed and executed sequentially so you can see what runs. If `False`, the entire remaining code is executed silently in one go (but output is still captured and shown).
+
+primaryPrompt
+- Meaning: Overrides the primary prompt string (for example `>>>`). This updates the in-memory `BEHAVIOR['PRIMARY_PROMPT']` used by the console and the default can also be changed in the settings file directly.
+- Type: string
+- Default: The prompt value defined in `settings.json` under `BEHAVIOR -> PRIMARY_PROMPT`.
+- Notes: Passing this parameter changes the prompt for the current session only.
+
+font
+- Meaning: Overrides the font family used in console widgets.
+- Type: string (font family name, e.g. "Consolas", "Courier New")
+- Default: The font specified by `settings.json` -> `THEME` -> `FONT`.
+
+fontSize
+- Meaning: Overrides the font size used in console widgets.
+- Type: int (font size in points / pixels depending on the platform and Tk configuration)
+- Default: Value from `settings.json` -> `THEME` -> `FONT_SIZE`.
+
+removeWaterMark
+- Meaning: Controls whether a short welcome watermark message (with a GitHub link and request to star the project) is printed at startup.
+- Type: bool
+- Default: `False` (watermark shown)
+
+userGlobals
+- Meaning: The `globals()` mapping that the console will use as its global namespace. Variables, functions, and imports in this mapping will be visible to code executed in the console.
+- Type: dict-like (typically the dict returned by `globals()`)
+- Default: If omitted, the console infers the caller's globals using `callerFrame.f_globals` (or from `inspect.currentframe().f_back` if `callerFrame` is also omitted).
+- When to pass: Provide this when you want the console to operate on a specific module or custom namespace.
+
+userLocals
+- Meaning: The `locals()` mapping used as the console's local namespace. Local variables available at the call site will be visible here.
+- Type: dict-like (typically the dict returned by `locals()`)
+- Default: Inferred from the caller's frame (`callerFrame.f_locals`) if not provided.
+
+callerFrame
+- Meaning: An `inspect` frame object used to infer both `userGlobals` and `userLocals` when they are not supplied. It's also used to determine the source file and line number for the "run remaining code" feature.
+- Type: frame object (as returned by `inspect.currentframe()` and `frame.f_back`)
+- Default: If omitted, `probe()` sets `callerFrame = inspect.currentframe().f_back` to automatically capture the frame of the caller.
+- When to pass: Use an explicit frame when calling `probe()` from helper wrappers or non-standard contexts where automatic frame detection would be wrong.
+
+Behavioral notes and edge cases
+- `probe()` replaces `sys.stdout`, `sys.stderr`, and `sys.stdin` with console-aware redirectors while the console is running. These streams are restored when the console's `onClose()` runs (but be mindful when embedding Pysole in larger apps).
+- If `runRemainingCode=True` but the source file cannot be read (packaged app, missing file, permission issues), the attempt to read the file will fail — in that case either run Pysole without `runRemainingCode` or pass an explicit `startupCode` (if you extend the API).
+- When `printStartupCode=True`, chunks are determined by top-level lines (zero indent) and their following indented lines. This makes printed execution easier to follow for functions, classes and loops.
+
+## Keyboard Shortcuts
+
+| Key | Action |
+| --- | --- |
+| `Enter` | Execute command (if complete) |
+| `Shift+Enter` | Insert newline with auto-indent |
+| `Tab` | Complete the current word / show suggestions |
+| `Up/Down` | Navigate suggestion list |
+| `Escape` | Hide suggestions |
+| `Ctrl Click` | open help panel on the current method/func/class... |
+
+
+## Troubleshooting/Notes
+
+Behavioral notes and edge cases
+
+- `probe()` temporarily replaces `sys.stdout`, `sys.stderr` and `sys.stdin` with redirectors that send text to the GUI console. These are restored on close (`onClose()`). Embedding Pysole in larger apps should take this into account.
+- `runRemainingCode=True` requires the calling module's source file to be available on disk. Running this in frozen/packaged environments may fail.
+- `printStartupCode=True` prints chunks determined by top-level statements (zero indent) and their indented blocks so function/class/loop definitions are grouped with their bodies.
+
+Settings and themes
+
+Default UI and behavior settings are loaded from `src/pysole/settings.json` (path built from `src/pysole/utils.py`). Themes are listed in `src/pysole/themes.json`. The in-app Theme Picker writes the selected theme back to `settings.json` to persist across sessions.
+
+Troubleshooting
+
+- If the GUI doesn't start, make sure `customtkinter` is installed for your Python version.
+- On Linux, ensure your Tk/Tcl support is present (system package) and `DISPLAY` is set when running headful UIs.
+- If `runRemainingCode` appears to run the wrong code, check where `probe()` is called (wrappers can shift the caller frame). Use `callerFrame=` to pass an explicit frame if needed.
+
+## Contributing
+
+- Bug reports and PRs welcome. Please open issues on the upstream GitHub repository: https://github.com/TzurSoffer/Pysole
+- Keep test changes small and focused. Include a short description of the error / feature and steps to reproduce.
+
+Changelog (high level)
+
+- See `pyproject.toml` for the current package version.
+
+## License
+
+This project is available under the MIT license — see the `LICENSE` file in the repository root.
+

liveconsole-1.7.11.dist-info/RECORD

@@ -0,0 +1,19 @@
+liveConsole/__init__.py,sha256=GyV_Y3iiiS12JoEiqE55uZPQ8ZDYfOSKvxh5rcfaD1U,20
+liveconsole-1.7.11.dist-info/licenses/LICENSE,sha256=7dZ0zL72aGaFE0C9DxacOpnaSkC5jajhG6iL7lqhWmU,1064
+pysole/__init__.py,sha256=0Jq2s5WxFVveZW-pGwThGZLt_mVSdGcsT9lpJNEZ6ds,124
+pysole/__main__.py,sha256=QvVFH8J2yzgQaF9MosQ6ajCW67uiRbYliePsTEUCIAg,82
+pysole/commandHistory.py,sha256=xJtWbJ_vgJo2QGgaZJsApTOi_Hm8Yz0V9_zqQUCItj8,1084
+pysole/helpTab.py,sha256=o0uSY-8sw7FuuBrt0FQwcgK6ljNVx3IgRnW7heZ6GvY,2454
+pysole/liveConsole.py,sha256=lzS3dphAQ1i8pQC4E2FY-FyMMSKi-dAN0xr6XUgrNmo,168
+pysole/mainConsole.py,sha256=TSiqbR4WLUuI0hOzjuI9X_TwIEYa6vGnIbgGhKBHJ3Q,15537
+pysole/pysole.py,sha256=PxZAWFkxVqF2OcgecTe9LZ0xZdEdHiS7UYSCbNPf22c,14136
+pysole/settings.json,sha256=cmOtIhRDWHMwmQMESuykWuzJd_jG6iT2tJ-uhSps_3U,722
+pysole/styledTextbox.py,sha256=qQnkShALNbvbZY7hYDM8Gigke63TfbtQYPUsrm4Qk6Q,2145
+pysole/suggestionManager.py,sha256=CGR1wsRIU4le3Bq_6CPAytM1CzTQAV_jUl5KZbg9LPU,6544
+pysole/themes.json,sha256=2KvEfxm-eDsfVKIdBhWk-Qd93wYQub3YwkxbS6CGKH0,2525
+pysole/utils.py,sha256=cKsSPWeYRxPhkiM8Xrb-aMW6w0SU5Xuu9WCgsu6_xtA,1364
+liveconsole-1.7.11.dist-info/METADATA,sha256=hUYw5e9NhozaoUvJvjLnruc6j9uSnCmhmPZa5_gXfmE,10408
+liveconsole-1.7.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+liveconsole-1.7.11.dist-info/entry_points.txt,sha256=qtvuJHcex4QqM97x_UawFWJYnfhQRl0jhqLcWRpnAGo,84
+liveconsole-1.7.11.dist-info/top_level.txt,sha256=YGhC2H7bvcDnMwEtvLXF6qQNIZT2Saayyk1KOJyndN8,19
+liveconsole-1.7.11.dist-info/RECORD,,

liveconsole-1.7.11.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+liveConsole
+pysole

pysole/__init__.py

@@ -1 +1,4 @@
 from .pysole import probe, _standalone, InteractiveConsole
+import sys
+
+sys.modules['liveConsole'] = sys.modules[__name__]

pysole/mainConsole.py

@@ -3,6 +3,7 @@ import traceback
 from .suggestionManager import CodeSuggestionManager
 from .commandHistory import CommandHistory
 from .styledTextbox import StyledTextWindow
+from .utils import stdPrint
 
 import tkinter as tk
 
@@ -11,26 +12,27 @@ class InteractiveConsoleText(StyledTextWindow):
     def __init__(self, master, helpTab, theme, font, behavior, userLocals=None, userGlobals=None, **kwargs):
         super().__init__(master, theme=theme, font=font, **kwargs)
         self.font=(font["FONT"], font["FONT_SIZE"])
-        
+
         # Initialize components
         self.PROMPT = behavior["PRIMARY_PROMPT"]
         self.PROMPT_LENGTH = len(self.PROMPT)
         self.suggestionManager = CodeSuggestionManager(self, userLocals=userLocals, userGlobals=userGlobals, theme=theme, font=font)
         self.helpTab = helpTab
-        
+
         self.navigatingHistory = False
         self.history = CommandHistory()
-        
+
         self.inputVar = tk.StringVar()
         self.waitingForInput = False
+        self.inputLine = "1.0"
 
         # Track current command
         self.currentCommandLine = 1
         self.isExecuting = False
-        
+
         # Setup bindings
         self._setupBindings()
-        
+
         # Initialize with first prompt
         self.addPrompt()
 
@@ -41,32 +43,59 @@ class InteractiveConsoleText(StyledTextWindow):
         self.bind("<Control-c>", self.cancel)
         self.bind("<Tab>", self.onTab)
         self.bind("<BackSpace>", self.onBackspace)
+        self.bind("<Delete>", self.onDelete)
         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 getPromptPosition(self):
+        """Get the position right after the prompt on current command line."""
+        return(f"{self.currentCommandLine}.{self.PROMPT_LENGTH}")
+
     def getCurrentLineNumber(self):
         """Get the line number where current command starts."""
         return(int(self.index("end-1c").split(".")[0]))
-    
+
+    def resetCurrentLineNumber(self):
+        self.currentCommandLine = self.getCurrentLineNumber()
+
     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."""
+    def writeToPrompt(self, text):
+        """Write text to the prompt of the console"""
         if self.isExecuting:
             return
-        
+
+        if text:
+            self.insert("end", text)
+        self.mark_set("insert", "end")
+        self.see("end")
+        self.updateStyling(start=self.getPromptPosition())    #< Ensure styling/lexer applied after programmatic change:
+
+    def replaceCurrentCommand(self, newCommand):
+        """Replace the current command with new text."""
         start = self.getPromptPosition()
         end = "end-1c"
-        
         self.delete(start, end)
-        self.insert(start, newCommand)
-        self.see("end")
-    
+        self.writeToPrompt(newCommand)
+
+    def runCommand(self, command, printCommand=False, clearPrompt=True):
+        """Insert code into the console prompt and execute it as if Enter was pressed."""
+        if self.isExecuting:
+            return(False)
+        if printCommand:
+            if clearPrompt:
+                self.replaceCurrentCommand(command)  #< Replace current command with the new code
+            else:
+                self.writeToPrompt(command)
+            self.onEnter(None, insertWhitespace=False)                       #< Simulate pressing Enter to run the command
+        else:
+            self.executeCommandThreaded(command, addPrompt=False)
+
     def isCursorInEditableArea(self):
         """Check if cursor is in the editable command area."""
         if self.isExecuting:
@@ -78,7 +107,7 @@ class InteractiveConsoleText(StyledTextWindow):
         return((cursorLine >= self.currentCommandLine and 
                 (cursorLine > self.currentCommandLine or cursorCol >= self.PROMPT_LENGTH)))
 
-    def onEnter(self, event):
+    def onEnter(self, event, insertWhitespace=True):
         """Handle Enter key - execute command."""
         self.suggestionManager.hideSuggestions()
         
@@ -88,25 +117,25 @@ class InteractiveConsoleText(StyledTextWindow):
             self.inputVar.set(line)
             self.waitingForInput = False
             return("break")
-        
+
         if self.isExecuting:
             return("break")
-        
+
         command = self.getCurrentCommand()
-        
+        # print(command)
+
         if not command.strip():
             return("break")
-        
+
         # Check if statement is incomplete
-        if self.isIncompleteStatement(command):
+        if self.isIncompleteStatement(command) and insertWhitespace:
             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(
@@ -114,16 +143,17 @@ class InteractiveConsoleText(StyledTextWindow):
             args=(command,),
             daemon=True
         ).start()
-        
+
         return("break")
 
     def readInput(self):
         """Return the last entered line when input() is called."""
         self.waitingForInput = True
+        self.inputLine = self.index("end -1c")
         self.wait_variable(self.inputVar)  #< waits until Enter is pressed
         line = self.inputVar.get()
         self.inputVar.set("")  #< reset
-        return(line)
+        return(line or "\n")
 
     def onShiftEnter(self, event):
         """Handle Shift+Enter - new line with auto-indent."""
@@ -162,15 +192,35 @@ class InteractiveConsoleText(StyledTextWindow):
     
     def onBackspace(self, event):
         """Prevent backspace from deleting the prompt."""
+        
+        if self.waitingForInput:      #< During input mode, only allow editing after input start
+            if self.compare("insert", "<=", self.inputLine):
+                return "break"
+            return None
+            
         if not self.isCursorInEditableArea():
-            return("break")
+            return "break"
         
         # Check if we're at the prompt boundary
         cursorPos = self.index("insert")
         promptPos = self.getPromptPosition()
         
         if self.compare(cursorPos, "<=", promptPos):
+            return "break"
+        
+        return None
+    
+    def onDelete(self, event):
+        """Prevent delete from deleting protected content."""
+        if self.waitingForInput:      #< During input mode, only allow editing after input start
+            if self.compare("insert", "<=", self.inputLine):
+                return("break")
+            return(None)
+            
+        if not self.isCursorInEditableArea():
             return("break")
+        
+        return(None)
 
     def onClick(self, event):
         """Handle mouse clicks - Ctrl+Click opens help for the clicked word."""
@@ -206,7 +256,11 @@ class InteractiveConsoleText(StyledTextWindow):
 
     def onKeyPress(self, event):
         """Handle key press events."""
-        # print(event.keysym)
+        if self.waitingForInput:      #< During input mode, only allow editing after input start
+            if (self.compare("insert", "<=", self.inputLine) and event.keysym == "Left"):
+                return("break")
+            return(None)
+
         if self.suggestionManager.suggestionWindow and \
            self.suggestionManager.suggestionWindow.winfo_viewable():
             if event.keysym == "Escape":
@@ -293,17 +347,24 @@ class InteractiveConsoleText(StyledTextWindow):
         
         return(currentIndent)
 
-    def writeOutput(self, text, tag="output"):
+    def writeOutput(self, text, tag="output", loc="end", timeout=None):
         """Write output to the console (thread-safe)."""
+        doneEvent = threading.Event()
+
         def _write():
-            self.insert("end", text + "\n", tag)
-            self.see("end")
-        
+            try:
+                self.insert(loc, text + "\n", tag)
+                self.see("end")
+            finally:
+                doneEvent.set()  # Signal completion
+
         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}")
+        doneEvent.wait(timeout)
+    
+    def newline(self):
+        """Insert a newline at the end."""
+        self.writeOutput("")
 
     def getCurrentCommand(self):
         """Extract the current command text (without prompt)."""
@@ -326,16 +387,15 @@ class InteractiveConsoleText(StyledTextWindow):
             self.mark_set("insert", "end")
             self.see("end")
             self.isExecuting = False
-        
+
         if self.isExecuting:
             self.after(0, _add)
         else:
             _add()
-    
-    def executeCommandThreaded(self, command):
+
+    def executeCommandThreaded(self, command, addPrompt=True):
         """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")
@@ -349,5 +409,7 @@ class InteractiveConsoleText(StyledTextWindow):
         except Exception:
             self.writeOutput(traceback.format_exc(), "error")
         
-        # Add new prompt after execution
-        self.addPrompt()
+        if addPrompt:
+            self.addPrompt()
+        else:
+            self.isExecuting = False

pysole/pysole.py

@@ -1,3 +1,5 @@
+import threading
+import time
 import customtkinter as ctk
 import tkinter as tk
 from tkinter import messagebox
@@ -5,8 +7,9 @@ import inspect
 import sys
 import io
 import json
+import signal
 
-from .utils import settingsPath, themesPath
+from .utils import settingsPath, themesPath, stdPrint, normalizeWhitespace, findUnindentedLine
 from .helpTab import HelpTab
 from .mainConsole import InteractiveConsoleText
 
@@ -35,23 +38,30 @@ class StdinRedirect(io.StringIO):
 
 class InteractiveConsole(ctk.CTk):
     """Main console window application."""
-    
-    def __init__(self, userGlobals=None, userLocals=None, callerFrame=None, theme=None, defaultSize=None, primaryPrompt=None):
+
+    def __init__(self, userGlobals=None, userLocals=None, callerFrame=None,
+                 defaultSize=None, primaryPrompt=None, font=None, fontSize=None,
+                 runRemainingCode=False, printStartupCode=False,
+                 removeWaterMark=False):
         super().__init__()
         with open(settingsPath, "r") as f:
             settings = json.load(f)
         self.THEME = settings["THEME"]
         self.FONT = self.THEME["FONT"]
         self.BEHAVIOR = settings["BEHAVIOR"]
-        
+
         if primaryPrompt != None:
             self.BEHAVIOR["PRIMARY_PROMPT"] = primaryPrompt
         if defaultSize != None:
             self.BEHAVIOR["DEFAULT_SIZE"] = defaultSize
+        if font != None:
+            self.FONT["FONT"] = font
+        if fontSize != None:
+            self.FONT["FONT_SIZE"] = fontSize
 
         self.title("Live Interactive Console")
         self.geometry(self.BEHAVIOR["DEFAULT_SIZE"])
-        
+
         ctk.set_appearance_mode(self.THEME["APPEARANCE"])
         ctk.set_default_color_theme("blue")
 
@@ -63,17 +73,54 @@ class InteractiveConsole(ctk.CTk):
                 userGlobals = callerFrame.f_globals
             if userLocals is None:
                 userLocals = callerFrame.f_locals
-        
+
+        self.callerFrame = callerFrame
         self.userGlobals = userGlobals
         self.userLocals = userLocals
-        
+
         # Create UI
         self._createMenu()
         self._createUi()
+
+        self.protocol("WM_DELETE_WINDOW", self.onClose)   #< Wire up window close button (X)
         
+        # Set up signal handler for Ctrl+C from terminal to close gracefully
+        def sigint_handler(signum, frame):
+            self.onClose()
+        
+        signal.signal(signal.SIGINT, sigint_handler)
+
         # Redirect stdout/stderr
         self._setupOutputRedirect()
         self._setupInputRedirect()
+        
+        self.runRemainingCode = runRemainingCode
+        self.printStartupCode = printStartupCode
+        self.removeWaterMark = removeWaterMark
+        self.startupCode = []
+        if runRemainingCode:
+            self.startupCode = self._getStartupCode()
+    
+    def _getStartupCode(self):
+        code_obj = self.callerFrame.f_code
+        callStartLineIndex = inspect.getframeinfo(self.callerFrame).positions.lineno     #< start of the probe call
+        callEndLineIndex = inspect.getframeinfo(self.callerFrame).positions.end_lineno   #< end of the probe call
+        filename = code_obj.co_filename
+
+        # Read the rest of the file after the call to probe()
+        with open(filename, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        startLine = lines[callStartLineIndex-1]
+        for line in lines[callStartLineIndex:callEndLineIndex]:
+            startLine += line.strip()
+
+        startupCode = normalizeWhitespace(lines[callEndLineIndex:])        #< ensure the code is not indented too much (egg if in __name__ == "__main__")
+        firstUnindentedLine = findUnindentedLine(startupCode)
+        while firstUnindentedLine != 0 and firstUnindentedLine != None:    #< handle if probe is inside a loop/if/etc by simply unindenting the call (while is for nested calls)
+            startupCode[:firstUnindentedLine] = normalizeWhitespace(startupCode[:firstUnindentedLine])
+            firstUnindentedLine = findUnindentedLine(startupCode)
+        return(startupCode)
 
     def _createMenu(self):
         """Create a menu bar using CTkOptionMenu."""
@@ -99,7 +146,7 @@ class InteractiveConsole(ctk.CTk):
             self._editSettings()
         elif choice == "Load Theme":
             self._loadTheme()
-    
+
     def _loadTheme(self):
         """
         Open a CTk popup to let the user choose a theme from themes.json.
@@ -175,7 +222,7 @@ class InteractiveConsole(ctk.CTk):
         def saveSettings():
             try:
                 newSettings = json.loads(textbox.get("0.0", "end-1c"))
-                with open("settings.json", "w") as f:
+                with open(settingsPath, "w") as f:
                     json.dump(newSettings, f, indent=4)
                 messagebox.showinfo("Success", "Settings saved!")
                 editor.destroy()
@@ -218,28 +265,99 @@ class InteractiveConsole(ctk.CTk):
         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")
+            lambda text, tag: self.console.writeOutput(text, "error", "end")
         )
 
     def _setupInputRedirect(self):
         """Setup stdin redirection to console."""
         sys.stdin = StdinRedirect(self.console.readInput)
+
+    def onClose(self):
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        self.destroy()
+    
+    def _printWaterMark(self):
+        m = (
+            "Welcome to Pysole, if you find me useful, please star me on GitHub:\n"
+            "https://github.com/TzurSoffer/Pysole"
+        )
+        stdPrint(m)
+        self.console.newline()
+        self.console.writeOutput(m, "instruction")
+        time.sleep(0.1)
+        self.console.addPrompt()
+        if self.runRemainingCode and self.printStartupCode == False:
+            self.console.newline()
+    
+    def _splitCodeIntoChunks(self):
+        codeChunks = []
+        currentChunk = []
+
+        for line in self.startupCode:
+            strippedLine = line.lstrip()
+            indentLevel = len(line) - len(strippedLine)
+
+            if not strippedLine:  #< Blank line, keep it in current chunk
+                currentChunk.append(line)
+                continue
+
+            if indentLevel != 0:
+                currentChunk.append(line)
+            else:
+                codeChunks.append(currentChunk)
+                currentChunk = [line]
+
+        if currentChunk:
+            codeChunks.append(currentChunk)
+
+        return(["\n".join(chunk).strip() for chunk in codeChunks if any(line.strip() for line in chunk)])
+
     
+    def _runStartup(self):
+        if self.removeWaterMark == False:
+            self._printWaterMark()
+
+        if self.runRemainingCode == False:
+            return
+
+        if self.printStartupCode == False:
+            self.console.newline()
+        chunks = self._splitCodeIntoChunks()
+        for chunk in chunks:
+            while self.console.isExecuting:
+                time.sleep(0.01)
+            if self.printStartupCode == False:
+                self.console.executeCommandThreaded(chunk, addPrompt=False)
+            else:
+                self.console.runCommand(chunk, printCommand=True, clearPrompt=True)
+        if self.printStartupCode == False:
+            self.console.addPrompt()
+
     def probe(self, *args, **kwargs):
         """Start the console main loop."""
+        self.after(0, threading.Thread(target=self._runStartup).start)
         self.mainloop(*args, **kwargs)
 
-def probe(userGlobals=None, userLocals=None, callerFrame=None):
+def probe(userGlobals=None, userLocals=None, callerFrame=None,
+          runRemainingCode=False, printStartupCode=False,
+          primaryPrompt=None, font=None, fontSize=None, removeWaterMark=False, **kwargs):
     if callerFrame == None:
         callerFrame = inspect.currentframe().f_back
     InteractiveConsole(userGlobals=userGlobals,
                               userLocals=userLocals,
-                              callerFrame=callerFrame).probe()
+                              callerFrame=callerFrame,
+                              runRemainingCode=runRemainingCode,
+                              printStartupCode=printStartupCode,
+                              primaryPrompt=primaryPrompt,
+                              font=font,
+                              fontSize=fontSize,
+                              removeWaterMark=removeWaterMark,
+                              **kwargs).probe()
 
 def _standalone():
     import pysole

pysole/settings.json

@@ -11,6 +11,7 @@
         "OUTPUT": "#ffffff",
         "ERROR": "#ff0000",
         "RESULT": "#66ccff",
+        "INSTRUCTION": "#ffccdd",
         "SUGGESTION_BOX_BG": "#2d2d2d",
         "SUGGESTION_BOX_SELECTION_BG": "#0066cc",
         "FONT": {

pysole/styledTextbox.py

@@ -6,7 +6,8 @@ from pygments.styles import get_style_by_name
 class StyledTextWindow(tk.Text):
     def __init__(self, master, theme, font, **kwargs):
         super().__init__(master, **kwargs)
-       
+        self.configure(font=(font["FONT"], font["FONT_SIZE"]))  #< default
+
         # Syntax highlighting setup
         self.lexer = PythonLexer()
         self.style = get_style_by_name(theme["LEXER_STYLE"])
@@ -16,9 +17,10 @@ class StyledTextWindow(tk.Text):
     def _setupTags(self, theme, font):
         """Configure text tags for different output types."""
         self.tag_configure("prompt", foreground=theme["PROMPT"], font=(font["FONT"], font["FONT_SIZE"], "bold"))
-        self.tag_configure("output", foreground=theme["OUTPUT"], font=(font["FONT"], font["FONT_SIZE"]))
-        self.tag_configure("error", foreground=theme["ERROR"], font=(font["FONT"], font["FONT_SIZE"]))
-        self.tag_configure("result", foreground=theme["RESULT"], font=(font["FONT"], font["FONT_SIZE"]))
+        self.tag_configure("output", foreground=theme["OUTPUT"])
+        self.tag_configure("error", foreground=theme["ERROR"])
+        self.tag_configure("result", foreground=theme["RESULT"])
+        self.tag_configure("instruction", foreground=theme["INSTRUCTION"])
         
         # Configure syntax highlighting tags
         for token, style in self.style:

pysole/suggestionManager.py

@@ -107,8 +107,11 @@ class CodeSuggestionManager:
         self.suggestionListbox.selection_set(0)
         
         # Position window near cursor
-        self._positionSuggestionWindow()
-        self.suggestionWindow.deiconify()
+        try:      #< some weird errors idk
+            self._positionSuggestionWindow()
+            self.suggestionWindow.deiconify()
+        except:
+            pass
     
     def _createSuggestionWindow(self):
         """Create the suggestion popup window."""

pysole/themes.json

@@ -11,6 +11,7 @@
         "OUTPUT": "#ffffff",
         "ERROR": "#ff0000",
         "RESULT": "#66ccff",
+        "INSTRUCTION": "#ffccdd",
         "SUGGESTION_BOX_BG": "#2d2d2d",
         "SUGGESTION_BOX_SELECTION_BG": "#0066cc",
         "FONT": {
@@ -30,6 +31,7 @@
         "OUTPUT": "#000000",
         "ERROR": "#ff0000",
         "RESULT": "#0066cc",
+        "INSTRUCTION": "#ffccdd",
         "SUGGESTION_BOX_BG": "#f0f0f0",
         "SUGGESTION_BOX_SELECTION_BG": "#cce6ff",
         "FONT": {
@@ -49,6 +51,7 @@
         "OUTPUT": "#586e75",
         "ERROR": "#dc322f",
         "RESULT": "#2aa198",
+        "INSTRUCTION": "#ffccdd",
         "SUGGESTION_BOX_BG": "#eee8d5",
         "SUGGESTION_BOX_SELECTION_BG": "#b58900",
         "FONT": {
@@ -68,6 +71,7 @@
         "OUTPUT": "#f8f8f2",
         "ERROR": "#ff5555",
         "RESULT": "#8be9fd",
+        "INSTRUCTION": "#ffccdd",
         "SUGGESTION_BOX_BG": "#44475a",
         "SUGGESTION_BOX_SELECTION_BG": "#6272a4",
         "FONT": {

pysole/utils.py

@@ -1,4 +1,45 @@
 import os
+import sys
+import re
 
 settingsPath = os.path.join(os.path.dirname(__file__), "settings.json")
 themesPath = os.path.join(os.path.dirname(__file__), "themes.json")
+
+def stdPrint(text):
+    """Print text to the terminal."""
+    try:
+        sys.__stdout__.write(f"{text}\n")
+        sys.__stdout__.flush()
+    except:
+        pass
+
+def normalizeWhitespace(lines):
+    """
+    Normalize leading whitespace across a list of code lines.
+    Removes common leading indentation and trims excess on over-indented lines.
+    """
+    
+    if type(lines) == str:
+        lines = lines.split('\n')
+
+    # Remove empty lines and preserve original line endings
+    strippedLines = [line.rstrip('\n') for line in lines if line.strip()]
+    if not strippedLines:
+        return []
+
+    # Find minimum indentation across non-empty lines
+    indentLevels = [
+        len(re.match(r'^[ \t]*', line).group())
+        for line in strippedLines
+    ]
+    minIndent = min(indentLevels)
+
+    
+    normalized = [line[minIndent:] if len(line) >= minIndent else line for line in lines]   #< Normalize by removing minIndent from each line
+    return(normalized)
+
+def findUnindentedLine(lines):
+    for i, line in enumerate(lines):
+        if re.match(r'^\S', line):  # Line starts with non-whitespace
+            return(i)
+    return(None)

liveconsole-1.6.1.dist-info/METADATA

@@ -1,138 +0,0 @@
-Metadata-Version: 2.4
-Name: liveConsole
-Version: 1.6.1
-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
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: customtkinter
-Requires-Dist: pygments
-Dynamic: license-file
-
-# PYSOLE
-
-## You can finally test your code in real time without using idle!
-### If you found [this repository](https://github.com/TzurSoffer/Pysole) useful, please give it a ⭐!.
-
-A fully-featured, **live Python console GUI** built with **CustomTkinter** and **Tkinter**, featuring:
-
-*   Python syntax highlighting via **Pygments**
-    
-*   Autocomplete for **keywords, built-ins, and local/global variables**
-    
-*   Thread-safe execution of Python code
-    
-*   Output capturing for `stdout` and `stderr`
-    
-*   Multi-line input with auto-indentation
-    
-*   History of previous commands
-
-* **Integrated Help Panel** for quick access to Python object documentation
-
-
-## Installation
-
-`pip install liveConsole`
-
-
-## Features
-
-### Standalone Launch
-
-* Once installed, you can launch the console directly by simply typing  ```pysole``` or ```liveconsole``` in the terminal
-
-* This opens the full GUI without needing to write any code. Perfect for quick debugging and experimenting.
-
-### Syntax Highlighting
-
-*   Real-time syntax highlighting using **Pygments** and the **Monokai** style.
-    
-*   Highlights Python keywords, built-ins, and expressions in the console.
-    
-
-### Autocomplete
-
-*   Suggests **keywords**, **built-in functions**, and **variables** in scope.
-    
-*   Popup list appears after typing at least 2 characters.
-    
-*   Only inserts the **missing portion** of a word.
-    
-*   Navigate suggestions with **Up/Down arrows**, confirm with **Tab/Return**.
-    
-
-### Multi-Line Input
-
-*   Supports **Shift+Enter** for inserting a new line with proper indentation.
-    
-*   Automatically detects incomplete statements and continues the prompt.
-    
-
-### Thread-Safe Execution
-
-*   Executes user code in a separate thread to prevent GUI freezing.
-    
-*   Captures both `stdout` and `stderr` output and prints them in the console.
-    
-*   Supports both **expressions (`eval`)** and **statements (`exec`)**.
-    
-
-### Clickable History
-
-*   Hover previous commands to see them highlighted.
-    
-*   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.
-    
-*   Can be used standalone or embedded in larger CustomTkinter applications.
-
-## Usage
-
-```
-import pysole
-pysole.probe()
-```
-
-*   Type Python commands in the `>>>` prompt and see live output.
-
-## Keyboard Shortcuts
-
-| Key | Action |
-| --- | --- |
-| `Enter` | Execute command (if complete) |
-| `Shift+Enter` | Insert newline with auto-indent |
-| `Tab` | Complete the current word / show suggestions |
-| `Up/Down` | Navigate suggestion list |
-| `Escape` | Hide suggestions |
-| `Mouse Click` | Select previous command from history |
-
-
-## Customization
-
-*   **Appearance mode**: Dark mode is default, but can be changed via files menu
-
-*   **Themes**: Pysole has multiple preconfigured themes. You can choose a theme via the Theme Picker, which updates the console colors and appearance. Preconfigured themes are loaded from themes.json and the selected theme is saved in settings.json so it persists across sessions.
-
-
-
-## License
-
-MIT License – free to use, modify, and distribute.

liveconsole-1.6.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-liveconsole-1.6.1.dist-info/licenses/LICENSE,sha256=7dZ0zL72aGaFE0C9DxacOpnaSkC5jajhG6iL7lqhWmU,1064
-pysole/__init__.py,sha256=SfaSBmFVSmhyf55UedBCqhi2Ss6Tre-BCKtZb3bSr2k,60
-pysole/__main__.py,sha256=QvVFH8J2yzgQaF9MosQ6ajCW67uiRbYliePsTEUCIAg,82
-pysole/commandHistory.py,sha256=xJtWbJ_vgJo2QGgaZJsApTOi_Hm8Yz0V9_zqQUCItj8,1084
-pysole/helpTab.py,sha256=o0uSY-8sw7FuuBrt0FQwcgK6ljNVx3IgRnW7heZ6GvY,2454
-pysole/liveConsole.py,sha256=lzS3dphAQ1i8pQC4E2FY-FyMMSKi-dAN0xr6XUgrNmo,168
-pysole/mainConsole.py,sha256=9Kdjpe9rQzx3Nk9aBaECR3PlwAXszgRt4VfIJmVJnRw,13141
-pysole/pysole.py,sha256=vTmPvS4nzapVudNPtf2JrnwBWB-x_n-XxBsr4jW7MK8,9230
-pysole/settings.json,sha256=6wCdMlemV6PblPKeQQsIiCrGWPLDLOMFD3hLMVAXL24,687
-pysole/styledTextbox.py,sha256=zpbaN0qX5FduhNyuWGU7y8Ll8J9p9YqczpSuRLo4PX0,2120
-pysole/suggestionManager.py,sha256=EUFeCQoZnLS8EjPPNuZpzjY0BR07m2KP5TloyaMDVGY,6457
-pysole/themes.json,sha256=2RG3ohn2ZBc2-h9bdooQZD6hW5pD41a5c2jdaKDA4MA,2385
-pysole/utils.py,sha256=VN42ukHMJpOvGb7ZV-qhF_zRUt13hzJKV_uRn9t6580,155
-liveconsole-1.6.1.dist-info/METADATA,sha256=ScK9vL5BuDsaRSoUZicUfWx2wDDqYlonVtJlH5Di_f0,4011
-liveconsole-1.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-liveconsole-1.6.1.dist-info/entry_points.txt,sha256=qtvuJHcex4QqM97x_UawFWJYnfhQRl0jhqLcWRpnAGo,84
-liveconsole-1.6.1.dist-info/top_level.txt,sha256=DlpA93ScJbRZcF8kGSc5YoO8Ntu1ib1_MEZMb4xea_Q,7
-liveconsole-1.6.1.dist-info/RECORD,,

liveconsole-1.6.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-pysole