forge-terminal-ui 0.0.4__tar.gz

forge_terminal_ui-0.0.4/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: forge-terminal-ui
+Version: 0.0.4
+Summary: Python TUI framework and terminal control
+Author-email: Gretchen Maculo <gretchen.maculo@gmail.com>
+Project-URL: Homepage, https://github.com/gretchycat/ForgeTUI
+Project-URL: Repository, https://github.com/gretchycat/ForgeTUI
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: libAnsiScreen
+
+# forgetui
+python library to control an ansi terminal

forge_terminal_ui-0.0.4/README.md

@@ -0,0 +1,2 @@
+# forgetui
+python library to control an ansi terminal

forge_terminal_ui-0.0.4/forge_terminal_ui.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: forge-terminal-ui
+Version: 0.0.4
+Summary: Python TUI framework and terminal control
+Author-email: Gretchen Maculo <gretchen.maculo@gmail.com>
+Project-URL: Homepage, https://github.com/gretchycat/ForgeTUI
+Project-URL: Repository, https://github.com/gretchycat/ForgeTUI
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: libAnsiScreen
+
+# forgetui
+python library to control an ansi terminal

forge_terminal_ui-0.0.4/forge_terminal_ui.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+forge_terminal_ui.egg-info/PKG-INFO
+forge_terminal_ui.egg-info/SOURCES.txt
+forge_terminal_ui.egg-info/dependency_links.txt
+forge_terminal_ui.egg-info/requires.txt
+forge_terminal_ui.egg-info/top_level.txt
+forgetui/termcontrol.py
+forgetui/terminput.py
+forgetui/termkeymap.py
+forgetui/theme.py
+forgetui/widget.py
+forgetui/widget_container.py
+forgetui/widget_input.py
+forgetui/widget_output.py
+forgetui/widget_terminal.py

forge_terminal_ui-0.0.4/forge_terminal_ui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

forge_terminal_ui-0.0.4/forge_terminal_ui.egg-info/requires.txt

@@ -0,0 +1 @@
+libAnsiScreen

forge_terminal_ui-0.0.4/forge_terminal_ui.egg-info/top_level.txt

@@ -0,0 +1 @@
+forgetui

forge_terminal_ui-0.0.4/forgetui/termcontrol.py

