cli-ih 0.6.3__tar.gz → 0.7.0__tar.gz

{cli_ih-0.6.3 → cli_ih-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_ih
-Version: 0.6.3
+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.6.3 → cli_ih-0.7.0}/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-0.6.3 → cli_ih-0.7.0}/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()
 
@@ -106,26 +161,32 @@ class AsyncInputHandler:
 
             try:
                 sig = inspect.signature(func)
+                has_var_args = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in sig.parameters.values())
+                if has_var_args:
+                    final_args = args
+                else:
+                    params = [p for p in sig.parameters.values() if p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.POSITIONAL_ONLY)]
+                    final_args = args[:len(params)]
                 if is_legacy:
-                    sig.bind(args)
+                    sig.bind(final_args)
                 else:
-                    sig.bind(*args)
+                    sig.bind(*final_args)
             except TypeError as e:
-                self.__warning(f"Argument error for legacy command '{name}': {e}")
+                self.__warning(f"Argument error for {"legacy " if is_legacy else ""}command '{name}': {e}")
                 return
 
             try:
                 if is_legacy:
                     warnings.warn("This way of running commands id Deprecated. And should be changed to the new decorator way.", DeprecationWarning, 2)
                     if inspect.iscoroutinefunction(func):
-                        await func(args)
+                        await func(final_args)
                     else:
-                        await asyncio.to_thread(func, args)
+                        await asyncio.to_thread(func, final_args)
                 else:
                     if inspect.iscoroutinefunction(func):
-                        await func(*args)
+                        await func(*final_args)
                     else:
-                        await asyncio.to_thread(func, *args)
+                        await asyncio.to_thread(func, *final_args)
 
             except HandlerClosed as e:
                 raise e
@@ -146,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:]
@@ -153,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-0.6.3 → cli_ih-0.7.0}/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:
@@ -85,30 +91,37 @@ class InputHandler:
                 func = command.get("cmd")
                 is_legacy = command.get("legacy", False)
                 if callable(func):
+                    sig = inspect.signature(func)
+                    has_var_args = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in sig.parameters.values())
+
+                    if has_var_args:
+                        final_args = args
+                    else:
+                        params = [p for p in sig.parameters.values() if p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.POSITIONAL_ONLY)]
+                        final_args = args[:len(params)]
+
                     if is_legacy:
                         try:
-                            sig = inspect.signature(func)
-                            sig.bind(args)
+                            sig.bind(final_args)
                         except TypeError as e:
                             self.__warning(f"Argument error for legacy command '{name}': {e}")
                             return
                         
                         try:
                             warnings.warn("This way of running commands id Deprecated. And should be changed to the new decorator way.", DeprecationWarning, 2)
-                            func(args)
+                            func(final_args)
                         except HandlerClosed as e:
                             raise e
                         except Exception as e:
                             self.__exeption(f"An error occurred in legacy command '{name}'", e)
                     else:
                         try:
-                            sig = inspect.signature(func)
-                            sig.bind(*args) 
+                            sig.bind(*final_args) 
                         except TypeError as e:
                             self.__warning(f"Argument error for command '{name}': {e}")
                             return
                         try:
-                            func(*args)
+                            func(*final_args)
                         except HandlerClosed as e:
                             raise e
                         except Exception as e:
@@ -123,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-0.7.0/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 → cli_ih-0.7.0}/cli_ih.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_ih
-Version: 0.6.3
+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.6.3 → cli_ih-0.7.0}/cli_ih.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ cli_ih/__init__.py
 cli_ih/asyncClient.py
 cli_ih/client.py
 cli_ih/exceptions.py
+cli_ih/utils.py
 cli_ih.egg-info/PKG-INFO
 cli_ih.egg-info/SOURCES.txt
 cli_ih.egg-info/dependency_links.txt

{cli_ih-0.6.3 → cli_ih-0.7.0}/cli_ih.egg-info/top_level.txt

@@ -1,2 +1,3 @@
+build
 cli_ih
 dist

{cli_ih-0.6.3 → cli_ih-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cli_ih"
-version = "0.6.3"
+version = "0.7.0"
 description = "A background command handler for python's command-line interface."
 readme = "README.md"
 requires-python = ">= 3.8"