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

cli_ih/asyncClient.py

@@ -1,6 +1,6 @@
-from typing import Coroutine, Callable, Any
+from typing import Callable, Any
 from .exceptions import HandlerClosed
-from .utils import safe_print as print, register_handler
+from .utils import safe_print as print, register_handler, SafeLogger
 import logging, warnings, asyncio, inspect, threading, sys, shutil, msvcrt
 
 class AsyncInputHandler:
@@ -10,12 +10,14 @@ class AsyncInputHandler:
         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.global_logger = logger if logger else SafeLogger()
+        self.logger = logger.getChild("InputHandler") if logger else self.global_logger
         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()
@@ -26,34 +28,19 @@ class AsyncInputHandler:
         return self.logger
     
     def __debug(self, msg: str):
-        if self.logger:
-            self.logger.debug(msg)
-        else:
-            print(f"[DEBUG]: {msg}")
+        self.logger.debug(msg)
     
     def __info(self, msg: str):
-        if self.logger:
-            self.logger.info(msg)
-        else:
-            print(f"[INFO]: {msg}")
+        self.logger.info(msg)
 
     def __warning(self, msg: str):
-        if self.logger:
-            self.logger.warning(msg)
-        else:
-            print(f"[WARNING]: {msg}")
+        self.logger.warning(msg)
 
     def __error(self, msg: str):
-        if self.logger:
-            self.logger.error(msg)
-        else:
-            print(f"[ERROR]: {msg}")
+        self.logger.error(msg)
     
     def __exeption(self, msg: str, e: Exception):
-        if self.logger:
-            self.logger.exception(f"{msg}: {e}")
-        else:
-            print(f"[EXEPTION]: {msg}: {e}")
+        self.logger.exception(f"{msg}: {e}")
 
     def __register_cmd(self, name: str, func: Callable[..., Any], description: str = "", legacy=False):
         name = name.lower()
@@ -96,7 +83,6 @@ class AsyncInputHandler:
         input_queue = asyncio.Queue()
 
         def _input_worker():
-            # Initial prompt
             with self.print_lock:
                 sys.stdout.write(self.cursor)
                 sys.stdout.flush()
@@ -106,37 +92,66 @@ class AsyncInputHandler:
                     if msvcrt.kbhit():
                         char = msvcrt.getwch()
                         
-                        if char == '\r': # Enter
+                        if char == '\xe0' or char == '\x00':
+                            try:
+                                scancode = msvcrt.getwch()
+                                if scancode == 'H':
+                                    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':
+                                    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':
                             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
+                        elif char == '\x08':
                             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
+                        elif char == '\x03':
                             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)
 
@@ -146,7 +161,7 @@ class AsyncInputHandler:
         thread = threading.Thread(target=_input_worker, daemon=True)
         thread.start()
 
-        async def _run_command(commands: dict, name: str, args: list):
+        async def _run_command(commands: dict[str, dict[str, Any]], name: str, args: list[str]):
             """Executes a command from the command dictionary if it exists."""
             command = commands.get(name)
             if not command:

cli_ih/client.py

@@ -1,7 +1,7 @@
-from typing import Callable
+from typing import Callable, Any
 from .exceptions import HandlerClosed
-from .utils import safe_print as print, register_handler
-import logging, warnings, sys, shutil, threading, msvcrt
+from .utils import safe_print as print, register_handler, SafeLogger
+import logging, sys, threading, warnings, inspect, shutil, msvcrt
 
 class InputHandler:
     def __init__(self, thread_mode = True, cursor = "", *, logger: logging.Logger | None = None, register_defaults: bool = True):
@@ -11,12 +11,14 @@ class InputHandler:
         self.thread_mode = thread_mode
         self.cursor = f"{cursor.strip()} " if cursor else ""
         self.thread = None
