clicanvas 0.2__tar.gz

clicanvas-0.2/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: clicanvas
+Version: 0.2
+Summary: A python library that deals with terminal-based user input. From a TUI framework to custom input functions.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: inputkit>=1.0.2
+Requires-Dist: regex>=2026.2.28
+Provides-Extra: thonny
+
+# CLICanvas
+
+CLICanvas is a python library that deals with terminal-based user input.
+From a TUI framework to custom input functions.
+
+## Features
+
+- Custom input function and modes, including a mirror of readline and getpass

clicanvas-0.2/README.md

@@ -0,0 +1,8 @@
+# CLICanvas
+
+CLICanvas is a python library that deals with terminal-based user input.
+From a TUI framework to custom input functions.
+
+## Features
+
+- Custom input function and modes, including a mirror of readline and getpass

clicanvas-0.2/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clicanvas"
+version = "0.2"
+description = "A python library that deals with terminal-based user input. From a TUI framework to custom input functions."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "inputkit>=1.0.2",
+    "regex>=2026.2.28",
+]
+
+[project.optional-dependencies]
+thonny = []
+
+[tool.uv.sources]
+tester = { git = "https://github.com/Minemario64/Testing-Suite.git" }
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = []

clicanvas-0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

clicanvas-0.2/src/clicanvas/__init__.py

@@ -0,0 +1,101 @@
+from importlib.metadata import metadata
+import os
+
+def isOptionFlagEnabled(flag: str) -> bool:
+    try:
+        m = metadata("clicanvas")
+        requested = m.get_all("Provides-Extra") or []
+        return flag in requested
+
+    except Exception:
+        return False
+
+if os.name == "nt" and isOptionFlagEnabled("thonny"):
+    import os, sys, subprocess
+    import ctypes, ctypes.wintypes as wintypes
+
+    @lambda _: _()
+    def ensureOutOfThonny():
+        if sys.stdout.__class__.__name__ == "FakeOutputStream":
+            subprocess.Popen(["python", os.path.abspath(sys.argv[0])], creationflags=subprocess.CREATE_NEW_CONSOLE)
+            print("Re-launching in external console...")
+            exit()
+
+    def isANSIEnabled():
+        kernel32 = ctypes.windll.kernel32
+        h = kernel32.GetStdHandle(-11)   # STD_OUTPUT_HANDLE = -11
+        mode = ctypes.c_uint()
+        if kernel32.GetConsoleMode(h, ctypes.byref(mode)) == 0:
+            return False
+
+        return bool(mode.value & 0x0004) # ENABLE_VIRTUAL_TERMINAL_PROCESSING
+
+    def enableANSI():
+        kernel32 = ctypes.windll.kernel32
+        h = kernel32.GetStdHandle(-11)
+        mode = ctypes.c_uint()
+        kernel32.GetConsoleMode(h, ctypes.byref(mode))
+        kernel32.SetConsoleMode(h, mode.value | 0x0004)
+
+    if not isANSIEnabled():
+        enableANSI()
+
+    class COORD(ctypes.Structure):
+        _fields_ = [("X", wintypes.SHORT),
+                    ("Y", wintypes.SHORT)]
+
+    class SMALL_RECT(ctypes.Structure):
+        _fields_ = [("Left", wintypes.SHORT),
+                    ("Top", wintypes.SHORT),
+                    ("Right", wintypes.SHORT),
+                    ("Bottom", wintypes.SHORT)]
+
+    class CONSOLE_SCREEN_BUFFER_INFOEX(ctypes.Structure):
+        _fields_ = [
+            ("cbSize", wintypes.ULONG),
+            ("dwSize", COORD),
+            ("dwCursorPosition", COORD),
+            ("wAttributes", wintypes.WORD),
+            ("srWindow", SMALL_RECT),
+            ("dwMaximumWindowSize", COORD),
+            ("wPopupAttributes", wintypes.WORD),
+            ("bFullscreenSupported", wintypes.BOOL),
+            ("ColorTable", wintypes.DWORD * 16)
+        ]
+
+    kernel32 = ctypes.windll.kernel32
+    STDOUT = -11
+    handle = kernel32.GetStdHandle(STDOUT)
+
+    info = CONSOLE_SCREEN_BUFFER_INFOEX()
+    info.cbSize = ctypes.sizeof(CONSOLE_SCREEN_BUFFER_INFOEX)
+
+    kernel32.GetConsoleScreenBufferInfoEx(handle, ctypes.byref(info))
+
+    def rgb(r: int, g: int, b: int) -> int:
+        return (b << 16) | (g << 8) | r
+
+    # Color Palette
+    info.ColorTable[0] = rgb(24, 31, 40)
+    info.ColorTable[4] = rgb(186, 7, 50)
+    info.ColorTable[2] = rgb(26, 122, 62)
+    info.ColorTable[6] = rgb(249, 163, 27)
+    info.ColorTable[1] = rgb(40, 92, 196)
+    info.ColorTable[5] = rgb(102, 25, 174)
+    info.ColorTable[3] = rgb(0, 130, 125)
+    info.ColorTable[7] = rgb(139, 147, 175)
+    info.ColorTable[8] = rgb(51, 57, 65)
+    info.ColorTable[12] = rgb(235, 58, 100)
+    info.ColorTable[10] = rgb(57, 219, 117)
+    info.ColorTable[14] = rgb(255, 252, 64)
+    info.ColorTable[9] = rgb(36, 159, 222)
+    info.ColorTable[13] = rgb(161, 47, 215)
+    info.ColorTable[11] = rgb(40, 194, 149)
+    info.ColorTable[15] = rgb(255, 255, 255)
+
+    info.wAttributes = 0x07
+
+    kernel32.SetConsoleScreenBufferInfoEx(handle, ctypes.byref(info))
+
+    sys.stdout.write("\x1b[2J\x1b[3J\x1b[H")
+    sys.stdout.flush()

