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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_ih
-Version: 0.6.2
+Version: 0.6.3
 Summary: A background command handler for python's command-line interface.
 Author-email: Hotment <michatchuplay@gmail.com>
 Requires-Python: >=3.8
@@ -57,6 +57,27 @@ handler.start()
 # > 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)

{cli_ih-0.6.2 → cli_ih-0.6.3}/README.md

@@ -49,6 +49,27 @@ handler.start()
 # > 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)

{cli_ih-0.6.2 → cli_ih-0.6.3}/cli_ih/asyncClient.py

@@ -1,12 +1,12 @@
-from typing import Callable
+from typing import Coroutine, Callable, Any
 from .exceptions import HandlerClosed
-import logging, warnings, asyncio, inspect
+import logging, warnings, asyncio, inspect, threading
 
 class AsyncInputHandler:
     def __init__(self, cursor = "", *, logger: logging.Logger | None = None, register_defaults: bool = True):
         self.commands = {}
         self.is_running = False
-        self.cursor = f"{cursor.strip()} "
+        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
@@ -48,7 +48,7 @@ class AsyncInputHandler:
         else:
             print(f"[EXEPTION]: {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"
@@ -56,16 +56,16 @@ class AsyncInputHandler:
             raise SyntaxError("Command name must not have spaces")
         if name in self.commands:
             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, "is_async": inspect.iscoroutinefunction(func)}
+        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
@@ -74,40 +74,32 @@ class AsyncInputHandler:
     async def start(self):
         """Starts the input handler loop in a separate thread if thread mode is enabled."""
         self.is_running = True
-
-        while self.is_running:
-            try:
-                user_input = await asyncio.to_thread(input, self.cursor)
-                if not user_input:
-                    continue
-
-                cmdargs = user_input.split(' ')
-                command_name = cmdargs[0].lower()
-                args = cmdargs[1:]
-                if command_name in self.commands:
-                    await _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
-            except HandlerClosed:
-                self.__info("Input Handler exited.")
-                break
-        self.is_running = False
+        loop = asyncio.get_running_loop()
+        input_queue = asyncio.Queue()
+
+        def _input_worker():
+            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
+                except Exception:
+                    break
+
+        thread = threading.Thread(target=_input_worker, daemon=True)
+        thread.start()
 
         async def _run_command(commands: dict, name: str, args: list):
             """Executes a command from the command dictionary if it exists."""
             command = commands.get(name)
             if not command:
                 self.__warning(f"Command '{name}' not found.")
+                return
 
             func = command.get("cmd")
             is_legacy = command.get("legacy", False)
-            is_async = command.get("is_async", False)
 
             if not callable(func):
                 raise ValueError(f"The command '{name}' is not callable.")
@@ -125,27 +117,63 @@ class AsyncInputHandler:
             try:
                 if is_legacy:
                     warnings.warn("This way of running commands id Deprecated. And should be changed to the new decorator way.", DeprecationWarning, 2)
-                    await asyncio.to_thread(func, args)
-                elif is_async:
-                    await func(*args)
+                    if inspect.iscoroutinefunction(func):
+                        await func(args)
+                    else:
+                        await asyncio.to_thread(func, args)
                 else:
-                    await asyncio.to_thread(func, *args)
+                    if inspect.iscoroutinefunction(func):
+                        await func(*args)
+                    else:
+                        await asyncio.to_thread(func, *args)
 
             except HandlerClosed as e:
                 raise e
             except Exception as e:
                 self.__exeption(f"An error occurred in command '{name}'", e)
 
+        while self.is_running:
+            try:
+                try:
+                    user_input = await asyncio.wait_for(input_queue.get(), timeout=0.1)
+                except asyncio.TimeoutError:
+                    continue
+
+                if user_input is EOFError:
+                    self.__error("Input ended unexpectedly.")
+                    break
+                
+                if not user_input:
+                    continue
+
+                cmdargs = user_input.split(' ')
+                command_name = cmdargs[0].lower()
+                args = cmdargs[1:]
+                if command_name in self.commands:
+                    await _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
+            except HandlerClosed:
+                self.__info("Input Handler exited.")
+                break
+        self.is_running = False
+
     def register_default_commands(self):
         @self.command(name="help", description="Displays all the available commands")
-        def help():
+        async def help(*args):
             str_out = "Available commands:\n"
             for command, data in self.commands.items():
                 str_out += f"  {command}: {data['description']}\n"
             print(str_out)
 
         @self.command(name="debug", description="If a logger is present changes the logging level to DEBUG.")
-        def debug_mode():
+        async def debug_mode(*args):
             logger = self.global_logger
             if not logger:
                 return self.__warning("No logger defined for this InputHandler instance.")
@@ -165,5 +193,5 @@ class AsyncInputHandler:
             self.__info(message)
 
         @self.command(name="exit", description="Exits the Input Handler irreversibly.")
-        def exit_thread():
+        async def exit_thread(*args):
             raise HandlerClosed("Handler was closed with exit command.")

{cli_ih-0.6.2 → cli_ih-0.6.3}/cli_ih/client.py

@@ -7,7 +7,7 @@ class InputHandler:
         self.commands = {}
         self.is_running = False
         self.thread_mode = thread_mode
-        self.cursor = f"{cursor.strip()} "
+        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

{cli_ih-0.6.2 → cli_ih-0.6.3}/cli_ih.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli_ih
-Version: 0.6.2
+Version: 0.6.3
 Summary: A background command handler for python's command-line interface.
 Author-email: Hotment <michatchuplay@gmail.com>
 Requires-Python: >=3.8
@@ -57,6 +57,27 @@ handler.start()
 # > 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)

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

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