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

{liveconsole-1.5.3.dist-info → liveconsole-1.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liveConsole
-Version: 1.5.3
+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
@@ -127,11 +127,9 @@ pysole.probe()
 
 ## Customization
 
-*   **Appearance mode**: Dark mode is default (`ctk.set_appearance_mode("dark")`)
-    
-*   **Font**: Consolas, 12pt by default, configurable in `InteractiveConsoleText` constructor
-    
-*   **Syntax Highlighting Style**: Change Pygments style by modifying `get_style_by_name("monokai")`
+*   **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.
 
 
 

liveconsole-1.6.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+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

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

pysole/__init__.py

@@ -0,0 +1 @@
+from .pysole import probe, _standalone, InteractiveConsole

pysole/__main__.py

@@ -0,0 +1,4 @@
+from .pysole import _standalone
+
+if __name__ == "__main__":
+    _standalone()

helpTab.py → pysole/helpTab.py

@@ -2,12 +2,12 @@ import sys
 import io
 from pygments.styles import get_style_by_name
 import customtkinter as ctk
-from styledTextbox import StyledTextWindow
+from .styledTextbox import StyledTextWindow
 
 class HelpTab(ctk.CTkFrame):
     """A right-hand help tab with closable and updateable text content."""
 
-    def __init__(self, parent, width=500, title="Help", **kwargs):
+    def __init__(self, parent, theme, font, width=500, title="Help", **kwargs):
         super().__init__(parent, width=width, **kwargs)
         self.parent = parent
         self.visible = False
@@ -18,16 +18,16 @@ class HelpTab(ctk.CTkFrame):
         # Header frame with title and close button
         headerFrame = ctk.CTkFrame(self, height=30)
         headerFrame.pack(fill="x")
-        self.style = get_style_by_name("monokai")
+        self.style = get_style_by_name(theme["LEXER_STYLE"])
 
-        self.titleLabel = ctk.CTkLabel(headerFrame, text=title, font=("Consolas", 12, "bold"))
+        self.titleLabel = ctk.CTkLabel(headerFrame, text=title, font=(font["FONT"], font["FONT_SIZE"], "bold"))
         self.titleLabel.pack(side="left", padx=5)
 
         self.closeButton = ctk.CTkButton(headerFrame, text="X", height=20, command=self.close)
         self.closeButton.pack(side="right", padx=5)
 
         # Scrollable text area
-        self.textBox = StyledTextWindow(self, wrap="word", font=("Consolas", 11), bg="#2e2e2e")
+        self.textBox = StyledTextWindow(self, theme, {"FONT": font["FONT"], "FONT_SIZE": max(0, (font["FONT_SIZE"]-1))}, wrap="word", bg="#2e2e2e")
         self.textBox.pack(fill="both", expand=True, padx=5, pady=5)
         self.textBox.configure(state="disabled")  # read-only
 

liveConsole.py → pysole/liveConsole.py

@@ -5,4 +5,4 @@ warnings.warn(
     stacklevel=2
 )
 
-from pysole import *
+from .pysole import *

mainConsole.py → pysole/mainConsole.py

@@ -1,22 +1,21 @@
 import threading
 import traceback
-from suggestionManager import CodeSuggestionManager
-from commandHistory import CommandHistory
-from styledTextbox import StyledTextWindow
+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)
+    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.suggestionManager = CodeSuggestionManager(self, userLocals=userLocals, userGlobals=userGlobals)
+        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

pysole/pysole.py

