on the road to 0.0.5

README.md

@@ -14,4 +14,76 @@ license: apache-2.0
 
 Description: Visualize logs in your Gradio app
 
-Install with: pip install gradio_logsview
+## Installation
+
+```
+pip install https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
+```
+
+or add this line to your `requirements.txt`:
+
+```
+gradio_logsview@https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
+```
+
+## How to run Python code?
+
+With `LogsView.run_python`, you can run Python code in a separate process and capture logs in real-time.
+You can configure which logs to capture (log level and logger name).
+
+```py
+from gradio_logsview import LogsView
+
+def fn_python():
+    # Run `my_function` in a separate process
+    # All logs above `INFO` level will be captured and displayed in real-time.
+    runner = LogsViewRunner() # Initialize the runner
+    yield from runner.run_python(my_function, log_level=logging.INFO, arg1="value1")
+    yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
+
+with gr.Blocks() as demo:
+    logs = LogsView()
+    btn = gr.Button("Run Python code")
+    btn.click(fn_python, outputs=logs)
+```
+
+## How to run a command?
+
+With `LogsView.run_command`, you can run a command on the system and capture logs from the process in real-time.
+    
+```py
+from gradio_logsview import LogsView
+
+def fn_command():
+    # Run a command and capture all logs from the subprocess
+    runner = LogsViewRunner() # Initialize the runner
+    yield from runner.run_command(
+        cmd=["mergekit-yaml", "config.yaml", "merge", "--copy-", "--cuda", "--low-cpu-memory"]
+    )
+    yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
+
+with gr.Blocks() as demo:
+    logs = LogsView()
+    btn = gr.Button("Run command")
+    btn.click(fn_command, outputs=logs)
+```
+
+## TODO
+
+- [ ] display logs with colors (front-end)
+- [ ] format logs client-side (front-end)
+- [ ] scrollable logs if more than N lines (front-end)
+- [ ] format each log only once (front-end)
+- [x] stop process if `run_command` gets cancelled (back-end)
+- [x] correctly pass error stacktrace in `run_python` (back-end)
+- [x] correctly catch print statements in `run_python` (back-end)
+- [ ] disable interactivity + remove all code editing logic (both?)
+- [x] how to handle progress bars? (i.e when logs are overwritten in terminal)
+- [ ] Have 3 tabs in UI for stdout, stderr and logging (front-end + back-end)
+- [ ] Write logger name in the logs (back-end)

app.py

@@ -3,13 +3,15 @@ import random
 import time
 
 import gradio as gr
+from tqdm import tqdm
 
-from gradio_logsview import LogsView
+from gradio_logsview import LogsView, LogsViewRunner
 
+logger = logging.getLogger("custom.foo")
 
 def random_values(failing: bool = False):
