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

cli_ih-0.7.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,92 @@
+# 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.0 → cli_ih-0.7.1}/cli_ih/asyncClient.py

@@ -16,6 +16,8 @@ class AsyncInputHandler:
         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()
@@ -106,12 +108,46 @@ class AsyncInputHandler:
                     if msvcrt.kbhit():
                         char = msvcrt.getwch()
                         
-                        if char == '\r': # Enter
+                        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

{cli_ih-0.7.0 → cli_ih-0.7.1}/cli_ih/client.py

@@ -17,6 +17,8 @@ class InputHandler:
         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()
@@ -145,7 +147,45 @@ class InputHandler:
                         if msvcrt.kbhit():
                             char = msvcrt.getwch()
                             
-                            if char == '\r': # Enter
+                            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()
@@ -153,6 +193,13 @@ class InputHandler:
                                 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()

cli_ih-0.7.1/cli_ih.egg-info/PKG-INFO

@@ -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.0 → cli_ih-0.7.1}/pyproject.toml

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

cli_ih-0.7.0/PKG-INFO

@@ -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/README.md

@@ -1,78 +0,0 @@
-# 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/cli_ih.egg-info/PKG-INFO

@@ -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)