@@ -0,0 +1,250 @@
+import customtkinter as ctk
+import tkinter as tk
+from tkinter import messagebox
+import inspect
+import sys
+import io
+import json
+
+from .utils import settingsPath, themesPath
+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, callerFrame=None, theme=None, defaultSize=None, primaryPrompt=None):
+        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
+
+        self.title("Live Interactive Console")
+        self.geometry(self.BEHAVIOR["DEFAULT_SIZE"])
+        
+        ctk.set_appearance_mode(self.THEME["APPEARANCE"])
+        ctk.set_default_color_theme("blue")
+
+        # Get namespace from caller if not provided
+        if userGlobals is None or userLocals is None:
+            if callerFrame == 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._createMenu()
+        self._createUi()
+        
+        # Redirect stdout/stderr
+        self._setupOutputRedirect()
+        self._setupInputRedirect()
+
+    def _createMenu(self):
+        """Create a menu bar using CTkOptionMenu."""
+        menuBar = ctk.CTkFrame(self, fg_color=self.THEME["BACKGROUND"])
+        menuBar.pack(side="top", fill="x")
+
+        self.menu_var = ctk.StringVar(value="File")
+        fileMenu = ctk.CTkOptionMenu(menuBar,
+                                     values=["Edit Settings", "Load Theme"],
+                                     variable=self.menu_var,
+                                     command=self._handleMenu,
+                                     fg_color=self.THEME["BACKGROUND"],
+                                     button_color=self.THEME["BACKGROUND"],
+                                     button_hover_color=self.THEME["HIGHLIGHTED_BACKGROUND"],
+                                     dropdown_fg_color=self.THEME["BACKGROUND"],
+                                     dropdown_hover_color=self.THEME["HIGHLIGHTED_BACKGROUND"],
+                                     dropdown_text_color=self.THEME["FOREGROUND"],
+                                     text_color=self.THEME["FOREGROUND"])
+        fileMenu.pack(side="left", padx=5, pady=2)
+
+    def _handleMenu(self, choice):
+        if choice == "Edit Settings":
+            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.
+        The chosen theme will override the THEME key in settings.json
+        and apply immediately.
+        """
+
+        # Load themes from themes.json
+        try:
+            with open(themesPath, "r") as f:
+                themes = json.load(f)
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to load themes.json:\n{e}")
+            return
+
+        if not themes:
+            messagebox.showerror("Error", "No themes found in themes.json")
+            return
+
+        # Create the CTk popup window
+        popup = ctk.CTkToplevel(self)
+        popup.title("Select Theme")
+        popup.geometry("300x150")
+        popup.grab_set()
+
+        ctk.CTkLabel(popup, text="Choose a theme:").pack(pady=(10, 5))
+
+        # Dropdown with theme keys
+        themeVar = tk.StringVar(value=list(themes.keys())[0])
+        themeDropdown = ctk.CTkOptionMenu(popup, values=list(themes.keys()), variable=themeVar)
+        themeDropdown.pack(pady=5)
+
+        def applyTheme():
+            chosenKey = themeVar.get()
+            chosenTheme = themes[chosenKey]
+
+            # Update self.THEME
+            self.THEME = chosenTheme
+
+            # Save to settings.json
+            try:
+                with open(settingsPath, "r") as f:
+                    settings = json.load(f)
+                settings["THEME"] = chosenTheme
+                with open(settingsPath, "w") as f:
+                    json.dump(settings, f, indent=4)
+            except Exception as e:
+                messagebox.showerror("Error", f"Failed to save settings.json:\n{e}")
+                return
+
+            messagebox.showinfo("Theme Applied", f"Theme '{chosenKey}' applied successfully, relaunch app for changes to take effect!")
+            popup.destroy()
+
+        applyBtn = ctk.CTkButton(popup, text="Apply", command=applyTheme)
+        applyBtn.pack(pady=(10, 10))
+
+    def _editSettings(self):
+        """Open a simple JSON editor for settings.json."""
+        editor = ctk.CTkToplevel(self)
+        editor.title("Edit Settings")
+        editor.geometry("500x400")
+
+        try:
+            with open(settingsPath, "r") as f:
+                jsonText = f.read()
+        except Exception as e:
+            jsonText = f"{{}}\n\n# Failed to load settings.json:\n{e}"
+
+        textbox = ctk.CTkTextbox(editor)
+        textbox.pack(fill="both", expand=True, padx=10, pady=10)
+        textbox.insert("0.0", jsonText)
+
+        def saveSettings():
+            try:
+                newSettings = json.loads(textbox.get("0.0", "end-1c"))
+                with open("settings.json", "w") as f:
+                    json.dump(newSettings, f, indent=4)
+                messagebox.showinfo("Success", "Settings saved!")
+                editor.destroy()
+            except Exception as e:
+                messagebox.showerror("Error", f"Invalid JSON:\n{e}")
+
+        saveBtn = ctk.CTkButton(editor, text="Save", command=saveSettings)
+        saveBtn.pack(pady=5)
+
+    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, theme=self.THEME, font=self.FONT, 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,
+            theme=self.THEME,
+            font=self.FONT,
+            behavior=self.BEHAVIOR,
+            wrap="word",
+            bg=self.THEME["BACKGROUND"],
+            fg=self.THEME["FOREGROUND"],
+            insertbackground=self.THEME["INSERTBACKGROUND"]
+        )
+        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(userGlobals=None, userLocals=None, callerFrame=None):
+    if callerFrame == None:
+        callerFrame = inspect.currentframe().f_back
+    InteractiveConsole(userGlobals=userGlobals,
+                              userLocals=userLocals,
+                              callerFrame=callerFrame).probe()
+
+def _standalone():
+    import pysole
+    pysole.probe(callerFrame=inspect.currentframe().f_back)
+
+# Example usage
+if __name__ == "__main__":
+    _standalone()

pysole/settings.json

@@ -0,0 +1,25 @@
+{
+    "THEME": {
+        "APPEARANCE": "dark",
+        "LEXER_STYLE": "monokai",
+        "BACKGROUND": "#1e1e1e",
+        "HIGHLIGHTED_BACKGROUND": "#0078d7",
+        "FOREGROUND": "white",
+        "HIGHLIGHTED_FOREGROUND": "black",
+        "INSERTBACKGROUND": "white",
+        "PROMPT": "#00ff00",
+        "OUTPUT": "#ffffff",
+        "ERROR": "#ff0000",
+        "RESULT": "#66ccff",
+        "SUGGESTION_BOX_BG": "#2d2d2d",
+        "SUGGESTION_BOX_SELECTION_BG": "#0066cc",
+        "FONT": {
+            "FONT": "Consolas",
+            "FONT_SIZE": 12
+        }
+    },
+    "BEHAVIOR": {
+        "DEFAULT_SIZE": "900x600",
+        "PRIMARY_PROMPT": ">>> "
+    }
+}

styledTextbox.py → pysole/styledTextbox.py

@@ -4,29 +4,28 @@ from pygments.lexers import PythonLexer
 from pygments.styles import get_style_by_name
 
 class StyledTextWindow(tk.Text):
-    def __init__(self, master,  **kwargs):
+    def __init__(self, master, theme, font, **kwargs):
         super().__init__(master, **kwargs)
        
         # Syntax highlighting setup
         self.lexer = PythonLexer()
-        self.style = get_style_by_name("monokai")
-        
-        # Setup tags
-        self._setupTags()
+        self.style = get_style_by_name(theme["LEXER_STYLE"])
+
+        self._setupTags(theme, font)
 
-    def _setupTags(self):
+    def _setupTags(self, theme, font):
         """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))
