cli-ih 0.6.3.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

cli_ih/__init__.py

@@ -1,5 +1,6 @@
 from .client import InputHandler
 from .asyncClient import AsyncInputHandler
+from .utils import safe_print
 import importlib.metadata
 
 try:

cli_ih/asyncClient.py

@@ -1,15 +1,22 @@
 from typing import Coroutine, Callable, Any
 from .exceptions import HandlerClosed
-import logging, warnings, asyncio, inspect, threading
+from .utils import safe_print as print, register_handler
+import logging, warnings, asyncio, inspect, threading, sys, shutil, msvcrt
 
 class AsyncInputHandler:
-    def __init__(self, cursor = "", *, logger: logging.Logger | None = None, register_defaults: bool = True):
+    def __init__(self, cursor = "", thread_mode: bool = True, *, logger: logging.Logger | None = None, register_defaults: bool = True):
+        register_handler(self)
         self.commands = {}
         self.is_running = False
+        self.thread_mode = thread_mode
         self.cursor = f"{cursor.strip()} " if cursor else ""
         self.global_logger = logger if logger else None
         self.logger = logger.getChild("InputHandler") if logger else None
         self.register_defaults = register_defaults
+        self.print_lock = threading.Lock()
+        self.input_buffer = ""
+        self.processing_command = False
+        
         if self.register_defaults:
             self.register_default_commands()
         else:
@@ -71,23 +78,71 @@ class AsyncInputHandler:
             return func
         return decorator
 
-    async def start(self):
-        """Starts the input handler loop in a separate thread if thread mode is enabled."""
+    def start(self):
+        """Starts the input handler loop. Runs in a thread if thread_mode is True, otherwise blocks."""
         self.is_running = True
+        if self.thread_mode:
+            thread = threading.Thread(target=self._start_thread, daemon=True)
+            thread.start()
+        else:
+            self._start_thread()
+
+    def _start_thread(self):
+        asyncio.run(self._run())
+
+    async def _run(self):
+        """Starts the input handler loop in a separate thread if thread mode is enabled."""
         loop = asyncio.get_running_loop()
         input_queue = asyncio.Queue()
 
         def _input_worker():
+            # Initial prompt
+            with self.print_lock:
+                sys.stdout.write(self.cursor)
+                sys.stdout.flush()
+
             while self.is_running:
                 try:
-                    text = input(self.cursor)
-                    loop.call_soon_threadsafe(input_queue.put_nowait, text)
-                except EOFError:
-                    loop.call_soon_threadsafe(input_queue.put_nowait, EOFError)
-                    break
+                    if msvcrt.kbhit():
+                        char = msvcrt.getwch()
+                        
+                        if char == '\r': # Enter
+                            with self.print_lock:
+                                sys.stdout.write('\n')
+                                sys.stdout.flush()
+                            text = self.input_buffer
+                            self.input_buffer = ""
+                            loop.call_soon_threadsafe(input_queue.put_nowait, text)
+                                
+                        elif char == '\x08': # Backspace
+                            if len(self.input_buffer) > 0:
+                                self.input_buffer = self.input_buffer[:-1]
+                                with self.print_lock:
+                                    sys.stdout.write('\b \b')
+                                    sys.stdout.flush()
+                        
+                        elif char == '\x03': # Ctrl+C
+                            loop.call_soon_threadsafe(input_queue.put_nowait, KeyboardInterrupt)
+                            break
+                        
+                        else:
+                            # Verify printable
+                            if char.isprintable():
+                                self.input_buffer += char
+                                with self.print_lock:
+                                    sys.stdout.write(char)
+                                    sys.stdout.flush()
+                    else:
+                        pass
+                        # Small sleep to prevent high CPU usage, 
+                        # but we are in a dedicated thread so it's fine-ish, 
+                        # actually explicit sleep is good.
+                        import time
+                        time.sleep(0.01)
+
                 except Exception:
                     break
