cli-ih 0.6.3.1__py3-none-any.whl → 0.7.1__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,24 @@
 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
+        self.history = []
+        self.history_index = 0
+        
         if self.register_defaults:
             self.register_default_commands()
         else:
@@ -71,23 +80,105 @@ 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 == '\xe0' or char == '\x00': # Special keys (Arrows, etc)
+                            try:
+                                scancode = msvcrt.getwch()
+                                if scancode == 'H': # Up Arrow
+                                    if self.history_index > 0:
+                                        self.history_index -= 1
+                                        self.input_buffer = self.history[self.history_index]
+                                        with self.print_lock:
+                                            sys.stdout.write('\r' + ' ' * (shutil.get_terminal_size().columns - 1) + '\r')
+                                            sys.stdout.write(self.cursor + self.input_buffer)
+                                            sys.stdout.flush()
+                                    
+                                elif scancode == 'P': # Down Arrow
+                                    if self.history_index < len(self.history):
+                                        self.history_index += 1
+                                        
+                                    if self.history_index == len(self.history):
+                                        self.input_buffer = ""
+                                    else:
+                                        self.input_buffer = self.history[self.history_index]
+                                        
+                                    with self.print_lock:
+                                        sys.stdout.write('\r' + ' ' * (shutil.get_terminal_size().columns - 1) + '\r')
+                                        sys.stdout.write(self.cursor + self.input_buffer)
+                                        sys.stdout.flush()
+                            except Exception:
+                                pass
+
+                        elif char == '\r': # Enter
+                            with self.print_lock:
+                                sys.stdout.write('\n')
+                                sys.stdout.flush()
+                            text = self.input_buffer
+                            self.input_buffer = ""
+                            
+                            if text:
+                                if not self.history or self.history[-1] != text:
+                                    self.history.append(text)
+                                self.history_index = len(self.history)
+                            
+                            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 +243,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 +251,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,12 @@ 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
+        self.history = []
+        self.history_index = 0
+        
         if self.register_defaults:
             self.register_default_commands()
         else:
@@ -130,26 +138,110 @@ 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 == '\xe0' or char == '\x00': # Special keys (Arrows, etc)
+                                try:
+                                    scancode = msvcrt.getwch()
+                                    if scancode == 'H': # Up Arrow
+                                        if self.history_index > 0:
+                                            self.history_index -= 1
+                                            self.input_buffer = self.history[self.history_index]
+                                            with self.print_lock:
+                                                # Clear current line visually
+                                                # We don't have columns info here easily, but safe_print logic uses clearing.
+                                                # Let's try to just use \r and spaces? No, let's just use \r and overwrite.
+                                                # To properly clear, we need to know the length of what was there.
+                                                # A reuse of _safe_print logic might be good but avoiding circularity.
+                                                # Simple clear strategy: \r, print many spaces, \r, print prompt + buffer
+                                                # Or better: \r + prompt + buffer + spaces to clear rest?
+                                                
+                                                # We'll use a crude clear for now or simple overwrite if shorter?
+                                                # Best to clear the line.
+                                                sys.stdout.write('\r' + ' ' * (shutil.get_terminal_size().columns - 1) + '\r')
+                                                sys.stdout.write(self.cursor + self.input_buffer)
+                                                sys.stdout.flush()
+                                        
+                                    elif scancode == 'P': # Down Arrow
+                                        if self.history_index < len(self.history):
+                                            self.history_index += 1
+                                            
+                                        if self.history_index == len(self.history):
+                                            self.input_buffer = ""
+                                        else:
+                                            self.input_buffer = self.history[self.history_index]
+                                            
+                                        with self.print_lock:
+                                            sys.stdout.write('\r' + ' ' * (shutil.get_terminal_size().columns - 1) + '\r')
+                                            sys.stdout.write(self.cursor + self.input_buffer)
+                                            sys.stdout.flush()
+                                except Exception:
+                                    pass
+
+                            elif char == '\r': # Enter
+                                with self.print_lock:
+                                    sys.stdout.write('\n')
+                                    sys.stdout.flush()
+                                text = self.input_buffer
+                                self.input_buffer = ""
+                                
+                                if text:
+                                    # Add to history if unique or last one different? 
+                                    # Usually standard behavior: always add, or add if different from last.
+                                    # Let's add if not empty.
+                                    if not self.history or self.history[-1] != text:
+                                        self.history.append(text)
+                                    self.history_index = len(self.history)
+                                    
+                                    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.7.1.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: cli_ih
+Version: 0.7.1
+Summary: A background command handler for python's command-line interface.
+Author-email: Hotment <michatchuplay@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# InputHandler Library
+
+A lightweight Python library for creating interactive command-line interfaces with custom command registration, input handling, and clean log output. It supports synchronous and asynchronous modes, threaded input processing, and enhanced logging.
+
+## Features
+
+- **Command Registration**: Register commands with decorators and descriptions.
+- **Threaded Input**: Non-blocking input handling by default.
+- **Safe Printing**: Logs appear above the input line, preserving your typed text and cursor position.
+- **Command History**: Navigate recent commands with Up/Down arrow keys.
+- **Sync & Async**: Support for both synchronous and asynchronous (asyncio) applications.
+- **Colored Logging**: Built-in support for colored log messages.
+
+## Installation
+
+`pip install cli_ih`
+
+## Quick Start (Synchronous)
+
+```python
+from cli_ih import InputHandler, safe_print
+
+handler = InputHandler(cursor="> ")
+
+# Use safe_print instead of print to keep the input line clean!
+@handler.command(name="greet", description="Greets the user.")
+def greet(name):
+    safe_print(f"Hello, {name}!")
+
+@handler.command(name="add", description="Adds two numbers.")
+def add(a, b):
+    safe_print(int(a) + int(b))
+
+handler.start()
+
+# Using safe_print allows you to print logs in the background 
+# without messing up the user's current input line.
+```
+
+## Async Client Example
+
+The `AsyncInputHandler` integrates with `asyncio`. The `start()` method is non-blocking when `thread_mode=True` (default).
+
+```python
+import asyncio
+from cli_ih import AsyncInputHandler, safe_print
+
+handler = AsyncInputHandler(cursor="Async> ")
+
+@handler.command(name="greet", description="Greets the user asynchronously.")
+async def greet(name):
+    await asyncio.sleep(1)
+    safe_print(f"Hello, {name}")
+
+@handler.command(name="add", description="Adds two numbers.")
+async def add(a, b):
+    safe_print(int(a) + int(b))
+
+# Start the handler (runs in a separate thread by default)
+handler.start()
+
+# Keep the main thread alive or run your main event loop
+async def main():
+    while handler.is_running:
+        await asyncio.sleep(1)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Key Considerations
+
+### Safe Printing
+Always use `from cli_ih import safe_print` for outputting text to the console. This utility automatically detects the active input handler and ensures that your log message is printed *above* the current input line, preserving the user's cursor and any text they are currently typing.
+
+```python
+from cli_ih import safe_print
+
+# Good
+safe_print("Log message")
+
+# Avoid (might disrupt input line)
+print("Log message")
+```
+
+### Thread Mode
+Both `InputHandler` and `AsyncInputHandler` accept a `thread_mode` parameter (default `True`).
+- `thread_mode=True`: The input loop runs in a separate thread. `start()` returns immediately.
+- `thread_mode=False`: The input loop runs in the current thread. `start()` blocks until exit.
+
+### Command History
+Use the **Up** and **Down** arrow keys to cycle through your previously entered commands, just like in a standard terminal.

cli_ih-0.7.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+cli_ih/__init__.py,sha256=wCwv9grczxpu7EXqunCdFgAWlx3XEZVw4O4U3fs45PY,278
+cli_ih/asyncClient.py,sha256=v7JaKi50xCEiqFUHlxhf83EoXzAwQ-r8VCjdlYz3q4c,13399
+cli_ih/client.py,sha256=EKgVCfC-O-Xxdxb7ZqG6DgYvti37wtpjthYns6ghssA,14158
+cli_ih/exceptions.py,sha256=0xqaMCVu-yEURIrB6wEhbf6kfdsRmODJBoDsQTOp29s,156
+cli_ih/utils.py,sha256=HstJPjjlTfVKz68sHU_whSBsOoBKhxizCcycNyQeK2k,1685
+cli_ih-0.7.1.dist-info/METADATA,sha256=rd-ysIOjWIYi8SgIGLbf8TGogLorPQziQCmOej_xQaA,3411
+cli_ih-0.7.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cli_ih-0.7.1.dist-info/top_level.txt,sha256=Ve1CRLNXhPyPSkpN0xLu26roh30LQCpNzkF61BZYfk0,7
+cli_ih-0.7.1.dist-info/RECORD,,

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

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

cli_ih-0.6.3.1.dist-info/METADATA

@@ -1,86 +0,0 @@
-Metadata-Version: 2.4
-Name: cli_ih
-Version: 0.6.3.1
-Summary: A background command handler for python's command-line interface.
-Author-email: Hotment <michatchuplay@gmail.com>
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# InputHandler Library
-
-A lightweight Python library for creating interactive command-line interfaces with custom command registration and input handling. It supports threaded input processing and includes enhanced logging with color-coded output.
-
-## Features
-
-- Command registration system with descriptions
-- Threaded or non-threaded input handling
-- Colored logging with support for debug mode
-- Built-in `help`, `debug`, and `exit` commands
-- Error handling for missing or invalid command arguments
-- NEW: Register commands with decorators
-
-## Installation
-
-`pip install cli_ih`
-
-## Quick Start
-
-```python
-from cli_ih import InputHandler
-
-def greet(args):
-    print(f"Hello, {' '.join(args)}!")
-
-handler = InputHandler(cursor="> ")
-# NEW
-@handler.command(name="add", description="Performs the `+` operator on the first 2 arguments.") # The name param will use the func name if its not provided
-def add(args):
-    print(int(args[0])+int(args[1]))
-
-handler.register_command("greet", greet, "Greets the user. Usage: greet [name]")
-handler.start()
-
-# Now type commands like:
-# > greet world
-# Hello, world!
-# > add 1 2
-# 3
-# > help
-# Available commands:
-#   help: Displays all the available commands
-#   debug: If a logger is present changes the logging level to DEBUG.
-#   exit: Exits the Input Handler irreversibly.
-#   add: Performs the `+` operator on the first 2 arguments.
-#   greet: Greets the user. Usage: greet [name]
-#
-# > debug
-# > exit
-```
-
-## New Async client
-```python
-import asyncio
-from cli_ih import AsyncInputHandler
-
-print(cli_ih.__version__)
-
-handler = AsyncInputHandler(cursor="> ")
-
-@handler.command(name="greet", description="Greets the user. Usage: greet [name]")
-async def greet(name, *args):
-    await asyncio.sleep(1)
-    print(f"Hello, {name}{" " if args else ""}{' '.join(args)}!")
-# NEW
-@handler.command(name="add", description="Performs the `+` operator on the first 2 arguments.")
-async def add(a, b):
-    print(a+b)
-
-asyncio.run(handler.start())
-```
-
-## Additional Info
-
-- You can provide a valid logger `logger=logger` to the `InputHandler` to enable logging (this will be removed soon)
-- You can provide the `thread_mode` param to the `InputHandler` class to set if it shoud run in a thread or no.
-(If you are using the `cli-ih` module on its own without any other background task set `thread_mode=False` to false)
-- You can also provide a `cursor` param to the `InputHandler` class to set the cli cursor (default cusor is empty)