clicanvas-0.2/src/clicanvas/input/__init__.py

@@ -0,0 +1,22 @@
+from .base import input as input
+from .readline import input as readline, loadHistory, saveHistory, maxHistory
+from .getpass import input as getpass
+from .confirm import input as confirm
+
+__all__ = ["input", "readline", "loadHistory", "saveHistory", "getpass", "confirm", "customInput", "getpassConfirm", "getpassCheck", "maxHistory"] # pyright: ignore[reportUnsupportedDunderAll]
+
+def __getattr__(name: str):
+    match name:
+        case "customInput":
+            from .base import customInput
+            return customInput
+
+        case "getpassConfirm":
+            from .getpass import confirm
+            return confirm
+
+        case "getpassCheck":
+            from .getpass import check
+            return check
+
+    raise AttributeError(name=name)

clicanvas-0.2/src/clicanvas/input/base.py

@@ -0,0 +1,119 @@
+from inputkit import Key, handleInput
+from typing import Callable, overload, Any
+from io import StringIO
+import sys
+
+VERSION = "1.0.0"
+
+_ANSI_START = "\x1b["
+
+def input(prompt: str, voidCtrlC: bool = True) -> str:
+    sys.stdout.write(prompt)
+    sys.stdout.flush()
+    inputBuf: StringIO = StringIO()
+    cur: int = 0
+    @handleInput(hideCursor=False)
+    def inpHandler(key: Key | str) -> bool:
+        nonlocal cur
+        if isinstance(key, str):
+            inputBuf.write(key)
+            cur += 1
+            sys.stdout.write(key)
+            sys.stdout.flush()
+            return True
+
+        match key:
+            case Key.BACKSPACE:
+                forwardInput = inputBuf.read()
+                cur -= 1
+                if cur == -1:
+                    cur = 0
+                    return True
+
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+                sys.stdout.write(f"{_ANSI_START}D{' '*(len(forwardInput)+1)}{_ANSI_START}{len(forwardInput)+1}D{f'{forwardInput}{_ANSI_START}{len(forwardInput)}D' if forwardInput else ''}")
+                sys.stdout.flush()
+
+            case Key.DEL:
+                inputBuf.seek(cur+1)
+                forwardInput = inputBuf.read()
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+                sys.stdout.write(f"{' '*(len(forwardInput)+1)}{_ANSI_START}{len(forwardInput)+1}D{f'{forwardInput}{_ANSI_START}{len(forwardInput)}D' if forwardInput else ''}")
+                sys.stdout.flush()
+
+            case Key.ENTER:
+                return False
+
+            case Key.CTRL_C:
+                if not voidCtrlC:
+                    raise KeyboardInterrupt
+
+            case Key.RIGHT:
+                inputBuf.seek(0, 2)
+                bufLength = inputBuf.tell()
+                if cur == bufLength:
+                    return True
+
+                cur += 1
+                inputBuf.seek(cur)
+                sys.stdout.write("\x1b[C")
+                sys.stdout.flush()
+
+            case Key.LEFT:
+                cur -= 1
+                if cur < 0:
+                    cur = 0
+
+                else:
+                    inputBuf.seek(cur)
+                    sys.stdout.write("\x1b[D")
+                    sys.stdout.flush()
+
+        return True
+
+    print()
+
+    res = inputBuf.getvalue()
+
+    return res
+
+@overload
+def customInput(prompt: str, validators: list[Callable[[str], bool]], failResponse: str = "Try Again.",*, inputFunc: Callable[[str], str] = input) -> str: ...
+
+@overload
+def customInput(prompt: str, validators: list[Callable[[str], bool]], failResponse: str = "Try Again.",*, transformers: list[Callable], inputFunc: Callable[[str], str] = input) -> Any: ...
+
+def customInput(prompt: str, validators: list[Callable[[str], bool]], failResponse: str = "Try Again.",*, inputFunc: Callable[[str], str] = input, transformers: list[Callable] | None = None) -> str | Any:
+    while True:
+        inp = inputFunc(prompt)
+        if all([validator(inp) for validator in validators]):
+            break
+
+        print(failResponse)
+
+    if transformers is None:
+        return inp
+
+    res: Any = inp
+    for transformer in transformers:
+        res = transformer(res)
+
+    return res
+
+if __name__ == "__main__":
+    print(repr(input("Hello: ")))
+    def isInt(input: str) -> bool:
+        try:
+            int(input)
+            return True
+
+        except Exception:
+            return False
+
+    print(customInput("Input an integer: ", [isInt], "Input an integer. Try Again.", transformers=[int]))