@@ -0,0 +1,362 @@
+#!/usr/bin/python3
+from __future__ import annotations
+import sys, os, fcntl, select
+from libansiscreen.screen import Screen
+from libansiscreen.renderer.ansi_emitter import ANSIEmitter, Box
+from forgetui.termkeymap import gen_keymap
+
+rgb_file_path = '/usr/share/X11/rgb.txt'
+
+class termcontrol:
+    def __init__(self):
+        #self.x11_colors = self.parse_rgb_file(rgb_file_path)
+        self.image_support=[]
+        self.img_cache={}
+        term=os.environ.get('TERM', '')
+        konsole_ver=os.environ.get('KONSOLE_VERSION', '')
+        if 'kitty' in term:
+            self.image_support.append('kitty')
+        if 'vt340' in term or len(konsole_ver or '')>0:
+            self.image_support.append('sixel')
+
+    def output(self, data, fd=sys.stdout.fileno()):
+        CHUNK_SIZE = 4096  # safe per-write chunk
+        """Queue a string or bytes for non-blocking terminal output."""
+        outbuf = bytearray()  # persistent buffer
+        if isinstance(data, str):
+            data = data.encode()
+        outbuf.extend(data)
+        # drain in chunks
+        while outbuf:
+            chunk = outbuf[:CHUNK_SIZE]
+            try:
+                n = os.write(fd, chunk)
+                del outbuf[:n]
+            except BlockingIOError:
+                # wait until fd is writable
+                select.select([], [fd], [])
+
+    # ------------------------------------------------------------------
+    # Mouse control
+    # ------------------------------------------------------------------
+    def enable_mouse(self, utf8=True, all_motion=False):
+        """
+        Enable mouse reporting.
+        Parameters:
+        - utf8: Use UTF-8 or SGR encoding for coordinates (1005 / 1006)
+        - all_motion: Track all mouse motion events, even without buttons (1003)
+        """
+        codes = []
+        # Base tracking
+        codes.append("\x1b[?1002h")  # Button-event tracking (press/release + drag)
+        # Optional: all motion reporting
+        if all_motion:
+            codes.append("\x1b[?1003h")  # Any-motion tracking (hover)
+        # Coordinate encoding
+        if utf8:
+            codes.append("\x1b[?1005h")  # UTF-8 coordinates
+        codes.append("\x1b[?1006h")      # SGR coordinates (decimal)
+        return "".join(codes)
+
+    def disable_mouse(self, utf8=True, all_motion=False):
+        """
+        Disable mouse reporting.
+        """
+        codes = []
+        # Base tracking
+        codes.append("\x1b[?1002l")  # Disable button-event tracking
+        # Optional: disable all-motion reporting
+        if all_motion:
+            codes.append("\x1b[?1003l")  # Disable any-motion tracking
+        # Coordinate encoding
+        if utf8:
+            codes.append("\x1b[?1005l")  # Disable UTF-8 coordinates
+        codes.append("\x1b[?1006l")      # Disable SGR coordinates
+        return "".join(codes)
+
+    def start_sync(self):
+        return "\x1b[?2026h"
+
+    def end_sync(self):
+        return "\x1b[?2026l"
+
+    def enable_cursor(self):
+        return "\x1b[?25h"
+
+    def disable_cursor(self):
+        return "\x1b[?25l"
+
+    def normal_screen(self):
+        return "\x1b[?1049l"
+
+    def alt_screen(self):
+        return "\x1b[?1049h"
+
+    def set_title(self, title):
+        return f"\x1b]0;{title}\\a"
+
+    def pause_terminal_output(self):
+        sys.stdout.flush()
+        os.system('stty -icanon -echo')
+
+    def resume_terminal_output(self):
+        sys.stdout.flush()
+        os.system('stty icanon echo')
+
+    def parse_rgb_file(self, file_path):
+        colors = {}
+        if not os.path.isfile(file_path):
+            return colors
+        with open(file_path, 'r') as file:
+            for line in file:
+                if not line.startswith('!'):
+                    parts = line.strip().split('\t')
+                    if len(parts) >= 4:
+                        name = parts[3].lower()
+                        red, green, blue = int(parts[0]), int(parts[1]), int(parts[2])
+                        colors[name] = {'red':red, 'green':green, 'blue':blue}
+        return colors
+
+    def pause(self):
+        print ('[pause]')
+        return sys.stdin.readline()
+
+    def get_terminal_size(self):
+        import array, fcntl, sys, termios
+        buf = array.array('H', [0, 0, 0, 0])
+        fcntl.ioctl(sys.stdout, termios.TIOCGWINSZ, buf)
+        # Create a dictionary with meaningful keys
+        window_info = {
+            "rows": buf[0],
+            "columns": buf[1],
+            "width": buf[2],
+            "height": buf[3]
+        }
+        return window_info
+
+    def color(self, color):
+        if type(color)==int:
+            return color
+        co={
+                'black'  : 0,
+                'red'    : 1,
+                'green'  : 2,
+                'yellow' : 3,
+                'brown'  : 3,
+                'blue'   : 4,
+                'magenta': 5,
+                'cyan'   : 6,
+                'white'  : 7,
+                'brightblack'  : 8,
+                'brightred'    : 9,
+                'brightgreen'  : 10,
+                'brightbrown'  : 11,
+                'brightyellow' : 11,
+                'brightblue'   : 12,
+                'brightmagenta': 13,
+                'brightcyan'   : 14,
+                'brightwhite'  : 15,
+            }
+        if type(color)==str:
+            regex = r'^([A-Fa-f0-9]{6})$'
+            if re.match(regex, color) is not None:
+                color={
+                        'red'  :int(color[0:2], 16),
+                        'green':int(color[2:4], 16),
+                        'blue' :int(color[4:6], 16),
+                      }
+                return color
+            regex = r'^([A-Fa-f0-9]{3})$'
+            if re.match(regex, color) is not None:
+                color={
+                        'red'  :int(color[0:1], 16)*16,
+                        'green':int(color[1:2], 16)*16,
+                        'blue' :int(color[2:3], 16)*16,
+                      }
+                return color
+            regex = r'^#([A-Fa-f0-9]{6})$'
+            if re.match(regex, color) is not None:
+                color={
+                        'red'  :int(color[1:3], 16),
+                        'green':int(color[3:5], 16),
+                        'blue' :int(color[5:7], 16),
+                      }
+                return color
+            regex = r'^#([A-Fa-f0-9]{3})$'
+            if re.match(regex, color) is not None:
+                color={
+                        'red'  :int(color[1:2], 16)*16,
+                        'green':int(color[2:3], 16)*16,
+                        'blue' :int(color[3:4], 16)*16,
+                      }
+                return color
+            if co.get(color):
+                return co.get(color.lower())
+            return self.x11_colors.get(color.lower())
+        return None
+
+    def getRGB(self, c):
+        color=self.color(c)
+        if type(color)==dict:
+            return color
+        if type(color)==int:
+            pass #FIXME
+        return {'red':127, 'green':127, 'blue':127}
+
+    def ansicolor(self, fg='default', bg='default',
+                  bold=False, dim=False, italic=False, underline=False,
+                  strike=False, blink=False, blink2=False, reverse=False,
+                  bold_is_bright=False):
+        if fg=='default':
+            fg=7
+        if bg=='default':
+            bg=None
+        fg=self.color(fg)
+        bg=self.color(bg)
+        fgs=""
+        bgs=""
+        if type(fg)==int:
+            if fg<16:
+                if fg<8:
+                    if bold_is_bright:
+                        fgs=f"{fg+90}"
+                    else:
+                        fgs=f"{fg+30}"
+                else:
+                    fgs=f"{(fg-8)+90}"
+            else:
+                fgs=f'38;5;{fg}'
+        elif type(fg)==dict:
+            fgs=f'38;2;{fg["red"]};{fg["green"]};{fg["blue"]}'
+        if type(bg)==int:
+            if bg<16:
+                if bg<8:
+                    bgs=f"{bg+40}"
+                else:
+                    bgs=f"{(bg-8)+100}"
+            else:
+                bgs=f'48;5;{bg}'
+        elif type(bg)==dict:
+            bgs=f'48;2;{bg["red"]};{bg["green"]};{bg["blue"]}'
+        bo, bl, bl2, dm, it, ul, st, rv="","","","","","","", ""
+        if bold:bo='1;'
+        if dim:bdm='2;'
+        if italic:it='3;'
+        if underline:ul='4;'
+        if blink:bl='5;'
+        if blink2:bl2='6;'
+        if reverse:rv='7;'
+        ansi=""
+        if len(bgs) and len(fgs):
+            ansi=f'{fgs};{bgs}'
+        elif len(bgs):
+            ansi=bgs
+        elif len(fgs):
+            ansi=fgs
+        if len(ansi)>0:
+            return f"\x1b[{bo}{dm}{it}{ul}{bl}{bl2}{rv}{ansi}m"
+        return ""
+
+    def drawRuler(self,w,h):
+        buffer=''
+        for y in range(0,h-2):
+            for x in range(0,int((w)/10)):
+                buffer+=self.gotoxy(x*10+1,y+1)
+                buffer+=f'({x*10},{y})'
+        return buffer
+
+    def pyte_render(self, x, y, screen, line=1,
+                    fg='default', bg='default',
+                    fg0='default', bg0='default',
+                    bold_is_bright=False):
+        bold=False
+        blink=False
+        w=screen.columns
+        h=screen.screen_lines
+        start_line=line-1
+        if start_line<0:
+            start_line=int(screen.cursor.y-h+2)
+        if start_line<0:
+            start_line=0
+        if start_line>int(screen.cursor.y-h+2):
+            start_line=int(screen.cursor.y-h+2)
+        buffer = self.ansicolor(fg, bg, bold=bold, blink=blink)
+        screen.cursor_position(screen.screen_lines+start_line, 1)
+        for yy in range(start_line, start_line+h):
+            buffer += self.gotoxy(x, y+yy-(start_line))
+            buffer+=self.ansicolor(fg, bg)
+            for xx in range(w):
+                if screen.buffer[yy][xx].fg!=fg or screen.buffer[yy][xx].bold!=bold:
+                    fg=screen.buffer[yy][xx].fg
+                    bold=screen.buffer[yy][xx].bold
+                    buffer += self.ansicolor(fg, None, bold=bold, bold_is_bright=bold_is_bright)
+                if screen.buffer[yy][xx].bg!=bg or screen.buffer[yy][xx].blink!=blink:
+                    bg=screen.buffer[yy][xx].bg
+                    blink=screen.buffer[yy][xx].blink
+                    buffer += self.ansicolor(None, bg, blink=blink)
+                buffer += screen.buffer[yy][xx].data
+            buffer+=self.ansicolor(fg0, bg0)
+        return buffer
+
+    def gotoxy(self, x, y):
+        return f'\x1b[{int(y)};{int(x)}f'
+
+    def clear(self):
+        return '\x1b[2J'
+
+    def reset(self):
+        return '\x1b[0m'
+
+    def setbg(self, c):
+        return self.ansicolor(None, c)
+
+    def setfg(self, c):
+        return self.ansicolor(c, None)
+
+    def up(self, n):
+        return f'\x1b[{n}A'
+
+    def down(self, n):
+        return f'\x1b[{n}B'
+
+    def left(self, n):
+        return f'\x1b[{n}D'
+
+    def right(self, n):
+        return f'\x1b[{n}C'
+
+    def clear_images(self):
+        out=''
+        if 'kitty' in self.image_support:
+            out+='\x1b_Ga=d\x1b\\'
+        if 'sixel' in self.image_support:
+            pass
+        return out
+
+    def showImage(self, image, x=0, y=0, w=30, h=15, showInfo=False, mode='auto', charset='utf8'):
+        desc=""
+        imgX,imgY=0,0
+        if(showInfo):
+            try:
+                img = Image.open(image)
+                imgX,imgY=img.size
+                img.close()
+            except:
+                pass
+            filename=os.path.basename(image)
+            desc=f'({imgX}x{imgY}) {filename}'[:w]
+            descX=int(x+(w/2)-(len(desc)/2))+1
+            descY=int(y+h)-1
+            desc=f'\x1b[s\x1b[48;5;245;30m\x1b[{descY};{descX}H{desc}\n'
+        start_pos = f'\x1b[{y};{x+1}H'
+        if not self.img_cache.get(image):
+            ic=ICat(w=int(w), h=int(h), zoom='aspect', f=True, x=int(0), y=int(0), place=True, mode=mode, charset=charset)
+            self.img_cache[image]=ic.print(image)
+        return f'{start_pos}{self.img_cache[image]}{desc}'
+
+def clean(input_string):
+    # Use regular expressions to replace consecutive whitespace characters with a single space
+    cleaned_string = re.sub(r'\s+', ' ', input_string)
+    # Remove leading and trailing spaces
+    return cleaned_string.strip()
+