-
+        
         thread = threading.Thread(target=_input_worker, daemon=True)
         thread.start()
 
@@ -152,6 +207,7 @@ class AsyncInputHandler:
                 if not user_input:
                     continue
 
+                self.processing_command = True
                 cmdargs = user_input.split(' ')
                 command_name = cmdargs[0].lower()
                 args = cmdargs[1:]
@@ -159,6 +215,13 @@ class AsyncInputHandler:
                     await _run_command(self.commands, command_name, args)
                 else:
                     self.__warning(f"Unknown command: '{command_name}'")
+                self.processing_command = False
+                
+                # Reprompt after command execution
+                with self.print_lock:
+                    sys.stdout.write(self.cursor)
+                    sys.stdout.flush()
+                
             except EOFError:
                 self.__error("Input ended unexpectedly.")
                 break

cli_ih/client.py

@@ -1,9 +1,11 @@
 from typing import Callable
 from .exceptions import HandlerClosed
-import logging, warnings
+from .utils import safe_print as print, register_handler
+import logging, warnings, sys, shutil, threading, msvcrt
 
 class InputHandler:
     def __init__(self, thread_mode = True, cursor = "", *, logger: logging.Logger | None = None, register_defaults: bool = True):
+        register_handler(self)
         self.commands = {}
         self.is_running = False
         self.thread_mode = thread_mode
@@ -12,6 +14,10 @@ class InputHandler:
         self.global_logger = logger if logger else None
         self.logger = logger.getChild("InputHandler") if logger else None
         self.register_defaults = register_defaults
+        self.print_lock = threading.Lock()
+        self.input_buffer = ""
+        self.processing_command = False
+        
         if self.register_defaults:
             self.register_default_commands()
         else:
@@ -130,26 +136,65 @@ class InputHandler:
             """Continuously listens for user input and processes commands."""
             while self.is_running:
                 try:
-                    user_input = input(self.cursor).strip()
-                    if not user_input:
-                        continue
-
-                    cmdargs = user_input.split(' ')
-                    command_name = cmdargs[0].lower()
-                    args = cmdargs[1:]
-                    if command_name in self.commands:
-                        _run_command(self.commands, command_name, args)
-                    else:
-                        self.__warning(f"Unknown command: '{command_name}'")
-                except EOFError:
-                    self.__error("Input ended unexpectedly.")
-                    break
-                except KeyboardInterrupt:
-                    self.__error("Input interrupted.")
-                    break
+                    # Initial prompt
+                    with self.print_lock:
+                        sys.stdout.write(self.cursor)
+                        sys.stdout.flush()
+                        
+                    while self.is_running:
+                        if msvcrt.kbhit():
+                            char = msvcrt.getwch()
+                            
+                            if char == '\r': # Enter
+                                with self.print_lock:
+                                    sys.stdout.write('\n')
+                                    sys.stdout.flush()
+                                text = self.input_buffer
+                                self.input_buffer = ""
+                                
+                                if text:
+                                    self.processing_command = True
+                                    cmdargs = text.split(' ')
+                                    command_name = cmdargs[0].lower()
+                                    args = cmdargs[1:]
+                                    if command_name in self.commands:
+                                        _run_command(self.commands, command_name, args)
+                                    else:
+                                        self.__warning(f"Unknown command: '{command_name}'")
+                                    self.processing_command = False
+                                
+                                # Break inner loop to reprompt
+                                break
+                                    
+                            elif char == '\x08': # Backspace
+                                if len(self.input_buffer) > 0:
+                                    self.input_buffer = self.input_buffer[:-1]
+                                    with self.print_lock:
+                                        sys.stdout.write('\b \b')
+                                        sys.stdout.flush()
+                            
+                            elif char == '\x03': # Ctrl+C
+                                self.__error("Input interrupted.")
+                                self.is_running = False
+                                return
+                            
+                            else:
+                                # Verify printable
+                                if char.isprintable():
+                                    self.input_buffer += char
+                                    with self.print_lock:
+                                        sys.stdout.write(char)
+                                        sys.stdout.flush()
+                        else:
+                            import time
+                            time.sleep(0.01)
+
                 except HandlerClosed:
                     self.__info("Input Handler exited.")
                     break