clicanvas-0.2/src/clicanvas/input/confirm.py

@@ -0,0 +1,18 @@
+from .base import customInput
+
+VERSION = "1.0.0"
+
+def isYesOrNo(text: str) -> bool:
+    if text.lower() in ['y', "n", "ye", "no", "yes", "yea", "yeah", "noo"]:
+        return True
+
+    return False
+
+def strToBool(text: str) -> bool:
+    if text in ['y', 'ye', 'yes', 'yea', 'yeah']:
+        return True
+
+    return False
+
+def input(prompt: str) -> bool:
+    return customInput(prompt, [isYesOrNo], "Must be yes or no. Try Again", transformers=[lambda text: text.lower(), strToBool])

clicanvas-0.2/src/clicanvas/input/constrained.py

@@ -0,0 +1,96 @@
+from inputkit import Key, handleInput
+from io import StringIO
+import sys
+import regex as rgx
+
+VERSION = "1.0.0"
+
+_ANSI_START = "\x1b["
+
+def input(prompt: str, rgxRestrictions: list[rgx.Pattern], voidCtrlC: bool = True) -> str:
+    sys.stdout.write(prompt)
+    sys.stdout.flush()
+    inputBuf: StringIO = StringIO()
+    cur: int = 0
+    @handleInput(hideCursor=False)
+    def inpHandler(key: Key | str) -> bool:
+        nonlocal cur
+        if isinstance(key, str):
+            cur += 1
+            inputBuf.write(key)
+            if not any([pattern.match(inputBuf.getvalue(), partial=True) for pattern in rgxRestrictions]):
+                cur -= 1
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                return True
+
+            sys.stdout.write(key)
+            sys.stdout.flush()
+            return True
+
+        match key:
+            case Key.BACKSPACE:
+                forwardInput = inputBuf.read()
+                cur -= 1
+                if cur == -1:
+                    cur = 0
+                    return True
+
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+                sys.stdout.write(f"{_ANSI_START}D{' '*(len(forwardInput)+1)}{_ANSI_START}{len(forwardInput)+1}D{f'{forwardInput}{_ANSI_START}{len(forwardInput)}D' if forwardInput else ''}")
+                sys.stdout.flush()
+
+            case Key.DEL:
+                inputBuf.seek(cur+1)
+                forwardInput = inputBuf.read()
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+                sys.stdout.write(f"{' '*(len(forwardInput)+1)}{_ANSI_START}{len(forwardInput)+1}D{f'{forwardInput}{_ANSI_START}{len(forwardInput)}D' if forwardInput else ''}")
+                sys.stdout.flush()
+
+            case Key.ENTER:
+                if not any([pattern.match(inputBuf.getvalue(), partial=True) for pattern in rgxRestrictions]):
+                    return True
+
+                return False
+
+            case Key.CTRL_C:
+                if not voidCtrlC:
+                    raise KeyboardInterrupt
+
+            case Key.RIGHT:
+                inputBuf.seek(0, 2)
+                bufLength = inputBuf.tell()
+                if cur == bufLength:
+                    return True
+
+                cur += 1
+                inputBuf.seek(cur)
+                sys.stdout.write("\x1b[C")
+                sys.stdout.flush()
+
+            case Key.LEFT:
+                cur -= 1
+                if cur < 0:
+                    cur = 0
+
+                else:
+                    inputBuf.seek(cur)
+                    sys.stdout.write("\x1b[D")
+                    sys.stdout.flush()
+
+        return True
+
+    print()
+
+    res = inputBuf.getvalue()
+
+    return res
+
+if __name__ == "__main__":
+    print(repr(input("Hello: ", [rgx.compile(r"rock", rgx.I), rgx.compile(r"paper", rgx.I), rgx.compile(r"scissors", rgx.I)])))

clicanvas-0.2/src/clicanvas/input/getpass.py

