libTerm 0.0.1__py3-none-any.whl

libTerm/__init__.py

@@ -0,0 +1,2 @@
+from libTerm.term import Term
+

libTerm/term/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python
+import os
+if os.name == 'nt':
+	from libTerm.term.winnt import Term
+else:
+	from libTerm.term.posix import Term

libTerm/term/cursor.py

@@ -0,0 +1,123 @@
+
+from dataclasses import dataclass
+from enum import Enum
+from collections import namedtuple
+import re
+from libTerm.term.types import Coord
+from time import time_ns
+import sys
+@dataclass()
+class ANSI_Cursor(str, Enum):
+	esc = '\x1b'
+	q = '6n'
+	save = 's'
+	load = 'u'
+	show = '?25h'
+	hide = '?25l'
+
+	def __str__(self):
+		return '{ESC}[{CODE}'.format(ESC=self.ESC,CODE=self.value)
+	def __repr__(self):
+		return repr(self.value)
+
+
+class Cursor():
+	def __init__(__s, term):
+		super().__init__()
+		__s.term = term
+		__s.ansi = ANSI_Cursor
+
+		__s.re = re.compile(r"^.?\x1b\[(?P<Y>\d*);(?P<X>\d*)R", re.VERBOSE)
+		__s.position = __s.__update__
+		__s._xy=Coord(0,0)
+		__s.XY=Coord(0,0)
+		__s.history = [*(None,) * 64]
+		__s.init = __s.__update__()
+	@property
+	def xy(__s):
+		__s._xy=__s.__update__()
+		return __s._xy
+
+	def __update__(__s, get='XY'):
+		def Parser():
+			buf = ' '
+			while buf[-1] != "R":
+				buf += sys.stdin.read(1)
+			# reading the actual values, but what if a keystroke appears while reading
+			# from stdin? As dirty work around, getpos() returns if this fails: None
+			try:
+				groups = __s.re.search(buf).groupdict()
+				result = Coord(int(groups['X']), int(groups['Y']))
+			except AttributeError:
+				result = None
+			return result
+
+		result = None
+		timeout = {}
+		timeout['limit'] = 500
+		timeout['start'] = time_ns() // 1e6
+		timeout['running'] = 0
+		while not result:
+			result = __s.term.ansi(''.join([__s.ansi.esc,'[', __s.ansi.q]), Parser)
+		__s.XY =result
+		return result
+
+	def show(__s, state=True):
+		if state:
+			print('\x1b[?25h', end='', flush=True)
+		else:
+			__s.hide()
+
+	def hide(__s, state=True):
+		if state:
+			print('\x1b[?25l', end='', flush=True)
+			atexit.register(__s.show)
+		else:
+			__s.show()
+
+	@property
+	def x(__s):
+		__s.X=__s.__update__('X')
+		return __s.X
+
+	@property
+	def y(__s):
+		__s.Y=__s.__update__('Y')
+		return __s.Y
+
+
+class vCursor(Cursor):
+	def __init__(__s, term,cursor):
+		__s.term = term
+		__s.realcursor=cursor
+		__s.position = Coord(__s.realcursor.x,__s.realcursor.y)
+		__s.history = [*(None,) * 64]
+		__s.controled = False
+		__s.bound = True
+		__s.frozen = False
+		__s.init = __s.__update__()
+
+	def freeze(__s, state=True):
+		if state:
+			__s.frozen = True
+			__s.bind(False)
+			__s.control(False)
+		else:
+			__s.frozen = False
+
+	def __update__(__s, get='XY'):
+		pass
+
+	def show(__s, state=True):
+		if state:
+			print('\x1b[?25h', end='', flush=True)
+		else:
+			__s.hide()
+
+	def hide(__s, state=True):
+		if state:
+			print('\x1b[?25l', end='', flush=True)
+			atexit.register(__s.show)
+		else:
+			__s.show()
+