+                except Exception as e:
+                    self.__exeption("Input loop error", e)
+                    break
             self.is_running = False
         if self.thread_mode:
             self.thread = threading.Thread(target=_thread, daemon=True)

cli_ih/utils.py

@@ -0,0 +1,51 @@
+import shutil
+import sys
+
+_HANDLER = None
+
+def register_handler(handler):
+    global _HANDLER
+    _HANDLER = handler
+
+def safe_print(msg: str, cursor: str | None = None, input_buffer: str | None = None):
+    """
+    Prints a message safely while preserving the current input buffer and cursor.
+    This ensures logs appear above the input line appropriately.
+    """
+    if cursor is None and input_buffer is None and _HANDLER is not None:
+        lock = None
+        try:
+            # Try to acquire lock if available to prevent race conditions
+            lock = getattr(_HANDLER, "print_lock", None)
+            if lock:
+                lock.acquire()
+            
+            cursor = str(getattr(_HANDLER, "cursor", ""))
+            input_buffer = str(getattr(_HANDLER, "input_buffer", ""))
+            processing_command = getattr(_HANDLER, "processing_command", False)
+            
+            if processing_command:
+                cursor = ""
+                input_buffer = ""
+            
+            _do_safe_print(msg, cursor, input_buffer)
+        finally:
+            if lock:
+                lock.release()
+    else:
+        # Fallback or explicit arguments
+        _do_safe_print(msg, cursor or "", input_buffer or "")
+
+def _do_safe_print(msg: str, cursor: str, input_buffer: str):
+    try:
+        columns = shutil.get_terminal_size().columns
+    except:
+        columns = 80
+            
+    # Clear line
+    sys.stdout.write('\r' + ' ' * (columns - 1) + '\r')
+    # Print message
+    sys.stdout.write(f"{msg}\n")
+    # Reprint cursor and buffer
+    sys.stdout.write(f"{cursor}{input_buffer}")
+    sys.stdout.flush()

{cli_ih-0.6.3.1.dist-info → cli_ih-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_ih
-Version: 0.6.3.1
+Version: 0.7.0
 Summary: A background command handler for python's command-line interface.
 Author-email: Hotment <michatchuplay@gmail.com>
 Requires-Python: >=3.8

cli_ih-0.7.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+cli_ih/__init__.py,sha256=wCwv9grczxpu7EXqunCdFgAWlx3XEZVw4O4U3fs45PY,278
+cli_ih/asyncClient.py,sha256=L7nCURM15Y9BIrSyfdeLB8PPddr1OF3IA8NWY26HyQQ,11171
+cli_ih/client.py,sha256=GWZH5YX2dDV7A2usgnX9xDm8xVjwLSj09sh5vfHSW-Y,10573
+cli_ih/exceptions.py,sha256=0xqaMCVu-yEURIrB6wEhbf6kfdsRmODJBoDsQTOp29s,156
+cli_ih/utils.py,sha256=HstJPjjlTfVKz68sHU_whSBsOoBKhxizCcycNyQeK2k,1685
+cli_ih-0.7.0.dist-info/METADATA,sha256=yu19a6SGAo79STCAgcxBVU4cqbvcYgIZ_KE7hyl_OcY,2789
+cli_ih-0.7.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cli_ih-0.7.0.dist-info/top_level.txt,sha256=Ve1CRLNXhPyPSkpN0xLu26roh30LQCpNzkF61BZYfk0,7
+cli_ih-0.7.0.dist-info/RECORD,,

{cli_ih-0.6.3.1.dist-info → cli_ih-0.7.0.dist-info}/top_level.txt

@@ -1,2 +1 @@
 cli_ih
-venv