@@ -0,0 +1,110 @@
+from inputkit import Key, handleInput
+from typing import overload
+from io import StringIO
+import sys
+
+VERSION = "1.0.0"
+
+_ANSI_START = "\x1b["
+
+def input(prompt: str = "Password: ", voidCtrlC: bool = True) -> str:
+    sys.stdout.write(prompt)
+    sys.stdout.flush()
+    inputBuf: StringIO = StringIO()
+    cur: int = 0
+    @handleInput(hideCursor=True)
+    def inpHandler(key: Key | str) -> bool:
+        nonlocal cur
+        if isinstance(key, str):
+            inputBuf.write(key)
+            cur += 1
+            return True
+
+        match key:
+            case Key.BACKSPACE:
+                forwardInput = inputBuf.read()
+                cur -= 1
+                if cur == -1:
+                    cur = 0
+                    return True
+
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+
+            case Key.DEL:
+                inputBuf.seek(cur+1)
+                forwardInput = inputBuf.read()
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+
+            case Key.ENTER:
+                return False
+
+            case Key.CTRL_C:
+                if not voidCtrlC:
+                    raise KeyboardInterrupt
+
+            case Key.RIGHT:
+                inputBuf.seek(0, 2)
+                bufLength = inputBuf.tell()
+                if cur == bufLength:
+                    return True
+
+                cur += 1
+                inputBuf.seek(cur)
+
+            case Key.LEFT:
+                cur -= 1
+                if cur < 0:
+                    cur = 0
+
+                else:
+                    inputBuf.seek(cur)
+
+        return True
+
+    print()
+
+    res = inputBuf.getvalue()
+
+    return res
+
+@overload
+def confirm() -> str: ...
+
+@overload
+def confirm(prompt: str = "Password: ", confirmPrompt: str = "Confirm password: ") -> str: ...
+
+@overload
+def confirm(prompt: str = "Password: ", confirmPrompt: str = "Confirm password: ", retry: bool = False) -> str | None: ...
+
+def confirm(prompt: str = "Password: ", confirmPrompt: str = "Confirm password: ", retry: bool = True) -> str | None:
+    while True:
+        password: str = input(prompt)
+        confirmedPassword: str = input(confirmPrompt)
+        if not (password == confirmedPassword):
+            if not retry:
+                return None
+
+        else:
+            break
+
+    return password
+
+def check(password: str, prompt: str = "Password: ", tries: int = 3, color: bool = True) -> bool:
+    for attempt in range(tries):
+        attemptedInput = input(prompt)
+        if attemptedInput == password:
+            return True
+
+        if attempt < tries - 1:
+            print(f"{f'{_ANSI_START}31m' if color else ''}Incorrect. Try Again{f'{_ANSI_START}0m' if color else ''}")
+
+    return False
+
+if __name__ == "__main__":
+    password = check("123456")

clicanvas-0.2/src/clicanvas/input/readline.py