forge_terminal_ui-0.0.4/forgetui/terminput.py

@@ -0,0 +1,121 @@
+#!/usr/bin/python3
+from __future__ import annotations
+import sys, os, fcntl, select, asyncio, time, termios, tty, re
+
+from .termkeymap import gen_keymap
+
+class termInput:
+    def __init__(self):
+        fps=30
+        self.timeout=1/fps
+        self.start=0
+        self.keymap=gen_keymap()
+        self.buffer=''
+        self.flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
+        self.filedescriptors = termios.tcgetattr(sys.stdin)
+        self.raw=False
+        self.__enter__()
+
+    def __enter__(self):
+        fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, self.flags | os.O_NONBLOCK)
+        if self.raw:
+            tty.setraw(sys.stdin)
+        else:
+            tty.setcbreak(sys.stdin)
+
+    def __del__(self):
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, self.filedescriptors)
+        fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, self.flags & ~os.O_NONBLOCK)
+
+    def __exit__(self):
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, self.filedescriptors)
+        fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, self.flags & ~os.O_NONBLOCK)
+
+    def disable_keyboard_echo(self): # Get the current terminal attributes
+        attributes = termios.tcgetattr(sys.stdin)
+        # Disable echo flag
+        attributes[3] = attributes[3] & ~termios.ECHO
+        # Apply the modified attributes
+        termios.tcsetattr(sys.stdin, termios.TCSANOW, attributes)
+
+    def enable_keyboard_echo(self): # Get the current terminal attributes
+        attributes = termios.tcgetattr(sys.stdin)
+        # Enable echo flag
+        attributes[3] = attributes[3] | termios.ECHO
+        # Apply the modified attributes
+        termios.tcsetattr(sys.stdin, termios.TCSANOW, attributes)
+
+    def read(self, bin=False):
+        self.buffer = ''
+        try:
+            rlist, _, _ = select.select([sys.stdin], [], [], self.timeout)
+        except (InterruptedError, OSError) as e:
+            if isinstance(e, InterruptedError) or getattr(e, "errno", None) == errno.EINTR:
+                return self.buffer
+            raise
+        if rlist:
+            if not bin:
+                try:
+                    # Read only a chunk of available buffer (e.g., 4096 bytes) instead of EOF
+                    self.buffer += sys.stdin.read(4096)
+                except Exception:
+                    self.buffer += sys.stdin.buffer.read(4096).decode('utf-8', errors='ignore')
+            else:
+                self.buffer += sys.stdin.buffer.read(4096)
+        return self.buffer
+
+    def ord(self, d):
+        if(type(d)==int):
+            return d
+        if(type(d)==str):
+            return ord(d[0])
+        if(type(d)==bytes):
+            return int.from_bytes(d)
+        return int(d)
+
+    def split_codes(self, buffer): #TODO split by all of the key map values and then every character individually
+        inputlist=buffer.split('\x1b')
+        for k,i in enumerate(inputlist[1:], start=1):
+            inputlist[k]='\x1b'+i
+        if inputlist[0]=='':
+            inputlist.pop(0)
+        return inputlist
+
+    def mouse_input(self, buffer):
+        m = re.match(r"\x1b\[<(\d+);(\d+);(\d+)([Mm])", buffer)
+        scroll_dir={64:'up', 65:'down',66:'left',67:'right'}
+        if m:
+            button, column, row, event = m.groups()
+            detail=''
+            button = int(button)
+            action = "button down" if event == "M" else "button up" if event == "m" else "Unknown"
+            if button>=64:
+                if button<=67:
+                    action='scroll '+scroll_dir[button]
+                else:
+                    action='scroll'
+            elif button >= 32:
+                button=button%32
+                action='drag'
+            column = int(column)-1
+            row = int(row)-1
+            return {'button':button, 'x':column, 'y':row,
+                    'action':action}
+        return None
+
+    def read_input(self): # Get the current settings of the terminal
+        buffer = self.read()
+        inputs=self.split_codes(buffer)
+        all_inputs=[]
+        for i in inputs:
+            key=self.keymap.get(i)
+            if key:
+                all_inputs.append(key)
+                continue
+            mouse=self.mouse_input(i)
+            if mouse:
+                all_inputs.append(mouse)
+                continue
+            all_inputs.append(i)
+        return all_inputs
+

