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

{cli_ih-0.7.1 → cli_ih-0.7.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_ih
-Version: 0.7.1
+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

{cli_ih-0.7.1 → cli_ih-0.7.1.1}/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,8 +10,8 @@ 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 = ""
@@ -28,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()
@@ -98,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()
@@ -108,10 +92,10 @@ class AsyncInputHandler:
                     if msvcrt.kbhit():
                         char = msvcrt.getwch()
                         
-                        if char == '\xe0' or char == '\x00': # Special keys (Arrows, etc)
+                        if char == '\xe0' or char == '\x00':
                             try:
                                 scancode = msvcrt.getwch()
-                                if scancode == 'H': # Up Arrow
+                                if scancode == 'H':
                                     if self.history_index > 0:
                                         self.history_index -= 1
                                         self.input_buffer = self.history[self.history_index]
@@ -120,7 +104,7 @@ class AsyncInputHandler:
                                             sys.stdout.write(self.cursor + self.input_buffer)
                                             sys.stdout.flush()
                                     
-                                elif scancode == 'P': # Down Arrow
+                                elif scancode == 'P':
                                     if self.history_index < len(self.history):
                                         self.history_index += 1
                                         
@@ -136,7 +120,7 @@ class AsyncInputHandler:
                             except Exception:
                                 pass
 
-                        elif char == '\r': # Enter
+                        elif char == '\r':
                             with self.print_lock:
                                 sys.stdout.write('\n')
                                 sys.stdout.flush()
@@ -150,29 +134,24 @@ class AsyncInputHandler:
                             
                             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)
 
@@ -182,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-0.7.1 → cli_ih-0.7.1.1}/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,8 +11,8 @@ 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 = ""
@@ -29,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"
@@ -68,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
@@ -138,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()
@@ -147,29 +131,19 @@ class InputHandler:
                         if msvcrt.kbhit():
                             char = msvcrt.getwch()
                             
-                            if char == '\xe0' or char == '\x00': # Special keys (Arrows, etc)
+                            if char == '\xe0' or char == '\x00':
                                 try:
                                     scancode = msvcrt.getwch()
-                                    if scancode == 'H': # Up Arrow
+                                    if scancode == 'H':
                                         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
+                                    elif scancode == 'P':
                                         if self.history_index < len(self.history):
                                             self.history_index += 1
                                             
@@ -185,7 +159,7 @@ class InputHandler:
                                 except Exception:
                                     pass
 
-                            elif char == '\r': # Enter
+                            elif char == '\r':
                                 with self.print_lock:
                                     sys.stdout.write('\n')
                                     sys.stdout.flush()
@@ -193,9 +167,6 @@ 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)
@@ -210,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-0.7.1 → cli_ih-0.7.1.1}/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 → cli_ih-0.7.1.1}/cli_ih.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_ih
-Version: 0.7.1
+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

{cli_ih-0.7.1 → cli_ih-0.7.1.1}/pyproject.toml

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