@@ -0,0 +1,237 @@
+from inputkit import Key, handleInput
+from typing import Iterable, overload, Any, TextIO
+from pathlib import Path
+from io import StringIO
+import sys
+
+VERSION = "1.0.0"
+
+_ANSI_START = "\x1b["
+
+class maxList(list):
+    @overload
+    def __init__(self,*, maxLen: int = 50) -> None: ...
+
+    @overload
+    def __init__(self, iterable: Iterable,*, maxLen: int = 50) -> None: ...
+
+    def __init__(self, iterable: Iterable | None = None,*, maxLen: int = 50) -> None:
+        self.__maxLen: int = maxLen
+        if iterable is None:
+            super().__init__()
+        else:
+            super().__init__(iterable)
+
+    def changeMaxLen(self, value: int) -> None:
+        self.__maxLen = value
+        if len(self) > self.__maxLen:
+            while len(self) > self.__maxLen:
+                self.pop(0)
+
+    def shiftUntilLen(self, length: int) -> None:
+        while len(self) > length:
+            self.pop()
+
+    def append(self, object: Any) -> None:
+        if len(self) >= self.__maxLen:
+            self.shiftUntilLen(self.__maxLen - 1)
+
+        return super().insert(0, object)
+
+    def extend(self, iterable: Iterable) -> None:
+        if len(iterable) > self.__maxLen: # pyright: ignore[reportArgumentType]
+            raise ValueError("Iterable too large")
+
+        elif len(iterable) == self.__maxLen: # pyright: ignore[reportArgumentType]
+            self.clear()
+            super().extend(iterable)
+
+        if (len(self) + len(iterable)) >= self.__maxLen: # pyright: ignore[reportArgumentType]
+            self.shiftUntilLen(len(self) - len(iterable)) # pyright: ignore[reportArgumentType]
+
+        self.reverse()
+        super().extend(iterable)
+        self.reverse()
+
+_HIST = maxList([])
+
+@overload
+def maxHistory() -> int: ...
+
+@overload
+def maxHistory(value: int) -> None: ...
+
+def maxHistory(value: int | None = None) -> int | None:
+    if value is None:
+        return _HIST._maxList__maxLen # pyright: ignore[reportAttributeAccessIssue]
+
+    else:
+        _HIST.changeMaxLen(value)
+
+def loadHistory(file: str | Path | TextIO) -> None:
+    if isinstance(file, Path):
+        if not file.is_file():
+            raise ValueError("Path object must be a file.")
+
+    if isinstance(file, str | Path):
+        with (open(file, "r", encoding='utf8') if isinstance(file, str) else file.open("r", encoding='utf8')) as fileObj:
+            _HIST.clear()
+            _HIST.extend(fileObj.read().splitlines())
+
+        return
+
+    elif isinstance(file, TextIO):
+        _HIST.clear()
+        cursor: int = file.tell()
+        file.seek(0)
+        _HIST.extend(file.read().splitlines())
+        file.seek(cursor)
+
+def saveHistory(filepath: str | Path) -> None:
+    if isinstance(filepath, Path):
+        if filepath.is_dir():
+            raise ValueError("Path must be able to be a file.")
+
+    if not (pathObj := (Path().joinpath(filepath) if isinstance(filepath, str) else filepath)).exists():
+        pathObj.touch()
+
+    with pathObj.open("w") as file:
+        file.write("\n".join(_HIST))
+
+def input(prompt: str, voidCtrlC: bool = True, connectHistory: bool = True) -> str:
+    sys.stdout.write(prompt)
+    sys.stdout.flush()
+    newInputText: str = ''
+    inputBuf: StringIO = StringIO()
+    cur: int = 0
+    historyIdx: int = -1
+    @handleInput(hideCursor=False)
+    def inpHandler(key: Key | str) -> bool:
+        nonlocal newInputText
+        nonlocal cur
+        nonlocal historyIdx
+        if isinstance(key, str):
+            inputBuf.write(key)
+            cur += 1
+            sys.stdout.write(key)
+            sys.stdout.flush()
+            return True
+
+        match key:
+            case Key.BACKSPACE:
+                forwardInput = inputBuf.read()
+                cur -= 1
+                if cur == -1:
+                    cur = 0
+                    return True
+
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+                sys.stdout.write(f"{_ANSI_START}D{' '*(len(forwardInput)+1)}{_ANSI_START}{len(forwardInput)+1}D{f'{forwardInput}{_ANSI_START}{len(forwardInput)}D' if forwardInput else ''}")
+                sys.stdout.flush()
+
+            case Key.DEL:
+                inputBuf.seek(cur+1)
+                forwardInput = inputBuf.read()
+                inputBuf.seek(cur)
+                inputBuf.truncate()
+                inputBuf.write(forwardInput)
+                inputBuf.seek(cur)
+                sys.stdout.write(f"{' '*(len(forwardInput)+1)}{_ANSI_START}{len(forwardInput)+1}D{f'{forwardInput}{_ANSI_START}{len(forwardInput)}D' if forwardInput else ''}")
+                sys.stdout.flush()
+
+            case Key.ENTER:
+                return False
+
+            case Key.CTRL_C:
+                if not voidCtrlC:
+                    raise KeyboardInterrupt
+
+            case Key.RIGHT:
+                inputBuf.seek(0, 2)
+                bufLength = inputBuf.tell()
+                if cur == bufLength:
+                    return True
+
+                cur += 1
+                inputBuf.seek(cur)
+                sys.stdout.write("\x1b[C")
+                sys.stdout.flush()
+
+            case Key.LEFT:
+                cur -= 1
+                if cur < 0:
+                    cur = 0
+
+                else:
+                    inputBuf.seek(cur)
+                    sys.stdout.write("\x1b[D")
+                    sys.stdout.flush()
+
+            case Key.UP | Key.DOWN:
+                if connectHistory:
+                    if historyIdx == -1:
+                        newInputText = inputBuf.getvalue()
+
+                    historyIdx += 1 if key == Key.UP else -1
+                    if historyIdx < -1:
+                        historyIdx = -1
+                        return True
+
+                    elif historyIdx == -1:
+                        inputBuf.seek(0, 2)
+                        bufLength = inputBuf.tell()
+                        inputBuf.seek(cur)
+
+                        # chr(32) is space, is there because of a syntax error for 3.10
+                        sys.stdout.write(f"{f'{_ANSI_START}{bufLength}D{chr(32)*bufLength}{_ANSI_START}{bufLength}D' if bufLength > 0 else ''}{newInputText}")
+                        sys.stdout.flush()
+
+                        inputBuf.seek(0)
+                        inputBuf.truncate(0)
+                        inputBuf.write(newInputText)
+                        cur = inputBuf.tell()
+                        return True
+
+                    try:
+                        inputBuf.seek(0, 2)
+                        bufLength = inputBuf.tell()
+                        inputBuf.seek(cur)
+
+                        # chr(32) is space, is there because of a syntax error for 3.10
+                        sys.stdout.write(f"{f'{_ANSI_START}{bufLength}D{chr(32)*bufLength}{_ANSI_START}{bufLength}D' if bufLength > 0 else ''}{_HIST[historyIdx]}")
+                        sys.stdout.flush()
+
+                        inputBuf.seek(0)
+                        inputBuf.truncate(0)
+                        inputBuf.write(_HIST[historyIdx])
+                        cur = inputBuf.tell()
+
+                    except IndexError:
+                        historyIdx += 1
+
+        return True
+
+    print()
+
+    res = inputBuf.getvalue()
+    if connectHistory:
+        _HIST.append(res)
+
+    return res
+
+if __name__ == "__main__":
+    loadHistory(".hist")
+    import time
+    name = input("Name: ", connectHistory=False)
+    print(f"Hello, {name}!")
+
+    time.sleep(1)
+    confirm = input("Confirm?(y/n): ", connectHistory=False)
+    print("Confirmed!" if confirm in ["y", "yes", "ye", "yea", "yeah"] else "Denied.")
+
+    while True:
+        input(": ", voidCtrlC=False)
+        saveHistory(".hist")