-        self.global_logger = logger if logger else None
-        self.logger = logger.getChild("InputHandler") if logger else None
+        self.global_logger = logger if logger else SafeLogger()
+        self.logger = logger.getChild("InputHandler") if logger else self.global_logger
         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()
@@ -27,36 +29,21 @@ class InputHandler:
         return self.logger
     
     def __debug(self, msg: str):
-        if self.logger:
-            self.logger.debug(msg)
-        else:
-            print(f"[DEBUG]: {msg}")
+        self.logger.debug(msg)
     
     def __info(self, msg: str):
-        if self.logger:
-            self.logger.info(msg)
-        else:
-            print(f"[INFO]: {msg}")
+        self.logger.info(msg)
 
     def __warning(self, msg: str):
-        if self.logger:
-            self.logger.warning(msg)
-        else:
-            print(f"[WARNING]: {msg}")
+        self.logger.warning(msg)
 
     def __error(self, msg: str):
-        if self.logger:
-            self.logger.error(msg)
-        else:
-            print(f"[ERROR]: {msg}")
+        self.logger.error(msg)
     
     def __exeption(self, msg: str, e: Exception):
-        if self.logger:
-            self.logger.exception(f"{msg}: {e}")
-        else:
-            print(f"[EXEPTION]: {msg}: {e}")
+        self.logger.exception(f"{msg}: {e}")
 
-    def __register_cmd(self, name: str, func: Callable, description: str = "", legacy=False):
+    def __register_cmd(self, name: str, func: Callable[..., Any], description: str = "", legacy=False):
         name = name.lower()
         if not description:
             description = "A command"
@@ -66,14 +53,14 @@ class InputHandler:
             raise SyntaxError(f"Command '{name}' is already registered. If theese commands have a different case and they need to stay the same, downgrade the package version to 0.5.x")
         self.commands[name] = {"cmd": func, "description": description, "legacy": legacy}
 
-    def register_command(self, name: str, func: Callable, description: str = ""):
+    def register_command(self, name: str, func: Callable[..., Any], description: str = ""):
         """(DEPRECATED) Registers a command with its associated function."""
         warnings.warn("Registering commands with `register_command` is deprecated, and should not be used.", DeprecationWarning, 2)
         self.__register_cmd(name, func, description, legacy=True)
 
     def command(self, *, name: str = "", description: str = ""):
         """Registers a command with its associated function as a decorator."""
-        def decorator(func: Callable):
+        def decorator(func: Callable[..., Any]):
             lname = name or func.__name__
             self.__register_cmd(lname, func, description)
             return func
@@ -136,7 +123,6 @@ class InputHandler:
             """Continuously listens for user input and processes commands."""
             while self.is_running:
                 try:
-                    # Initial prompt
                     with self.print_lock:
                         sys.stdout.write(self.cursor)
                         sys.stdout.flush()
@@ -145,7 +131,35 @@ class InputHandler:
                         if msvcrt.kbhit():
                             char = msvcrt.getwch()
                             
-                            if char == '\r': # Enter
+                            if char == '\xe0' or char == '\x00':
+                                try:
+                                    scancode = msvcrt.getwch()
+                                    if scancode == 'H':
+                                        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':
+                                        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':
                                 with self.print_lock:
                                     sys.stdout.write('\n')
                                     sys.stdout.flush()
@@ -153,6 +167,10 @@ class InputHandler:
                                 self.input_buffer = ""
                                 
                                 if text:
+                                    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()
@@ -163,23 +181,21 @@ class InputHandler:
                                         self.__warning(f"Unknown command: '{command_name}'")
                                     self.processing_command = False
                                 
-                                # Break inner loop to reprompt
                                 break
                                     
-                            elif char == '\x08': # Backspace
+                            elif char == '\x08':
                                 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
+                            elif char == '\x03':
                                 self.__error("Input interrupted.")
                                 self.is_running = False
                                 return
                             
                             else:
-                                # Verify printable
                                 if char.isprintable():
                                     self.input_buffer += char
                                     with self.print_lock:

cli_ih/utils.py

@@ -1,5 +1,6 @@
 import shutil
 import sys
+import threading
 
 _HANDLER = None
 
@@ -7,15 +8,55 @@ def register_handler(handler):
     global _HANDLER
     _HANDLER = handler
 
-def safe_print(msg: str, cursor: str | None = None, input_buffer: str | None = None):
+class SafeLogger:
+    """A dummy logger that uses safe_print to output logs to the console."""
+    def __init__(self):
+        self.handlers = []
+
+    def debug(self, msg: str):
+        safe_print(f"[DEBUG]: {msg}")
+
+    def info(self, msg: str):
+        safe_print(f"[INFO]: {msg}")
+
+    def warning(self, msg: str):
+        safe_print(f"[WARNING]: {msg}")
+
+    def error(self, msg: str):
+        safe_print(f"[ERROR]: {msg}")
+        
+    def critical(self, msg: str):
+        safe_print(f"[CRITICAL]: {msg}")
+
+    def exception(self, msg: str):
+        safe_print(f"[EXCEPTION]: {msg}")
+
+    def log(self, level, msg: str):
+        safe_print(f"[LOG {level}]: {msg}")
+    
+    def getChild(self, name):
+        return self
+    
+    def setLevel(self, level):
+        pass
+
+    def getEffectiveLevel(self):
+        return 0
+
+
+def safe_print(msg: object, 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.
     """
+    try:
+        msg = str(msg)
+    except:
+        msg = "<Unprintable Object>"
+
     if cursor is None and input_buffer is None and _HANDLER is not None:
-        lock = None
+        lock: threading.Lock | None = None
         try:
-            # Try to acquire lock if available to prevent race conditions
             lock = getattr(_HANDLER, "print_lock", None)
             if lock:
                 lock.acquire()
@@ -33,8 +74,7 @@ def safe_print(msg: str, cursor: str | None = None, input_buffer: str | None = N
             if lock:
                 lock.release()
     else:
-        # Fallback or explicit arguments
-        _do_safe_print(msg, cursor or "", input_buffer or "")
+        _do_safe_print(msg, str(cursor or ""), str(input_buffer or ""))
 
 def _do_safe_print(msg: str, cursor: str, input_buffer: str):
     try:
@@ -42,10 +82,7 @@ def _do_safe_print(msg: str, cursor: str, input_buffer: str):
     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.1.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: cli_ih
+Version: 0.7.1.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.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+cli_ih/__init__.py,sha256=wCwv9grczxpu7EXqunCdFgAWlx3XEZVw4O4U3fs45PY,278
+cli_ih/asyncClient.py,sha256=56RLucih5qVNuxFR0EefExyohSheOh0BjomSoTMBEkU,12633
+cli_ih/client.py,sha256=7jrFFrLdXln5VS4EG_YEse9oaa6n4FnUll5rvZNFiTc,12284
+cli_ih/exceptions.py,sha256=0xqaMCVu-yEURIrB6wEhbf6kfdsRmODJBoDsQTOp29s,156
+cli_ih/utils.py,sha256=3WcqvHrwwsiBYlkzIV51_SLsbtqpqEcN5v4Hu3E48Uw,2501
+cli_ih-0.7.1.1.dist-info/METADATA,sha256=LO2NUmmDsuOAGtVEQsXuJZ7Cm3FuF45-1LyXPK7Nx7U,3413
+cli_ih-0.7.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cli_ih-0.7.1.1.dist-info/top_level.txt,sha256=Ve1CRLNXhPyPSkpN0xLu26roh30LQCpNzkF61BZYfk0,7
+cli_ih-0.7.1.1.dist-info/RECORD,,

cli_ih-0.7.0.dist-info/METADATA

@@ -1,86 +0,0 @@
-Metadata-Version: 2.4
-Name: cli_ih
-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
-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)

cli_ih-0.7.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-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,,