liveConsole 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

liveconsole-1.7.7.dist-info/METADATA

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: liveConsole
+Version: 1.7.7
+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.5.dist-info → liveconsole-1.7.7.dist-info}/RECORD

@@ -1,19 +1,19 @@
 liveConsole/__init__.py,sha256=GyV_Y3iiiS12JoEiqE55uZPQ8ZDYfOSKvxh5rcfaD1U,20
-liveconsole-1.7.5.dist-info/licenses/LICENSE,sha256=7dZ0zL72aGaFE0C9DxacOpnaSkC5jajhG6iL7lqhWmU,1064
+liveconsole-1.7.7.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=t_ijaSm2rTxM5CrLqjxT5Oq_OFwxk7JsPOAXxo9dbdE,15357
-pysole/pysole.py,sha256=OdENWPZnchn_DbYGdcb7WULumYM1NxQmwe9DJzPb0xY,12707
+pysole/pysole.py,sha256=8hDTU7wRcWvg3Hsnz84o1HXoy69nrFgSMyCAJnGitb0,13778
 pysole/settings.json,sha256=cmOtIhRDWHMwmQMESuykWuzJd_jG6iT2tJ-uhSps_3U,722
 pysole/styledTextbox.py,sha256=qWnwGAKjl7R2HYPXQOr8GrGYIr4JC8PzmeioOCH7hGo,2236
-pysole/suggestionManager.py,sha256=EUFeCQoZnLS8EjPPNuZpzjY0BR07m2KP5TloyaMDVGY,6457
+pysole/suggestionManager.py,sha256=CGR1wsRIU4le3Bq_6CPAytM1CzTQAV_jUl5KZbg9LPU,6544
 pysole/themes.json,sha256=2KvEfxm-eDsfVKIdBhWk-Qd93wYQub3YwkxbS6CGKH0,2525
-pysole/utils.py,sha256=cBjS3KxDCuVr4Wa8up0eH493cLky9_CFImO-kaiWakQ,339
-liveconsole-1.7.5.dist-info/METADATA,sha256=VuazaRtDpU5esWJ2St-l2LwKY5-75J_umHcwBuk4XwE,5087
-liveconsole-1.7.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-liveconsole-1.7.5.dist-info/entry_points.txt,sha256=qtvuJHcex4QqM97x_UawFWJYnfhQRl0jhqLcWRpnAGo,84
-liveconsole-1.7.5.dist-info/top_level.txt,sha256=YGhC2H7bvcDnMwEtvLXF6qQNIZT2Saayyk1KOJyndN8,19
-liveconsole-1.7.5.dist-info/RECORD,,
+pysole/utils.py,sha256=cKsSPWeYRxPhkiM8Xrb-aMW6w0SU5Xuu9WCgsu6_xtA,1364
+liveconsole-1.7.7.dist-info/METADATA,sha256=gUfCtoVEBonZ-rH3dJz3GOHsIgEdPZxgDJBUHOk2RTI,10407
+liveconsole-1.7.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+liveconsole-1.7.7.dist-info/entry_points.txt,sha256=qtvuJHcex4QqM97x_UawFWJYnfhQRl0jhqLcWRpnAGo,84
+liveconsole-1.7.7.dist-info/top_level.txt,sha256=YGhC2H7bvcDnMwEtvLXF6qQNIZT2Saayyk1KOJyndN8,19
+liveconsole-1.7.7.dist-info/RECORD,,

pysole/pysole.py

@@ -8,7 +8,7 @@ import sys
 import io
 import json
 
-from .utils import settingsPath, themesPath, stdPrint
+from .utils import settingsPath, themesPath, stdPrint, normalizeWhitespace, findUnindentedLine
 from .helpTab import HelpTab
 from .mainConsole import InteractiveConsoleText
 
@@ -73,6 +73,7 @@ class InteractiveConsole(ctk.CTk):
             if userLocals is None:
                 userLocals = callerFrame.f_locals
 
+        self.callerFrame = callerFrame
         self.userGlobals = userGlobals
         self.userLocals = userLocals
 
@@ -87,20 +88,30 @@ class InteractiveConsole(ctk.CTk):
         self.runRemainingCode = runRemainingCode
         self.printStartupCode = printStartupCode
         self.removeWaterMark = removeWaterMark
-        self.startupCode = ()
+        self.startupCode = []
         if runRemainingCode:
-            code_obj = callerFrame.f_code
-            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()
-
-            startLineIndex = callerFrame.f_lineno
-            startLine = lines[startLineIndex - 1]
-            leadingWhitespaceLen = len(startLine) - len(startLine.lstrip())
-            self.startupCode = lines[startLineIndex:]
-            self.startupCode = [line.rstrip()[leadingWhitespaceLen:] for line in self.startupCode]
+            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."""
@@ -327,7 +338,8 @@ class InteractiveConsole(ctk.CTk):
         self.mainloop(*args, **kwargs)
 
 def probe(userGlobals=None, userLocals=None, callerFrame=None,
-          runRemainingCode=False, printStartupCode=False, **kwargs):
+          runRemainingCode=False, printStartupCode=False,
+          primaryPrompt=None, font=None, fontSize=None, **kwargs):
     if callerFrame == None:
         callerFrame = inspect.currentframe().f_back
     InteractiveConsole(userGlobals=userGlobals,
@@ -335,6 +347,10 @@ def probe(userGlobals=None, userLocals=None, callerFrame=None,
                               callerFrame=callerFrame,
                               runRemainingCode=runRemainingCode,
                               printStartupCode=printStartupCode,
+                              primaryPrompt=primaryPrompt,
+                              font=font,
+                              fontSize=fontSize,
+                              removeWaterMark=False,
                               **kwargs).probe()
 
 def _standalone():

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/utils.py

@@ -1,5 +1,6 @@
 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")
@@ -10,4 +11,35 @@ def stdPrint(text):
         sys.__stdout__.write(f"{text}\n")
         sys.__stdout__.flush()
     except:
-        pass
+        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.7.5.dist-info/METADATA

@@ -1,161 +0,0 @@
-Metadata-Version: 2.4
-Name: liveConsole
-Version: 1.7.5
-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 ⭐!.
-
-## Showcase (click to watch on Youtube)
-[![Watch the demo](Showcase/thumbnail.png)](https://www.youtube.com/shorts/pjoelNjc3O0)
-
-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**
-
-*   Run code at startup for easier debugging
-    
-*   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.
-    
-### Run Code at Startup
-
-*   Pysole can automatically execute Python code when the console launches.
-
-*   Use the runRemainingCode=True argument in pysole.probe() to run all remaining lines in the calling script after the probe() call.
-
-*   The printStartupCode flag controls whether these lines are printed in the console as they execute (True) or run silently (False).
-
-*   Useful for initializing variables, importing libraries, or setting up your environment automatically.
-
-### 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()
-```
-or for also running some code at the startup of the pysole
-```
-import pysole
-pysole.probe(runRemainingCode=True,   #< for executing the code below probe
-             printStartupCode=True    #< for printing the command as well as it output
-             )
-x = 1                                 #< initialize some variable
-print(x)                              #< print the variable on the console
-```
-
-*   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.