clicanvas-0.2/src/clicanvas/microwidgets/__init__.py

@@ -0,0 +1,7 @@
+from .menu import menu
+from .checkbox import checkbox, CheckboxChoice
+from .incrementer import numInput
+from .slider import percent
+from ._lib import ANSIColor, HighlightMode
+
+__all__ = ["menu", "checkbox", "CheckboxChoice", "numInput", "percent", "ANSIColor", "HighlightMode"]

clicanvas-0.2/src/clicanvas/microwidgets/_lib.py

@@ -0,0 +1,26 @@
+from enum import IntEnum
+
+class ANSIColor(IntEnum):
+    BLACK = 30
+    RED = 31
+    GREEN = 32
+    YELLOW = 33
+    BLUE = 34
+    MAGENTA = 35
+    CYAN = 36
+    WHITE = 37
+    BRIGHT_BLACK = 90
+    BRIGHT_RED = 91
+    BRIGHT_GREEN = 92
+    BRIGHT_YELLOW = 93
+    BRIGHT_BLUE = 94
+    BRIGHT_MAGENTA = 95
+    BRIGHT_CYAN = 96
+    BRIGHT_WHITE = 97
+
+class HighlightMode(IntEnum):
+    INVERT = 7
+    COLOR = 0
+    BOLD = 1
+
+_ANSI_START = "\x1b["

clicanvas-0.2/src/clicanvas/microwidgets/checkbox.py

@@ -0,0 +1,70 @@
+from inputkit import Key, handleInput
+from ._lib import ANSIColor, HighlightMode, _ANSI_START
+from dataclasses import dataclass
+from typing import Callable
+import sys
+
+def runImmediately(func: Callable) -> Callable:
+    func()
+    return func
+
+@dataclass
+class CheckboxChoice:
+    choice: object
+    selected: bool = False
+
+VERSION = "1.0.0"
+
+def checkbox(prompt: str, choices: list[CheckboxChoice], cursor: str = ">", color: ANSIColor | tuple[int, int, int] | None = None, highlightMode: HighlightMode = HighlightMode.INVERT, keepOnScreen: bool = False) -> list[object]:
+    if not choices:
+        return []
+
+    pos: int = 0
+    colorStr: str = f"\x1b[{color.value}m" if isinstance(color, ANSIColor) else f"\x1b[38;2;{color[0]};{color[1]};{color[2]}m" if isinstance(color, tuple) else ''
+
+    @runImmediately
+    def draw() -> None:
+        sys.stdout.write(f"{prompt}\r\n")
+
+        for i, choice in enumerate(choices):
+            sys.stdout.write(f"{colorStr if not (highlightMode == highlightMode.COLOR) else ''}{cursor if i == pos else " "*len(cursor)} {(f'{_ANSI_START}7m' if highlightMode == HighlightMode.INVERT else colorStr if highlightMode == highlightMode.COLOR else f"{_ANSI_START}1m" if highlightMode == highlightMode.BOLD else '') if i == pos else ""} [{"X" if choice.selected else " "}] {choice.choice} {f'{_ANSI_START}0m' if (colorStr) or (i == pos) else ""}\r\n")
+
+        sys.stdout.write(f"\r\n{colorStr if not (highlightMode == highlightMode.COLOR) else ''}{cursor if pos == len(choices) else " "*len(cursor)} {(f'{_ANSI_START}7m' if highlightMode == HighlightMode.INVERT else colorStr if highlightMode == highlightMode.COLOR else f"{_ANSI_START}1m" if highlightMode == highlightMode.BOLD else '') if pos == len(choices) else ""} Confirm {f'{_ANSI_START}0m' if (colorStr) or (pos == len(choices)) else ""}\r\n")
+
+        sys.stdout.flush()
+
+    @handleInput
+    def inputHandler(key: Key | str) -> bool:
+        nonlocal pos
+        match (key.lower() if isinstance(key, str) else key):
+            case Key.CTRL_Q | "q":
+                return False
+
+            case Key.UP | Key.DOWN:
+                pos = (pos + (-1 if key == Key.UP else 1)) % (len(choices) + 1)
+
+            case Key.ENTER:
+                if pos == len(choices):
+                    return False
+
+                choices[pos].selected = not choices[pos].selected
+
+        sys.stdout.write(f"\x1b[{len(choices)+3}A")
+        sys.stdout.flush()
+        draw()
+
+        return True
+
+    if not keepOnScreen:
+        for _ in range(len(choices) + 3):
+            sys.stdout.write(f"\x1b[A\x1b[2K")
+
+        sys.stdout.flush()
+
+    return [choice.choice for choice in choices if choice.selected]
+
+if __name__ == "__main__":
+    print(checkbox("Select Features:", [
+        CheckboxChoice("Math", True),
+        CheckboxChoice("Logging")
+    ], cursor="►", color=ANSIColor.BRIGHT_GREEN, highlightMode=HighlightMode.COLOR))