+        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"]))
         
         # 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)
+                tagFont = (font["FONT"], font["FONT_SIZE"], "bold" if style["bold"] else "normal")
+                self.tag_configure(str(token), foreground=fg, font=tagFont)
 
 
     def updateStyling(self, start="1.0"):

suggestionManager.py → pysole/suggestionManager.py

@@ -5,7 +5,10 @@ import tkinter as tk
 class CodeSuggestionManager:
     """Manages code suggestions and autocomplete functionality."""
     
-    def __init__(self, textWidget, userLocals, userGlobals):
+    def __init__(self, textWidget, userLocals, userGlobals, theme, font):
+        self.THEME = theme
+        self.FONT = font
+
         self.userLocals = userLocals
         self.userGlobals = userGlobals
         self.textWidget = textWidget
@@ -111,14 +114,14 @@ class CodeSuggestionManager:
         """Create the suggestion popup window."""
         self.suggestionWindow = tk.Toplevel(self.textWidget)
         self.suggestionWindow.wm_overrideredirect(True)
-        self.suggestionWindow.configure(bg="#2d2d2d")
+        self.suggestionWindow.configure(bg=self.THEME["SUGGESTION_BOX_BG"])
         
         self.suggestionListbox = tk.Listbox(
             self.suggestionWindow,
-            bg="#2d2d2d",
-            fg="white",
-            selectbackground="#0066cc",
-            font=("Consolas", 10),
+            bg=self.THEME["SUGGESTION_BOX_BG"],
+            fg=self.THEME["FOREGROUND"],
+            selectbackground=self.THEME["SUGGESTION_BOX_SELECTION_BG"],
+            font=(self.FONT["FONT"], max(2, (self.FONT["FONT_SIZE"]-2))),
             height=8
         )
         self.suggestionListbox.pack()

pysole/themes.json