libTerm/term/posix.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+import os
+import termios
+import tty
+import atexit
+import re
+import sys
+from time import time_ns
+from shutil import get_terminal_size
+from dataclasses import dataclass, field
+from enum import Enum
+from collections import namedtuple
+from libTerm.term.types import Coord,color, Size,Colors
+from libTerm.term.cursor import  Cursor, vCursor
+
+
+
+# Indices for termios list.
+IFLAG = 0
+OFLAG = 1
+CFLAG = 2
+LFLAG = 3
+ISPEED = 4
+OSPEED = 5
+CC = 6
+TCSAFLUSH = termios.TCSAFLUSH
+ECHO = termios.ECHO
+ICANON = termios.ICANON
+
+VMIN = 6
+VTIME = 5
+
+
+class TermAttrs():
+	def __init__(s):
+		s.stack=[]
+		s.init=None
+		s.staged=None
+		s.active=None
+	def stage(s):
+		s.staged=list(s.active)
+	def update(s,new=None):
+		if new is None:
+			new=s.staged
+		s.stack+=[list(s.active)]
+		s.active=new
+		s.staged=None
+	def restore(s):
+		if s.stack:
+			s.staged=s.stack.pop()
+		return s.staged
+
+
+
+class Term():
+	def __init__(s,*a,**k):
+		# super().__init__()
+		s.pid       = os.getpid()
+		s.ppid      = os.getpid()
+		
+		s.fd        = sys.stdin.fileno()
+		s.tty       = os.ttyname(s.fd)
+
+		s.TCSAFLUSH = termios.TCSAFLUSH
+		s.ECHO      = termios.ECHO
+		s.ICANON    = termios.ICANON
+		s.TCSANOW   = termios.TCSANOW
+
+		s.attrs     = TermAttrs()
+
+
+		s.attrs.active =  s.tcgetattr()
+		s.attrs.init   =  list([*s.attrs.active])
+		s.attrs.stack += [list(s.attrs.active)]
+
+		s._mode     = 0
+		s.mode      = s.__mode__
+		atexit.register(s.mode,'normal')
+		s.cursor    = Cursor(s)
+		s.vcursors  = {0:vCursor(s,s.cursor)}
+		s.size      = Size(parent=s)
+		s.color     = Colors(parent=s)
+
+
+	def tcgetattr(s):
+		return termios.tcgetattr(s.fd)
+
+	def tcsetattr(s,attr,when=TCSAFLUSH):
+		termios.tcsetattr(s.fd,when,attr)
+
+	def setraw(s, when=TCSAFLUSH):
+		"""Put terminal into raw mode."""
+		from termios import IGNBRK,BRKINT,IGNPAR,PARMRK,INPCK,ISTRIP,INLCR,IGNCR,ICRNL,IXON,IXANY,IXOFF,OPOST,PARENB,CSIZE,CS8,ECHO,ECHOE,ECHOK,ECHONL,ICANON,IEXTEN,ISIG,NOFLSH,TOSTOP
+		s.attrs.stage()
+		# Clear all POSIX.1-2017 input mode flags.
+		# See chapter 11 "General Terminal Interface"
+		# of POSIX.1-2017 Base Definitions.
+		s.attrs.staged[IFLAG] &= ~( IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP | INLCR | IGNCR | ICRNL | IXON
+									| IXANY | IXOFF)
+		# Do not post-process output.
+		s.attrs.staged[OFLAG] &= ~OPOST
+		# Disable parity generation and detection; clear character size mask;
+		# let character size be 8 bits.
+		s.attrs.staged[CFLAG] &= ~(PARENB | CSIZE)
+		s.attrs.staged[CFLAG] |= CS8
+		# Clear all POSIX.1-2017 local mode flags.
+		s.attrs.staged[LFLAG] &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON | IEXTEN | ISIG | NOFLSH | TOSTOP)
+		# POSIX.1-2017, 11.1.7 Non-Canonical Mode Input Processing,
+		# Case B: MIN>0, TIME=0
+		# A pending read shall block until MIN (here 1) bytes are received,
+		# or a signal is received.
+		s.attrs.staged[CC] = list(s.attr.staged[CC])
+		s.attrs.staged[CC][VMIN] = 1
+		s.attrs.staged[CC][VTIME] = 0
+		s.update(when)
+
+	def setcbreak(s,when=TCSAFLUSH):
+		"""Put terminal into cbreak mode."""
+		# this code was lifted from the tty module and adapted for being a method
+		s.attrs.stage()
+		# Do not echo characters; disable canonical input.
+		s.attrs.staged[LFLAG] &= ~(ECHO | ICANON)
+		# POSIX.1-2017, 11.1.7 Non-Canonical Mode Input Processing,
+		# Case B: MIN>0, TIME=0
+		# A pending read shall block until MIN (here 1) bytes are received,
+		# or a signal is received.
+		s.attrs.staged[CC] = list(s.attrs.staged[CC])
+		s.attrs.staged[CC][VMIN] = 1
+		s.attrs.staged[CC][VTIME] = 0
+		s.update(when)
+
+	def echo(s,enable=False):
+		s.attrs.stage()
+		s.attrs.staged[3] &= ~s.ECHO
+		if enable:
+			s.attrs.staged[3] |= s.ECHO
+		s.update()
+
+	def canonical(s,enable):
+		s.attrs.stage()
+		s.attrs.staged[3] &= ~s.ICANON
+		if enable:
+			s.attrs.staged[3] |= s.ICANON
+		s.update()
+
+	def __mode__(s,mode=None):
+		def Normal():
+			# s.cursor.show(True)
+			s.echo(True)
+			s.canonical(True)
+			s.tcsetattr(s.attrs.init)
+			s._mode = nmodi.get('normal')
+
+		def Ctl():
+			# s.cursor.show(False)
+			s.echo(False)
+			s.canonical(False)
+			s._mode = nmodi.get('ctl')
+
+		nmodi={'normal' : 1,'ctl': 2 }
+		fmodi = {
+			1   :  Normal,
+			2   :  Ctl,
+		}
+		if mode is not None and mode != s._mode:
+			nmode=nmodi.get(mode)
+			fmodi.get(nmode)()
+		return s._mode
+		
+	def update(s,when=TCSAFLUSH):
+		s.tcsetattr( s.attrs.staged,when)
+		s.attrs.update(s.tcgetattr())
+
+	def ansi(s, ansi, parser):
+		s.setcbreak()
+		try:
+			sys.stdout.write(ansi)
+			sys.stdout.flush()
+			result = parser()
+		finally:
+			s.tcsetattr(s.attrs.restore())
+		return result
+#