clicanvas-0.2/src/clicanvas/microwidgets/incrementer.py

@@ -0,0 +1,61 @@
+from inputkit import handleInput, Key
+import sys
+
+def _inSlice(s: slice, n: int):
+    start = s.start or 0
+    step = s.step or 1
+    stop = s.stop
+
+    if stop is None:
+        if step > 0:
+            return n >= start and (n - start) % step == 0
+
+        else:
+            return n <= start and (start - n) % (-step) == 0
+
+    if step > 0:
+        return start <= n < stop and (n - start) % step == 0
+    else:
+        return stop < n <= start and (start - n) % (-step) == 0
+
+def numInput(prompt: str, range: slice, n: int | None = None) -> int:
+    """Prompts the user in the terminal with a custom input for a number spinner like `Threads: [4] 🠑🠓`
+
+    Args:
+        prompt (str): The prompt.
+        range (slice): A slice for the min, max, and step for the limits of the input
+        n (int | None, optional): The starting number, and must be in the range. Defaults to the lowest number in the range.
+
+    Returns:
+        int: The number the user picked.
+    """
+
+    if not _inSlice(range, n or range.start):
+        raise ValueError("n is not in range")
+
+    num: int = n or range.start
+
+    def draw():
+        sys.stdout.write(f"\r\x1b[2K{prompt} [{num}] \x1b[90m🠕🠗\x1b[0m")
+
+    draw()
+
+    @handleInput
+    def inputHandler(key: str | Key) -> bool:
+        nonlocal num
+        match key:
+            case Key.ENTER:
+                return False
+
+            case Key.UP | Key.DOWN:
+                n = (range.step or 1) * (-1 if key == Key.DOWN else 1)
+                if _inSlice(range, num + n):
+                    num += n
+
+                draw()
+
+        return True
+
+    print()
+
+    return num

clicanvas-0.2/src/clicanvas/microwidgets/menu.py

@@ -0,0 +1,47 @@
+from inputkit import Key, handleInput
+from ._lib import ANSIColor, HighlightMode, _ANSI_START
+import sys
+
+VERSION = "1.0.0"
+
+def menu(prompt: str, choices: list[object], defaultIdx: int = 0, cursor: str = ">", color: ANSIColor | tuple[int, int, int] | None = None, highlightMode: HighlightMode = HighlightMode.INVERT) -> object:
+    if not choices:
+        return None
+
+    pos: int = defaultIdx % len(choices)
+    colorStr: str = f"\x1b[{color.value}m" if isinstance(color, ANSIColor) else f"\x1b[38;2;{color[0]};{color[1]};{color[2]}m" if isinstance(color, tuple) else ''
+
+    def draw() -> None:
+        sys.stdout.write(f"{prompt}\r\n")
+
+        for i, choice in enumerate(choices):
+            sys.stdout.write(f"{colorStr if not (highlightMode == highlightMode.COLOR) else ''}{f"{cursor}" if i == pos else " "} {(f"{_ANSI_START}7m" if highlightMode == HighlightMode.INVERT else colorStr if highlightMode == highlightMode.COLOR else f"{_ANSI_START}1m" if highlightMode == highlightMode.BOLD else '') if i == pos else ""} {choice} {f"{_ANSI_START}0m" if (colorStr) or (i == pos) else ""}\r\n")
+
+        sys.stdout.flush()
+
+    draw()
+
+    @handleInput
+    def inputHandler(key: Key | str) -> bool:
+        nonlocal pos
+        match key:
+            case Key.ENTER:
+                return False
+
+            case Key.UP:
+                pos = (pos - 1) % len(choices)
+
+            case Key.DOWN:
+                pos = (pos + 1) % len(choices)
+
+        sys.stdout.write(f"\x1b[{len(choices)+1}A")
+        sys.stdout.flush()
+        draw()
+
+        return True
+
+    return choices[pos]
+
+
+if __name__ == "__main__":
+    print(menu("Select Language:", ["Python", "Rust", "Ruby", "Lua"], cursor="►", color=(255, 213, 64), highlightMode=HighlightMode.COLOR))