-    for i in range(10):
-        logging.log(
+    for i in tqdm(range(10)):
+        logger.log(
             random.choice(
                 [  # Random levels
                     logging.INFO,
@@ -26,90 +28,134 @@ def random_values(failing: bool = False):
             raise ValueError("Failing!!")
 
 
-def fn_process_success():
-    yield from LogsView.run_process(["python", "-u", "demo/script.py"])
+def fn_command_success():
+    runner = LogsViewRunner()
+    yield from runner.run_command(["python", "-u", "demo/script.py"])
+    yield runner.log(f"Runner: {runner}")
 
 
-def fn_process_failing():
-    yield from LogsView.run_process(["python", "-u", "demo/script.py", "--failing"])
+def fn_command_failing():
+    runner = LogsViewRunner()
+    yield from runner.run_command(["python", "-u", "demo/script.py", "--failing"])
+    yield runner.log(f"Runner: {runner}")
 
 
-def fn_thread_success():
-    yield from LogsView.run_thread(random_values, log_level=logging.INFO, failing=False)
+def fn_python_success():
+    runner = LogsViewRunner()
+    yield from runner.run_python(random_values, log_level=logging.INFO, logger_name="custom.foo", failing=False)
+    yield runner.log(f"Runner: {runner}")
 
 
-def fn_thread_failing():
-    yield from LogsView.run_thread(random_values, log_level=logging.INFO, failing=True)
+def fn_python_failing():
+    runner = LogsViewRunner()
+    yield from runner.run_python(random_values, log_level=logging.INFO, logger_name="custom.foo", failing=True)
+    yield runner.log(f"Runner: {runner}")
 
 
 markdown_top = """
 # LogsView Demo
 
-This demo shows how to use the `LogsView` component to display logs from a process or a thread in real-time.
+This demo shows how to use the `LogsView` component to run some Python code or execute a command and display logs in real-time.
 
-Click on any button to launch a process or a thread and see the logs displayed in real-time.
-In the thread example, logs are generated randomly with different log levels.
-In the process example, logs are generated by a Python script but any command can be executed.
+Click on any button to launch a process and see the logs displayed in real-time.
+In the Python examples, code is executed in a process. You can see the logs (generated randomly with different log levels).
+In the command examples, the command line is executed on the system directly. Any command can be executed.
 """
 
 
 markdown_bottom = """
-## How to run in a thread?
+## Installation
+
+```
+pip install https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
+```
+
+or add this line to your `requirements.txt`:
 
-With `LogsView.run_thread`, you can run a function in a separate thread and capture logs in real-time.
+```
+gradio_logsview@https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
+```
+
+## How to run Python code?
+
+With `LogsView.run_python`, you can run Python code in a separate process and capture logs in real-time.
 You can configure which logs to capture (log level and logger name).
 
 ```py
 from gradio_logsview import LogsView
 
-def fn_thread():
-    # Run `my_function` in a separate thread
+def fn_python():
+    # Run `my_function` in a separate process
     # All logs above `INFO` level will be captured and displayed in real-time.
-    yield from LogsView.run_thread(my_function, log_level=logging.INFO, arg1="value1")
+    runner = LogsViewRunner() # Initialize the runner
+    yield from runner.run_python(my_function, log_level=logging.INFO, arg1="value1")
+    yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
 
 with gr.Blocks() as demo:
     logs = LogsView()
-    btn = gr.Button("Run thread")
-    btn.click(fn_thread, outputs=logs)
+    btn = gr.Button("Run Python code")
+    btn.click(fn_python, outputs=logs)
 ```
 
-## How to run in a process?
+## How to run a command?
 
-With `LogsView.run_process`, you can run a command in a separate process and capture logs from the process in real-time.
+With `LogsView.run_command`, you can run a command on the system and capture logs from the process in real-time.
     
 ```py
 from gradio_logsview import LogsView
 
-def fn_process():
-    # Run a process and capture all logs from the process
-    yield from LogsView.run_process(
+def fn_command():
+    # Run a command and capture all logs from the subprocess
+    runner = LogsViewRunner() # Initialize the runner
+    yield from runner.run_command(
         cmd=["mergekit-yaml", "config.yaml", "merge", "--copy-", "--cuda", "--low-cpu-memory"]
     )
+    yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
 
 with gr.Blocks() as demo:
     logs = LogsView()
-    btn = gr.Button("Run process")
-    btn.click(fn_process, outputs=logs)
+    btn = gr.Button("Run command")
+    btn.click(fn_command, outputs=logs)
 ```
+
+## TODO
+
+- [ ] display logs with colors (front-end)
+- [ ] format logs client-side (front-end)
+- [ ] scrollable logs if more than N lines (front-end)
+- [ ] format each log only once (front-end)
+- [x] stop process if `run_command` gets cancelled (back-end)
+- [x] correctly pass error stacktrace in `run_python` (back-end)
+- [x] correctly catch print statements in `run_python` (back-end)
+- [ ] disable interactivity + remove all code editing logic (both?)
+- [x] how to handle progress bars? (i.e when logs are overwritten in terminal)
+- [ ] Have 3 tabs in UI for stdout, stderr and logging (front-end + back-end)
+- [ ] Write logger name in the logs (back-end)
 """
 
 with gr.Blocks() as demo:
     gr.Markdown(markdown_top)
 
     with gr.Row():
-        btn_thread_success = gr.Button("Run thread (success)")
-        btn_thread_failing = gr.Button("Run thread (failing)")
+        btn_python_success = gr.Button("Run Python code (success)")
+        btn_python_failing = gr.Button("Run Python code (failing)")
     with gr.Row():
-        btn_process_success = gr.Button("Run process (success)")
-        btn_process_failing = gr.Button("Run process (failing)")
+        btn_command_success = gr.Button("Run command (success)")
+        btn_command_failing = gr.Button("Run command (failing)")
     logs = LogsView()
 
     gr.Markdown(markdown_bottom)
 
-    btn_thread_failing.click(fn_thread_failing, outputs=logs)
-    btn_thread_success.click(fn_thread_success, outputs=logs)
-    btn_process_failing.click(fn_process_failing, outputs=logs)
-    btn_process_success.click(fn_process_success, outputs=logs)
+    btn_python_failing.click(fn_python_failing, outputs=logs)
+    btn_python_success.click(fn_python_success, outputs=logs)
+    btn_command_failing.click(fn_command_failing, outputs=logs)
+    btn_command_success.click(fn_command_success, outputs=logs)
 
 
 if __name__ == "__main__":

requirements.txt

@@ -1 +1 @@
-gradio_logsview-0.0.4-py3-none-any.whl
+gradio_logsview-0.0.5-py3-none-any.whl

space.py

@@ -3,13 +3,15 @@ import random
 import time
 
 import gradio as gr
+from tqdm import tqdm
 
 from gradio_logsview import LogsView, LogsViewRunner
 
+logger = logging.getLogger("custom.foo")
 
 def random_values(failing: bool = False):
-    for i in range(10):
-        logging.log(
+    for i in tqdm(range(10)):
+        logger.log(
             random.choice(
                 [  # Random levels
                     logging.INFO,
@@ -26,38 +28,38 @@ def random_values(failing: bool = False):
             raise ValueError("Failing!!")
 
 
-def fn_process_success():
+def fn_command_success():
     runner = LogsViewRunner()
-    yield from runner.run_process(["python", "-u", "demo/script.py"])
+    yield from runner.run_command(["python", "-u", "script.py"])
     yield runner.log(f"Runner: {runner}")
 
 
-def fn_process_failing():
+def fn_command_failing():
     runner = LogsViewRunner()
-    yield from runner.run_process(["python", "-u", "demo/script.py", "--failing"])
+    yield from runner.run_command(["python", "-u", "script.py", "--failing"])
     yield runner.log(f"Runner: {runner}")
 
 
-def fn_thread_success():
+def fn_python_success():
     runner = LogsViewRunner()
-    yield from runner.run_thread(random_values, log_level=logging.INFO, failing=False)
+    yield from runner.run_python(random_values, log_level=logging.INFO, logger_name="custom.foo", failing=False)
     yield runner.log(f"Runner: {runner}")
 
 
-def fn_thread_failing():
+def fn_python_failing():
     runner = LogsViewRunner()
-    yield from runner.run_thread(random_values, log_level=logging.INFO, failing=True)
+    yield from runner.run_python(random_values, log_level=logging.INFO, logger_name="custom.foo", failing=True)
     yield runner.log(f"Runner: {runner}")
 
 
 markdown_top = """
 # LogsView Demo
 
-This demo shows how to use the `LogsView` component to display logs from a process or a thread in real-time.
+This demo shows how to use the `LogsView` component to run some Python code or execute a command and display logs in real-time.
 
-Click on any button to launch a process or a thread and see the logs displayed in real-time.
-In the thread example, logs are generated randomly with different log levels.
-In the process example, logs are generated by a Python script but any command can be executed.
+Click on any button to launch a process and see the logs displayed in real-time.
+In the Python examples, code is executed in a process. You can see the logs (generated randomly with different log levels).
+In the command examples, the command line is executed on the system directly. Any command can be executed.
 """
 
 
@@ -65,55 +67,61 @@ markdown_bottom = """
 ## Installation
 
 ```
-pip install https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.3-py3-none-any.whl
+pip install https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
 ```
 
 or add this line to your `requirements.txt`:
 
 ```
-gradio_logsview@https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.3-py3-none-any.whl
+gradio_logsview@https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
 ```
 
-## How to run in a thread?
+## How to run Python code?
 
-With `LogsView.run_thread`, you can run a function in a separate thread and capture logs in real-time.
+With `LogsView.run_python`, you can run Python code in a separate process and capture logs in real-time.
 You can configure which logs to capture (log level and logger name).
 
 ```py
 from gradio_logsview import LogsView
 
-def fn_thread():
-    # Run `my_function` in a separate thread
+def fn_python():
+    # Run `my_function` in a separate process
     # All logs above `INFO` level will be captured and displayed in real-time.
     runner = LogsViewRunner() # Initialize the runner
-    yield from runner.run_thread(my_function, log_level=logging.INFO, arg1="value1")
+    yield from runner.run_python(my_function, log_level=logging.INFO, arg1="value1")
     yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
 
 with gr.Blocks() as demo:
     logs = LogsView()
-    btn = gr.Button("Run thread")
-    btn.click(fn_thread, outputs=logs)
+    btn = gr.Button("Run Python code")
+    btn.click(fn_python, outputs=logs)
 ```
 
-## How to run in a process?
+## How to run a command?
 
-With `LogsView.run_process`, you can run a command in a separate process and capture logs from the process in real-time.
+With `LogsView.run_command`, you can run a command on the system and capture logs from the process in real-time.
     
 ```py
 from gradio_logsview import LogsView
 
-def fn_process():
-    # Run a process and capture all logs from the process
+def fn_command():
+    # Run a command and capture all logs from the subprocess
     runner = LogsViewRunner() # Initialize the runner
-    yield from runner.run_process(
+    yield from runner.run_command(
         cmd=["mergekit-yaml", "config.yaml", "merge", "--copy-", "--cuda", "--low-cpu-memory"]
     )
     yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
 
 with gr.Blocks() as demo:
     logs = LogsView()
-    btn = gr.Button("Run process")
-    btn.click(fn_process, outputs=logs)
+    btn = gr.Button("Run command")
+    btn.click(fn_command, outputs=logs)
 ```
 
 ## TODO
@@ -122,30 +130,32 @@ with gr.Blocks() as demo:
 - [ ] format logs client-side (front-end)
 - [ ] scrollable logs if more than N lines (front-end)
 - [ ] format each log only once (front-end)
-- [x] stop process if `run_process` gets cancelled (back-end)
-- [x] correctly pass error stacktrace in `run_thread` (back-end)
-- [ ] correctly catch print statements in `run_thread` (back-end)
+- [x] stop process if `run_command` gets cancelled (back-end)
+- [x] correctly pass error stacktrace in `run_python` (back-end)
+- [x] correctly catch print statements in `run_python` (back-end)
 - [ ] disable interactivity + remove all code editing logic (both?)
-- [ ] how to handle progress bars? (i.e when logs are overwritten in terminal)
+- [x] how to handle progress bars? (i.e when logs are overwritten in terminal)
+- [ ] Have 3 tabs in UI for stdout, stderr and logging (front-end + back-end)
+- [ ] Write logger name in the logs (back-end)
 """
 
 with gr.Blocks() as demo:
     gr.Markdown(markdown_top)
 
     with gr.Row():
-        btn_thread_success = gr.Button("Run thread (success)")
-        btn_thread_failing = gr.Button("Run thread (failing)")
+        btn_python_success = gr.Button("Run Python code (success)")
+        btn_python_failing = gr.Button("Run Python code (failing)")
     with gr.Row():
-        btn_process_success = gr.Button("Run process (success)")
-        btn_process_failing = gr.Button("Run process (failing)")
+        btn_command_success = gr.Button("Run command (success)")
+        btn_command_failing = gr.Button("Run command (failing)")
     logs = LogsView()
 
     gr.Markdown(markdown_bottom)
 
-    btn_thread_failing.click(fn_thread_failing, outputs=logs)
-    btn_thread_success.click(fn_thread_success, outputs=logs)
-    btn_process_failing.click(fn_process_failing, outputs=logs)
-    btn_process_success.click(fn_process_success, outputs=logs)
+    btn_python_failing.click(fn_python_failing, outputs=logs)
+    btn_python_success.click(fn_python_success, outputs=logs)
+    btn_command_failing.click(fn_command_failing, outputs=logs)
+    btn_command_success.click(fn_command_success, outputs=logs)
 
 
 if __name__ == "__main__":

src/backend/gradio_logsview/logsview.py

@@ -7,13 +7,13 @@ import queue
 import subprocess
 import time
 import traceback
-from contextlib import contextmanager, redirect_stdout
+from contextlib import contextmanager, redirect_stderr, redirect_stdout
 from dataclasses import dataclass
 from datetime import datetime
 from functools import wraps
 from logging.handlers import QueueHandler
-from queue import Queue
-from threading import Thread
+from multiprocessing import Process
+from multiprocessing import Queue as mpQueue
 from typing import Any, Callable, Generator, List, Literal, NoReturn
 
 from gradio.components.base import Component
@@ -30,15 +30,33 @@ class Log:
 
 
 class LogsViewRunner:
+    """
+    Runner to execute a command or a function and capture logs in real-time.
+
+    Parameters:
+        date_format: Date format to use for logs timestamps. Default is "%Y-%m-%d %H:%M:%S".
+
+    Attributes:
+        date_format: Date format to use for logs timestamps.
+        logs: List of `Log` logs.
+        exit_code: Exit code of the process or function. None if not run yet.
+        process: Process or subprocess.Popen object. None if not run yet.
+
+    Usage:
+    ```python
+    runner = LogsViewRunner()
+    for logs in runner.run_command(["echo", "Hello World"]):
+        for log in logs:
+            print(log.timestamp, log.level, log.message)
+    """
+
     def __init__(self, date_format: str = "%Y-%m-%d %H:%M:%S"):
         self.date_format = date_format
         self.logs: List[Log] = []
 
         # Runner state
-        self.completed = False
-        self.error = False
-        self.process: subprocess.Popen | None = None
-        self.thread: Thread | None = None
+        self.exit_code: int | None = None
+        self.process: Process | subprocess.Popen | None = None
 
     def log(
         self,
@@ -55,7 +73,25 @@ class LogsViewRunner:
         self.logs.append(Log(level=level, message=message, timestamp=timestamp))
         return self.logs
 
-    def run_process(
+    def log_from_record(self, record: logging.LogRecord) -> List[Log]:
+        return self.log(
+            message=record.getMessage(),
+            level=record.levelname,
+            timestamp=record.created,
+        )
+
+    def _log_from_queue(self, mp_queue: mpQueue) -> Generator[List[Log], None, None]:
+        while True:
+            try:
+                line = mp_queue.get_nowait()
+                if isinstance(line, logging.LogRecord):
+                    yield self.log_from_record(line)
+                else:
+                    yield self.log(line)
+            except queue.Empty:
+                break
+
+    def run_command(
         self, command: List[str], **kwargs
     ) -> Generator[List[Log], None, None]:
         """Run a command in a subprocess and yield logs in real-time."""
@@ -75,116 +111,61 @@ class LogsViewRunner:
             yield self.log(line.strip())
 
         self.process.stdout.close()
-        return_code = self.process.wait()
-        if return_code:
-            yield self.log(f"Process exited with code {return_code}", level="ERROR")
-            self.completed = True
-            self.error = True
+        self.exit_code = self.process.wait()
+        if self.exit_code:
+            yield self.log(f"Command exited with code {self.exit_code}", level="ERROR")
         else:
-            yield self.log("Process exited successfully", level="INFO")
-            self.completed = True
-            self.error = False
+            yield self.log("Command exited successfully", level="INFO")
 
-    def run_thread(
+    def run_python(
         self,
         fn: Callable,
         log_level: int = logging.INFO,
         logger_name: str | None = None,
         **kwargs,
     ) -> Generator[List[Log], None, None]:
-        """Run a function in a thread and capture logs in real-time to yield them."""
+        """Run Python code in a process and capture logs in real-time to yield them."""
         yield self.log(
             f"Running {fn.__name__}({', '.join(f'{k}={v}' for k, v in kwargs.items())})"
         )
-
-        error_queue, wrapped_fn = non_failing_fn(fn)
-        self.thread = Thread(target=wrapped_fn, kwargs=kwargs)
-
-        def _log(record: logging.LogRecord) -> bool:
-            """Handle log record and return True if log should be yielded."""
-            # if record.thread != self.thread.ident:
-            #     return False  # Skip if not from the thread
-            if logger_name and not record.name.startswith(logger_name):
-                return False  # Skip if not from the logger
-            if record.levelno < log_level:
-                return False  # Skip if too verbose
-            self.log(
-                message=record.getMessage(),
-                level=record.levelname,
-                timestamp=record.created,
-            )
-            return True
-
-        stdout_queue = queue.Queue()
-        stream = LineQueueStream(stdout_queue)
-        with capture_logging(log_level) as log_queue:
-            with redirect_stdout(stream):
-                # Start thread and loop to capture and yield logs from the thread
-                self.thread.start()
-                while self.thread.is_alive():
-                    while True:
-                        try:
-                            if _log(log_queue.get_nowait()):
-                                yield self.logs
-                        except queue.Empty:
-                            break
-                    while True:
-                        try:
-                            line = stdout_queue.get_nowait()
-                            yield self.log(line)
-                        except queue.Empty:
-                            break
-                    self.thread.join(timeout=0.1)  # adjust the timeout as needed
-
-        # After the thread completes, yield any remaining logs
-        while True:
-            try:
-                if _log(log_queue.get_nowait()):
-                    yield self.logs
-            except queue.Empty:
-                break
-        while True:
-            try:
-                line = stdout_queue.get_nowait()
-                yield self.log(line)
-            except queue.Empty:
-                break
-
+        logs_queue, stdout_queue, stderr_queue, error_queue, wrapped_fn = wrap_for_process(fn, log_level=log_level, logger_name=logger_name)
+        self.process = Process(target=wrapped_fn, kwargs=kwargs)
+
+        # Start process and pull logs while it runs
+        self.process.start()
+        while self.process.is_alive():
+            yield from self._log_from_queue(logs_queue)
+            yield from self._log_from_queue(stdout_queue)
+            yield from self._log_from_queue(stderr_queue)
+            self.process.join(timeout=0.1)
+
+        # After the process completes, yield any remaining logs
+        yield from self._log_from_queue(logs_queue)
+        yield from self._log_from_queue(stdout_queue)
+        yield from self._log_from_queue(stderr_queue)
+
+        # Check for error
         try:
-            error = error_queue.get_nowait()
+            error_msg = error_queue.get_nowait()
+            self.exit_code = 1
+            yield self.log(error_msg, level="ERROR")            
         except queue.Empty:
-            error = None
-        if error is not None:
-            msg = (
-                f"Error in '{fn.__name__}':"
-                + "\n"
-                + "\n".join(
-                    line.strip("\n")
-                    for line in traceback.format_tb(error.__traceback__)
-                    if line.strip()
-                )
-                + "\n\n"
-                + str(error)
-            )
-            yield self.log(msg, level="ERROR")
-            self.completed = True
-            self.error = True
-        else:
-            yield self.log("Thread completed successfully")
-            self.completed = True
-            self.error = False
+            yield self.log("Process completed successfully")
+            self.exit_code = 0
 
     def __repr__(self) -> str:
-        return f"<LogsViewRunner nb_logs={len(self.logs)} completed={self.completed} error={self.error}>"
+        return f"<LogsViewRunner nb_logs={len(self.logs)} exit_code={self.exit_code}>"
 
     def __del__(self):
-        if self.process and self.process.poll() is None:
-            print(f"Killing process: {self.process}")
-            self.process.kill()
-        if self.thread and self.thread.is_alive():
-            print(f"Joining thread: {self.thread}")
-            self.thread.join()
-
+        if (isinstance(self.process, Process) and self.process.is_alive()) or (isinstance(self.process, subprocess.Popen) and self.process.poll() is None):
+            try:
+                print(f"Terminating process {self.process}")
+                self.process.terminate()
+            except Exception as e:
+                print(f"Failed to terminate process: {e}")
+            finally:
+                print(f"Killing process: {self.process}")
+                self.process.kill()
 
 class LogsView(Component):
     """
@@ -278,40 +259,57 @@ class LogsView(Component):
 
 
 @contextmanager
-def capture_logging(log_level: int) -> Generator[Queue, None, None]:
+def capture_logging(log_queue: mpQueue, log_level: int, logger_name: str | None = None) -> Generator:
     # Create a queue to capture log messages
-    log_queue = queue.Queue()
-    logger = logging.getLogger()
+    logger = logging.getLogger(logger_name)
     logger.setLevel(log_level)
     handler = QueueHandler(log_queue)
     logger.addHandler(handler)
 
-    # Yield the queue
-    yield log_queue
+    yield
 
     # Clean up
     logger.removeHandler(handler)
 
 
-def non_failing_fn(fn: Callable, *args, **kwargs) -> Callable:
-    error_queue = queue.Queue()
+def wrap_for_process(fn: Callable, log_level: int, logger_name: str | None) -> Callable:
+    logs_queue = mpQueue()
+    stdout_queue = mpQueue()
+    stderr_queue = mpQueue()
+    error_queue = mpQueue()
 
     @wraps(fn)
     def _inner(*args, **kwargs):
-        try:
-            fn(*args, **kwargs)
-        except Exception as e:
-            error_queue.put(e)
-
-    return error_queue, _inner
-
-class LineQueueStream(io.StringIO):
-    def __init__(self, queue: queue.Queue, *args, **kwargs):
+        with capture_logging(logs_queue, log_level, logger_name):
+            with redirect_stdout(CapturingStream(stdout_queue)):
+                with redirect_stderr(CapturingStream(stderr_queue)):
+                        try:
+                            fn(*args, **kwargs)
+                        except Exception as error:
+                            msg = (
+                                f"Error in '{fn.__name__}':"
+                                + "\n"
+                                + "\n".join(
+                                    line.strip("\n")
+                                    for line in traceback.format_tb(error.__traceback__)
+                                    if line.strip()
+                                )
+                                + "\n\n"
+                                + str(error)
+                            )
+                            error_queue.put(msg)
+
+    return logs_queue, stdout_queue, stderr_queue, error_queue, _inner
+
+class CapturingStream(io.StringIO):
+    """Stream to capture stdout/stderr line by line and put them in a queue."""
+    def __init__(self, queue: mpQueue, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._queue = queue
         self._current_line = ""
 
     def write(self, s: str) -> int:
+        s = s.replace("\r", "\n") # Remove carriage return (from tqdm)
         if "\n" in s:
             lines = s.split("\n")
             for line in lines[:-1]:

src/demo/app.py

@@ -4,11 +4,13 @@ import time
 
 import gradio as gr
 from gradio_logsview import LogsView, LogsViewRunner
+from tqdm import tqdm
 
+logger = logging.getLogger("custom.foo")
 
 def random_values(failing: bool = False):
-    for i in range(10):
-        logging.log(
+    for i in tqdm(range(10)):
+        logger.log(
             random.choice(
                 [  # Random levels
                     logging.INFO,
@@ -25,38 +27,38 @@ def random_values(failing: bool = False):
             raise ValueError("Failing!!")
 
 
-def fn_process_success():
+def fn_command_success():
     runner = LogsViewRunner()
-    yield from runner.run_process(["python", "-u", "demo/script.py"])
+    yield from runner.run_command(["python", "-u", "demo/script.py"])
     yield runner.log(f"Runner: {runner}")
 
 
-def fn_process_failing():
+def fn_command_failing():
     runner = LogsViewRunner()
-    yield from runner.run_process(["python", "-u", "demo/script.py", "--failing"])
+    yield from runner.run_command(["python", "-u", "demo/script.py", "--failing"])
     yield runner.log(f"Runner: {runner}")
 
 
-def fn_thread_success():
+def fn_python_success():
     runner = LogsViewRunner()
-    yield from runner.run_thread(random_values, log_level=logging.INFO, failing=False)
+    yield from runner.run_python(random_values, log_level=logging.INFO, logger_name="custom.foo", failing=False)
     yield runner.log(f"Runner: {runner}")
 
 
-def fn_thread_failing():
+def fn_python_failing():
     runner = LogsViewRunner()
-    yield from runner.run_thread(random_values, log_level=logging.INFO, failing=True)
+    yield from runner.run_python(random_values, log_level=logging.INFO, logger_name="custom.foo", failing=True)
     yield runner.log(f"Runner: {runner}")
 
 
 markdown_top = """
 # LogsView Demo
 
-This demo shows how to use the `LogsView` component to display logs from a process or a thread in real-time.
+This demo shows how to use the `LogsView` component to run some Python code or execute a command and display logs in real-time.
 
-Click on any button to launch a process or a thread and see the logs displayed in real-time.
-In the thread example, logs are generated randomly with different log levels.
-In the process example, logs are generated by a Python script but any command can be executed.
+Click on any button to launch a process and see the logs displayed in real-time.
+In the Python examples, code is executed in a process. You can see the logs (generated randomly with different log levels).
+In the command examples, the command line is executed on the system directly. Any command can be executed.
 """
 
 
@@ -64,55 +66,61 @@ markdown_bottom = """
 ## Installation
 
 ```
-pip install https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.3-py3-none-any.whl
+pip install https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
 ```
 
 or add this line to your `requirements.txt`:
 
 ```
-gradio_logsview@https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.3-py3-none-any.whl
+gradio_logsview@https://huggingface.co/spaces/Wauplin/gradio_logsview/resolve/main/gradio_logsview-0.0.5-py3-none-any.whl
 ```
 
-## How to run in a thread?
+## How to run Python code?
 
-With `LogsView.run_thread`, you can run a function in a separate thread and capture logs in real-time.
+With `LogsView.run_python`, you can run Python code in a separate process and capture logs in real-time.
 You can configure which logs to capture (log level and logger name).
 
 ```py
 from gradio_logsview import LogsView
 
-def fn_thread():
-    # Run `my_function` in a separate thread
+def fn_python():
+    # Run `my_function` in a separate process
     # All logs above `INFO` level will be captured and displayed in real-time.
     runner = LogsViewRunner() # Initialize the runner
-    yield from runner.run_thread(my_function, log_level=logging.INFO, arg1="value1")
+    yield from runner.run_python(my_function, log_level=logging.INFO, arg1="value1")
     yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
 
 with gr.Blocks() as demo:
     logs = LogsView()
-    btn = gr.Button("Run thread")
-    btn.click(fn_thread, outputs=logs)
+    btn = gr.Button("Run Python code")
+    btn.click(fn_python, outputs=logs)
 ```
 
-## How to run in a process?
+## How to run a command?
 
-With `LogsView.run_process`, you can run a command in a separate process and capture logs from the process in real-time.
+With `LogsView.run_command`, you can run a command on the system and capture logs from the process in real-time.
     
 ```py
 from gradio_logsview import LogsView
 
-def fn_process():
-    # Run a process and capture all logs from the process
+def fn_command():
+    # Run a command and capture all logs from the subprocess
     runner = LogsViewRunner() # Initialize the runner
-    yield from runner.run_process(
+    yield from runner.run_command(
         cmd=["mergekit-yaml", "config.yaml", "merge", "--copy-", "--cuda", "--low-cpu-memory"]
     )
     yield runner.log(f"Runner: {runner}") # Log any message
+    if runner.exit_code != 0:
+        # Handle error
+        ...
 
 with gr.Blocks() as demo:
     logs = LogsView()
-    btn = gr.Button("Run process")
-    btn.click(fn_process, outputs=logs)
+    btn = gr.Button("Run command")
+    btn.click(fn_command, outputs=logs)
 ```
 
 ## TODO
@@ -121,30 +129,32 @@ with gr.Blocks() as demo:
 - [ ] format logs client-side (front-end)
 - [ ] scrollable logs if more than N lines (front-end)
 - [ ] format each log only once (front-end)
-- [x] stop process if `run_process` gets cancelled (back-end)
-- [x] correctly pass error stacktrace in `run_thread` (back-end)
-- [ ] correctly catch print statements in `run_thread` (back-end)
+- [x] stop process if `run_command` gets cancelled (back-end)
+- [x] correctly pass error stacktrace in `run_python` (back-end)
+- [x] correctly catch print statements in `run_python` (back-end)
 - [ ] disable interactivity + remove all code editing logic (both?)
-- [ ] how to handle progress bars? (i.e when logs are overwritten in terminal)
+- [x] how to handle progress bars? (i.e when logs are overwritten in terminal)
+- [ ] Have 3 tabs in UI for stdout, stderr and logging (front-end + back-end)
+- [ ] Write logger name in the logs (back-end)
 """
 
 with gr.Blocks() as demo:
     gr.Markdown(markdown_top)
 
     with gr.Row():
-        btn_thread_success = gr.Button("Run thread (success)")
-        btn_thread_failing = gr.Button("Run thread (failing)")
+        btn_python_success = gr.Button("Run Python code (success)")
+        btn_python_failing = gr.Button("Run Python code (failing)")
     with gr.Row():
-        btn_process_success = gr.Button("Run process (success)")
-        btn_process_failing = gr.Button("Run process (failing)")
+        btn_command_success = gr.Button("Run command (success)")
+        btn_command_failing = gr.Button("Run command (failing)")
     logs = LogsView()
 
     gr.Markdown(markdown_bottom)
 
-    btn_thread_failing.click(fn_thread_failing, outputs=logs)
-    btn_thread_success.click(fn_thread_success, outputs=logs)
-    btn_process_failing.click(fn_process_failing, outputs=logs)
-    btn_process_success.click(fn_process_success, outputs=logs)
+    btn_python_failing.click(fn_python_failing, outputs=logs)
+    btn_python_success.click(fn_python_success, outputs=logs)
+    btn_command_failing.click(fn_command_failing, outputs=logs)
+    btn_command_success.click(fn_command_success, outputs=logs)
 
 
 if __name__ == "__main__":