libTerm/term/types.py

@@ -0,0 +1,193 @@
+from dataclasses import dataclass,field
+from collections import namedtuple
+from os import get_terminal_size
+from  time import sleep, time_ns
+import sys
+
+
+@dataclass()
+class Coord(namedtuple('Coord', ['x', 'y'])):
+	__module__ = None
+	__qualname__='Coord'
+	_x: int = field(default=0)
+	_y: int = field(default=0)
+
+	def __str__(__s):
+		return f'\x1b[{__s.y + 1};{__s.x + 1}H'
+
+	def __repr__(s):
+		return f"{s.__class__.__name__}({s.x}, {s.y})"
+
+	def __len__(self):
+		return 2
+	def __iter__(self):
+		yield self.x
+		yield self.y
+	def __getitem__(s, index):
+		if 0 > index > 2:
+			raise IndexError("numberpair index out of range")
+		return (
+			((index == 0)*s.x)+
+			((index == 1)*s.y))
+	def __add__(s, other):
+		if isinstance(other,Coord2D):
+			x=s.x+other.x
+			y=s.y+other.y
+			return Coord2D(x,y)
+		elif isinstance(other,complex):
+			x=s.x+other.real
+			y=s.y+other.imag
+			return Coord2D(x,y)
+		elif isinstance(other,str):
+			return f'{s.__str__()}{other}'
+		else:
+			raise TypeError(f"cannot add {type(s)} to {type(other)}")
+
+
+
+	@property
+	def xy(s) -> tuple[int, int]:
+		return (s.x, s.y)
+
+	@property
+	def y(s):
+		return s._y
+
+	@property
+	def x(s):
+		return s._x
+
+
+@dataclass(frozen=True)
+class color:
+	R: int = field(default=0, metadata={"range": (0, 65535)})
+	G: int = field(default=0, metadata={"range": (0, 65535)})
+	B: int = field(default=0, metadata={"range": (0, 65535)})
+	BIT: int = field(default=8, metadata={"set": (4, 8, 16, 32)})
+
+	def __post_init__(self):
+		for attr_name in ("R", "G", "B"):
+			value = getattr(self, attr_name)
+			if not isinstance(value, int):
+				raise ValueError(f"{attr_name.upper()} must be an integer between 0 and 65535. Got {value}.")
+		if not isinstance(getattr(self, "BIT"), int):
+			raise ValueError(f"{attr_name.upper()} must be one of 4,8,16,32. Got {value}.")
+
+	@property
+	def RGB(self) -> tuple[int, int, int]:
+		return (self.R, self.G, self.B)
+
+# @dataclass()
+# class TermCo(namedtuple('Co',['x','y'])):
+# 	x:int=field(default=0)
+# 	y:int=field(default=0)
+# class Line(namedtuple('Line',['a','b'])):
+# 	a:Co=field(default_factory=Co)
+# 	b:Co=field(default_factory=Co)
+# 	@classmethod
+# 	def __add__(s, o):
+# 		if isinstance(o,Line):
+# 			if len(s.a)!=0 and len(s.b)!=0:
+# 				lenx=abs(s.b.x-s.a.x)+abs(o.b.x-o.a.x)
+# 				leny=abs(s.b.y-s.a.y)+abs(o.b.y-o.a.y)
+# 				L=Line(s.a,Co(s.a.x+lenx,s.a.y+leny))
+# 			else:
+# 				return 0
+#
+# 	def __len__(s):
+# 		if len(s.a) != 0 and len(s.b) != 0:
+# 			lenx = abs(s.b.x - s.a.x) + abs(o.b.x - o.a.x)
+# 			leny = abs(s.b.y - s.a.y) + abs(o.b.y - o.a.y)
+# 			return ((lenx**2+leny**2)**(1/2))
+
+class Size():
+	def __init__(__s, **k):
+		__s.parent = k.get('parent')
+		__s.getsize = get_terminal_size
+		__s.time = None
+		__s.last = None
+		__s.xy = Coord(1, 1)
+		__s._tmp = Coord(1, 1)
+		__s.rows = 1
+		__s.cols = 1
+
+		__s.history = []
+		__s.changed = False
+		__s.changing = False
+
+		__s.__kwargs__(**k)
+		__s.__update__()
+
+	@property
+	def width(__s):
+		__s.__update__()
+		return __s.cols
+	@property
+	def height(__s):
+		__s.__update__()
+		return __s.rows
+	@property
+	def rc(__s):
+		__s.__update__()
+		return (__s.cols, __s.rows)
+
+	def __kwargs__(__s, **k):
+		__s.term = k.get('parent')
+
+	def __update__(__s):
+		if __s.time is None:
+			__s.last = time_ns()
+		size = Coord(*__s.getsize())
+		if size != __s.xy:
+			if size != __s._tmp:
+				__s.changing = True
+				__s._tmp = size
+				__s._tmptime = time_ns()
+			if size == __s._tmp:
+				if (time_ns() - __s._tmptime) * 1e6 > 500:
+					__s.changing = False
+					__s.changed = True
+					__s.history += [__s.xy]
+					__s.xy = size
+					__s.rows = __s.xy.y
+					__s.cols = __s.xy.x
+				else:
+					__s._tmp = size
+		if size == __s.xy:
+			__s.changed = False
+
+class Colors():
+	def __init__(__s, **k):
+		__s.parent = None
+		__s.specs = {'fg': 10, 'bg': 11}
+		__s._ansi = '\x1b]{spec};?\a'
+		__s.__kwargs__(**k)
+		__s.fg = color(255, 255, 255)
+		__s.bg = color(0, 0, 0)
+		__s.init = __s.__update__()
+
+	def __kwargs__(__s, **k):
+		__s.term = k.get('parent')
+
+	@staticmethod
+	def _ansiparser_():
+		buf = ''
+		try:
+			for i in range(23):
+				buf += sys.stdin.read(1)
+			rgb = buf.split(':')[1].split('/')
+			rgb = [int(i, base=16) for i in rgb]
+			rgb = color(*rgb, 16)
+		except Exception as E:
+			# print(E)
+			rgb = None
+		return rgb
+
+	def __update__(__s):
+		for ground in __s.specs:
+			result = None
+			while not result:
+				result = __s.term.ansi(__s._ansi.format(spec=__s.specs[ground]), __s._ansiparser_)
+			__s.__setattr__(ground, result)
+
+		return {'fg': __s.fg, 'bg': __s.bg}