clicanvas-0.2/src/clicanvas/microwidgets/slider.py

@@ -0,0 +1,63 @@
+from inputkit import handleInput, Key
+from io import StringIO
+from ._lib import ANSIColor
+import sys
+
+VERSION = "1.0.0"
+
+def percent(prompt: str, interval: float = 0.01, n: float = 0.0, width: int = 10, color: ANSIColor = ANSIColor.BRIGHT_WHITE) -> float:
+    """Prompts the user and gets a percent, shown as a slider.
+
+    Args:
+        prompt (str): The prompt
+        interval (float, optional): The change when moving the slider. Must be between 0.01 - 1. Defaults to 0.01.
+        n (float, optional): Initial percent. Must be between 0 - 1. Defaults to 0.0.
+        width (int, optional): The width of the slider. Defaults to 10.
+        color (ANSIColor, optional): The color of the edges of the slider, the percent amount displayed, and the color of the full values in the slider. Defaults to ANSIColor.BRIGHT_WHITE.
+
+    Raises:
+        ValueError: if n is not between 0 - 1
+        ValueError: if interval is not between 0.01 - 1
+
+    Returns:
+        float: the float representation of the percent
+    """
+
+    if not (0.0 <= n <= 1.0):
+        raise ValueError(f"n must be between 0 - 1, not {n}")
+
+    if not (0.01 <= interval <= 1.0):
+        raise ValueError(f"interval must be between 0.01 - 1, not {n}")
+
+    num: int = round(100 * n)
+    step: int = round(100 * interval)
+
+    def draw():
+        n = 100 / (width*2)
+        slide: StringIO = StringIO()
+        for i in range(1, width+1):
+            slide.write(f"\x1b[{color}m#" if num >= i * (n*2) else "\x1b[39m=" if (num >= (i-1) * (n*2)) and ((num / n) % 2 >= 1) else "\x1b[90m-" if (num > (i-1) * (n*2)) else " ")
+
+        sys.stdout.write(f"\r\x1b[2K{prompt} \x1b[{color}m[{slide.getvalue()}\x1b[{color}m] {num}%\x1b[0m")
+
+    draw()
+
+    @handleInput
+    def inputHandler(key: str | Key) -> bool:
+        nonlocal num
+        match key:
+            case Key.ENTER:
+                return False
+
+            case Key.LEFT | Key.RIGHT:
+                num += step if key == Key.RIGHT else -step
+                if not (0 <= num <= 100):
+                    num -= step if key == Key.RIGHT else -step
+
+                draw()
+
+        return True
+
+    print()
+
+    return num / 100

clicanvas-0.2/src/clicanvas.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: clicanvas
+Version: 0.2
+Summary: A python library that deals with terminal-based user input. From a TUI framework to custom input functions.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: inputkit>=1.0.2
+Requires-Dist: regex>=2026.2.28
+Provides-Extra: thonny
+
+# CLICanvas
+
+CLICanvas is a python library that deals with terminal-based user input.
+From a TUI framework to custom input functions.
+
+## Features
+
+- Custom input function and modes, including a mirror of readline and getpass

clicanvas-0.2/src/clicanvas.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+src/clicanvas/__init__.py
+src/clicanvas.egg-info/PKG-INFO
+src/clicanvas.egg-info/SOURCES.txt
+src/clicanvas.egg-info/dependency_links.txt
+src/clicanvas.egg-info/requires.txt
+src/clicanvas.egg-info/top_level.txt
+src/clicanvas/input/__init__.py
+src/clicanvas/input/base.py
+src/clicanvas/input/confirm.py
+src/clicanvas/input/constrained.py
+src/clicanvas/input/getpass.py
+src/clicanvas/input/readline.py
+src/clicanvas/microwidgets/__init__.py
+src/clicanvas/microwidgets/_lib.py
+src/clicanvas/microwidgets/checkbox.py
+src/clicanvas/microwidgets/incrementer.py
+src/clicanvas/microwidgets/menu.py
+src/clicanvas/microwidgets/slider.py

clicanvas-0.2/src/clicanvas.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clicanvas-0.2/src/clicanvas.egg-info/requires.txt

@@ -0,0 +1,4 @@
+inputkit>=1.0.2
+regex>=2026.2.28
+
+[thonny]

clicanvas-0.2/src/clicanvas.egg-info/top_level.txt

@@ -0,0 +1 @@
+clicanvas