forge_terminal_ui-0.0.4/forgetui/termkeymap.py

@@ -0,0 +1,70 @@
+def gen_keymap():
+    term_keymap = {
+        # --- Manual Standard Overrides ---
+        "\x7f":"Backspace",
+        "\x1b":"Esc",
+        "\x00":"Ctrl  ",
+        "\x09":"Tab",
+        "\x0a":"Enter",
+        "\x0d":"CR",
+        "\x1b[Z":"Shift Tab",
+        "\x1b\n":"Alt Enter",
+    }
+
+    special = {28: "\\", 29: "] 5", 30: "^ 6", 31: "/ 7"}
+    # --- 1. C0 Control Codes (Ctrl+A to Ctrl+Z) ---
+    for i in range(1, 32):
+        # Handle the Information Separators
+        char = special.get(i, chr(i + 64))
+        if term_keymap.get(chr(i)) is None:
+            term_keymap[chr(i)] = f"Ctrl {char}"
+
+    # --- 2. XTerm Modified Sequences ---
+    modifiers = {
+        "2": "Shift", "3": "Alt", "4": "Shift Alt", "5": "Ctrl",
+        "6": "Ctrl Shift", "7": "Ctrl Alt", "8": "Ctrl Shift Alt",
+        "9": "Meta", "10": "Meta Shift", "12": "Meta Shift Alt",
+        "13": "Meta Ctrl","14": "Meta Ctrl Shift","15": "Meta Ctrl Alt",
+        "16": "Meta Ctrl Shift Alt",
+
+    }
+
+    # CSI Suffixes (1;modX)
+    nav_f_codes = {
+        "A": "Up", "B": "Down", "C": "Right", "D": "Left",
+        "H": "Home", "F": "End", "P": "F1", "Q": "F2", "R": "F3", "S": "F4"
+    }
+
+    # Tilde Codes (code;mod~)
+    tilde_codes = {
+        "1": "Home", "2": "Ins", "3": "Del", "4": 'End',
+        "5": "PgUp", "6": "PgDn",
+        "15": "F5", "17": "F6", "18": "F7", "19": "F8",
+        "20": "F9", "21": "F10", "23": "F11", "24": "F12",
+        "25": "F13", "26": "F14", "28": "F15", "29": "F16",
+        "31": "F17", "32": "F18", "33": "F19", "34": "F20",
+        "35": "F21", "36": "F22", "37": "F23", "38": "F24",
+        "32": "SysRq", "34": "Break",
+    }
+
+    #keys with no modifiers
+    for code, name in nav_f_codes.items():
+        term_keymap[f"\x1bO{code}"] = f"{name}"
+        term_keymap[f"\x1b[{code}"] = f"{name}"
+    for code, name in tilde_codes.items():
+        term_keymap[f"\x1b[{code}~"] = f"{name}"
+
+    #keys for all the modifiers
+    for mod_val, mod_name in modifiers.items():
+        for code, name in nav_f_codes.items():
+            term_keymap[f"\x1b[1;{mod_val}{code}"] = f"{mod_name} {name}"
+        for code, name in tilde_codes.items():
+            term_keymap[f"\x1b[{code};{mod_val}~"] = f"{mod_name} {name}"
+
+    # --- 3. Alt + Keys (Meta) ---
+    for i in range(32, 127): # Space through ~
+        term_keymap[f"\x1b{chr(i)}"] = f"Alt {chr(i)}"
+        for m in [ 9,10,12,13,14,15,16]:
+            term_keymap[f"\x1b[{str(i)};{str(m)}u" ] = f"{modifiers[str(m)]} {chr(i)}"
+    return term_keymap
+