libTerm/term/winnt.py

@@ -0,0 +1,90 @@
+import shutil
+import ctypes
+import sys
+import msvcrt
+import atexit
+import struct
+from libTerm.term.types import color
+from libTerm.term.types import Size
+
+class Colors:
+	def __init__(s,**k):
+		s.parent = k.get('parent')
+		s.fg = color(255, 255, 255)
+		s.bg = color(0, 0, 0)
+		s.refresh()
+	def refresh(s):
+		# Windows API constants
+		STD_OUTPUT_HANDLE = -11
+		handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+		csbi = ctypes.create_string_buffer(22)
+		res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(handle, csbi)
+		if res:
+			# Unpack the color attribute as a WORD (2 bytes) at offset 4
+			attr = struct.unpack('<H', csbi.raw[4:6])[0]
+			s.fg = attr & 0x0F
+			s.bg = (attr & 0xF0) >> 4
+			s.foreground = s.fg
+			s.background = s.bg
+		else:
+			s.fg = None
+			s.bg = None
+			s.foreground = None
+			s.background = None
+
+class Term:
+    def __init__(s, *a, **k):
+        s.pid = None  # Not relevant for Windows terminal
+        s.ppid = None
+        s.fd = None
+        s.tty = None
+        s.attrs = None
+        s._mode = 0
+        s.mode = s.__mode__
+        atexit.register(s.mode, 'normal')
+        s.cursor = None
+        s.vcursors = None
+        s.size = Size(parent=s)  # Reflects current terminal size
+        s.color = Colors(parent=s)  # Reflects current terminal colors
+
+
+    def getch(s):
+        """Read a single character from the terminal."""
+        return msvcrt.getch().decode('utf-8', errors='ignore')
+
+    def kbhit(s):
+        """Check if a keypress is available."""
+        return msvcrt.kbhit()
+
+    def __mode__(s, mode=None):
+        nmodi = {'normal': 1, 'ctl': 2}
+        if mode is not None and mode != s._mode:
+            s._mode = nmodi.get(mode)
+        return s._mode
+
+    def ansi(s, ansi, parser):
+        # Parse ANSI color code for foreground (e.g., \x1b[32m)
+        import re
+        match = re.search(r'\x1b\[(3[0-7])m', ansi)
+        if match:
+            s.last_ansi_fg = int(match.group(1)[1:])  # 30-37 -> 0-7
+        sys.stdout.write(ansi)
+        sys.stdout.flush()
+        return parser()
+
+    def refresh(s):
+        """Refresh the size and color settings."""
+        s.size.refresh()
+        s.color.refresh()
+
+    # Stub methods for compatibility
+    def setraw(s, when=None):
+        pass
+    def setcbreak(s, when=None):
+        pass
+    def echo(s, enable=False):
+        pass
+    def canonical(s, enable):
+        pass
+    def update(s, when=None):
+        pass