@@ -0,0 +1,78 @@
+{
+    "Dark": {
+        "APPEARANCE": "dark",
+        "LEXER_STYLE": "monokai",
+        "BACKGROUND": "#1e1e1e",
+        "HIGHLIGHTED_BACKGROUND": "#0078d7",
+        "FOREGROUND": "white",
+        "HIGHLIGHTED_FOREGROUND": "black",
+        "INSERTBACKGROUND": "white",
+        "PROMPT": "#00ff00",
+        "OUTPUT": "#ffffff",
+        "ERROR": "#ff0000",
+        "RESULT": "#66ccff",
+        "SUGGESTION_BOX_BG": "#2d2d2d",
+        "SUGGESTION_BOX_SELECTION_BG": "#0066cc",
+        "FONT": {
+            "FONT": "Consolas",
+            "FONT_SIZE": 12
+        }
+    },
+    "Light": {
+        "APPEARANCE": "light",
+        "LEXER_STYLE": "friendly",
+        "BACKGROUND": "#ffffff",
+        "HIGHLIGHTED_BACKGROUND": "#cce6ff",
+        "FOREGROUND": "#000000",
+        "HIGHLIGHTED_FOREGROUND": "#000000",
+        "INSERTBACKGROUND": "#000000",
+        "PROMPT": "#008000",
+        "OUTPUT": "#000000",
+        "ERROR": "#ff0000",
+        "RESULT": "#0066cc",
+        "SUGGESTION_BOX_BG": "#f0f0f0",
+        "SUGGESTION_BOX_SELECTION_BG": "#cce6ff",
+        "FONT": {
+            "FONT": "Consolas",
+            "FONT_SIZE": 12
+        }
+    },
+    "Solarized": {
+        "APPEARANCE": "light",
+        "LEXER_STYLE": "solarized-light",
+        "BACKGROUND": "#fdf6e3",
+        "HIGHLIGHTED_BACKGROUND": "#b58900",
+        "FOREGROUND": "#657b83",
+        "HIGHLIGHTED_FOREGROUND": "#fdf6e3",
+        "INSERTBACKGROUND": "#657b83",
+        "PROMPT": "#268bd2",
+        "OUTPUT": "#586e75",
+        "ERROR": "#dc322f",
+        "RESULT": "#2aa198",
+        "SUGGESTION_BOX_BG": "#eee8d5",
+        "SUGGESTION_BOX_SELECTION_BG": "#b58900",
+        "FONT": {
+            "FONT": "Consolas",
+            "FONT_SIZE": 12
+        }
+    },
+    "Dracula": {
+        "APPEARANCE": "dark",
+        "LEXER_STYLE": "dracula",
+        "BACKGROUND": "#282a36",
+        "HIGHLIGHTED_BACKGROUND": "#44475a",
+        "FOREGROUND": "#f8f8f2",
+        "HIGHLIGHTED_FOREGROUND": "#ffffff",
+        "INSERTBACKGROUND": "#f8f8f2",
+        "PROMPT": "#50fa7b",
+        "OUTPUT": "#f8f8f2",
+        "ERROR": "#ff5555",
+        "RESULT": "#8be9fd",
+        "SUGGESTION_BOX_BG": "#44475a",
+        "SUGGESTION_BOX_SELECTION_BG": "#6272a4",
+        "FONT": {
+            "FONT": "Consolas",
+            "FONT_SIZE": 12
+        }
+    }
+}

pysole/utils.py

@@ -0,0 +1,4 @@
+import os
+
+settingsPath = os.path.join(os.path.dirname(__file__), "settings.json")
+themesPath = os.path.join(os.path.dirname(__file__), "themes.json")

liveconsole-1.5.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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=bkwnzm2BLZMOiA63cI27FLnXmcOMpDdZVCnfOgP-GoU,4018
-styledTextbox.py,sha256=pc-7gaq_pGTZGZmtr_ARbPuKlKgJYqzD6HTR7tFhx7k,1989
-suggestionManager.py,sha256=GRde3c1gFAWt_3rvBoFt_-Xl0aOzzloBMD7MHJA2W8U,6256
-liveconsole-1.5.3.dist-info/licenses/LICENSE,sha256=7dZ0zL72aGaFE0C9DxacOpnaSkC5jajhG6iL7lqhWmU,1064
-liveconsole-1.5.3.dist-info/METADATA,sha256=Ad_v6Vo0ZFdUU9WDUftPe7tHVggvslTi94RUeNZbd1k,3936
-liveconsole-1.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-liveconsole-1.5.3.dist-info/entry_points.txt,sha256=qtvuJHcex4QqM97x_UawFWJYnfhQRl0jhqLcWRpnAGo,84
-liveconsole-1.5.3.dist-info/top_level.txt,sha256=yEmcEVam34LgZbQWtT6RdrdJVzsXwElx6Wpsn3eR2as,95
-liveconsole-1.5.3.dist-info/RECORD,,

liveconsole-1.5.3.dist-info/top_level.txt

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

pysole.py

@@ -1,126 +0,0 @@
-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, callerFrame=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:
-            if callerFrame == 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(userGlobals=None, userLocals=None, callerFrame=None):
-    if callerFrame == None:
-        callerFrame = inspect.currentframe().f_back
-    InteractiveConsole(userGlobals=userGlobals,
-                              userLocals=userLocals,
-                              callerFrame=callerFrame).probe()
-
-def _standalone():
-    import pysole
-    pysole.probe(callerFrame=inspect.currentframe().f_back)
-
-# Example usage
-if __name__ == "__main__":
-    _standalone()