libterm-0.0.1.dist-info/METADATA

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: libTerm
+Version: 0.0.1

libterm-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+libTerm/__init__.py,sha256=XykOeLAxMgxFieSsHqzMB0Qa4izGjCqXPZYubTXPvtc,33
+libTerm/term/__init__.py,sha256=bstJSmazmFJ5ZGDzx35UyeWfLwcEN9pmHtN42c4MeNI,131
+libTerm/term/cursor.py,sha256=qIkS2Nk4Ky6Ab-RInZ9Rqd0h22VJH_brKQscCVwhq_g,2691
+libTerm/term/posix.py,sha256=c4k3FycHxbKCK-PtGzylUDX8qTtffx3qHE9_Zd_UTFc,4544
+libTerm/term/types.py,sha256=-IfgTCCRQxchS6IN7iBmFAoNKHny48YWxDhmyVvVBJk,4694
+libTerm/term/winnt.py,sha256=pMAUKr1BAqFWm8Dct_mp1cvbxISQQi3JBlRfbjEzF48,2528
+libterm-0.0.1.dist-info/METADATA,sha256=7NuroGFhL3AWgyBlj7ojoMG5u4R-1LITMmNnOuVUolY,51
+libterm-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+libterm-0.0.1.dist-info/top_level.txt,sha256=pKN_iVl3hsXjz-Dqvni3ur7y7mdgHZrJ3OI7fBbH-lE,8
+libterm-0.0.1.dist-info/RECORD,,

libterm-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

libterm-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+libTerm