syndesi 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

syndesi/cli/backend_console.py

@@ -1,96 +0,0 @@
-# backend_status.py
-# 13.07.2025
-# Sébastien Deriaz
-
-import argparse
-import logging
-import time
-from collections.abc import Callable
-from multiprocessing.connection import Connection
-from time import sleep
-from typing import Any
-
-from rich.console import Console
-from rich.text import Text
-
-from ..tools.backend_api import BACKEND_PORT, LOCALHOST
-from ..tools.backend_logger import BackendLogger
-from ..tools.log_settings import LoggerAlias
-
-LOGGING_COLORS = {
-    logging.DEBUG: "grey66",
-    logging.INFO: "green",
-    logging.WARNING: "yellow",
-    logging.ERROR: "red",
-    logging.CRITICAL: "bold purple",
-}
-
-logging.getLogger().setLevel(logging.CRITICAL + 1)
-
-
-class LogHandler(logging.Handler):
-    def __init__(
-        self, callback: Callable[[logging.LogRecord], None] | None = None
-    ) -> None:
-        super().__init__()
-        self.callback = callback
-
-    def emit(self, record: logging.LogRecord) -> None:
-        if self.callback is not None:
-            self.callback(record)
-
-
-class BackendConsole:
-    def __init__(self, input_args: list[str]) -> None:
-        self.argument_parser = argparse.ArgumentParser()
-        self.argument_parser.add_argument(
-            "-a",
-            "--address",
-            type=str,
-            default=LOCALHOST,
-            help="Listening address, set it to the interface that will be used by the client",
-        )
-        self.argument_parser.add_argument(
-            "-p", "--port", type=int, default=BACKEND_PORT
-        )
-        self.argument_parser.add_argument(
-            "-l", "--log-level", type=str, choices=list(logging._nameToLevel.keys())
-        )  # pyright: ignore[reportPrivateUsage]
-
-        args = self.argument_parser.parse_args(input_args)
-
-        self.address = args.address
-        self.port = args.port
-
-        self._console = Console()
-
-        self._log_handler = LogHandler()
-        self._log_handler.callback = self._add_line
-
-        logging.getLogger().addHandler(self._log_handler)
-        self._start_time = time.time()
-        self.conn: Connection[Any, Any] | None = None
-        self._backend_logger = BackendLogger()
-
-    def run(self) -> None:
-        self._backend_logger.start()
-        try:
-            while True:
-                sleep(1)
-        except KeyboardInterrupt:
-            pass
-
-    def _format_record(self, record: logging.LogRecord) -> str:
-        color = LOGGING_COLORS.get(record.levelno)
-        relative_time = record.created - self._start_time
-
-        line = f"[{color}]{relative_time:7.3f} {record.levelname:<8} {record.msg}[/]"
-        if record.name == LoggerAlias.BACKEND.value:
-            line = f"[bold]{line}[/bold]"
-        elif record.name == LoggerAlias.BACKEND_LOGGER.value:
-            line = f"[italic]{line}[/italic]"
-        return line
-
-    def _add_line(self, record: logging.LogRecord) -> None:
-        formated_text = self._format_record(record)
-        self._console.print(Text.from_markup(formated_text), markup=True)

syndesi/cli/backend_status.py

@@ -1,274 +0,0 @@
-# backend_status.py
-# 13.07.2025
-# Sébastien Deriaz
-
-import argparse
-import logging
-import threading
-import time
-from collections.abc import Callable
-from multiprocessing.connection import Client, Pipe, wait
-from time import sleep
-from typing import cast
-
-from rich.console import Group
-from rich.live import Live
-from rich.panel import Panel
-from rich.table import Table
-from rich.text import Text
-
-from syndesi.adapters.backend.backend_tools import NamedConnection
-from syndesi.tools.log_settings import LoggerAlias
-
-from ..tools.backend_api import (
-    BACKEND_PORT,
-    LOCALHOST,
-    Action,
-    backend_request,
-)
-from ..tools.log import log_manager
-
-LOGGING_COLORS = {
-    logging.DEBUG: "grey66",
-    logging.INFO: "green",
-    logging.WARNING: "yellow",
-    logging.ERROR: "red",
-    logging.CRITICAL: "bold purple",
-}
-
-logging.getLogger().setLevel(logging.CRITICAL + 1)
-
-
-class LogHandler(logging.Handler):
-    def __init__(
-        self, callback: Callable[[logging.LogRecord], None] | None = None
-    ) -> None:
-        super().__init__()
-        self.callback = callback
-
-    def emit(self, record: logging.LogRecord) -> None:
-        if self.callback is not None:
-            self.callback(record)
-
-
-class BackendStatus:
-    DEFAULT_REFRESH_RATE = 0.5
-    DEFAULT_N_CONSOLE_LINES = 20  # Number of lines in the console view
-    CONNECTIONS_MIN_HEIGHT = 2
-
-    def __init__(self, input_args: list[str]) -> None:
-        self.argument_parser = argparse.ArgumentParser()
-        self.argument_parser.add_argument(
-            "-l",
-            "--live",
-            type=float,
-            default=False,
-            help="Live mode, update status continuously at set refresh rate",
-        )
-        self.argument_parser.add_argument(
-            "--log-lines",
-            type=int,
-            default=self.DEFAULT_N_CONSOLE_LINES,
-            help="Number of log lines to display",
-        )
-        self.argument_parser.add_argument(
-            "-a",
-            "--address",
-            type=str,
-            default=LOCALHOST,
-            help="Listening address, set it to the interface that will be used by the client",
-        )
-        self.argument_parser.add_argument(
-            "-p", "--port", type=int, default=BACKEND_PORT
-        )
-        self.argument_parser.add_argument(
-            "--log-level", type=str, choices=list(logging._nameToLevel.keys())
-        )  # pyright: ignore[reportPrivateUsage]
-
-        args = self.argument_parser.parse_args(input_args)
-
-        self._n_console_lines = args.log_lines
-        self.host: str = args.address
-        self.port: int = args.port
-        self.live_delay: float | None = args.live
-
-        # Buffer for last N_CONSOLE_LINES log messages
-        self.console_lines: list[str] = []
-        self.console_lock = threading.Lock()  # Lock for thread safety
-        log_manager.enable_backend_logging()
-        self._start_time = time.time()
-        self.conn: NamedConnection | None = None
-
-        self._log_handler = LogHandler()
-
-        self._new_console_line_r, self._new_console_line_w = Pipe()
-
-    def run(self) -> None:
-        self._log_handler.callback = self._add_line_status_screen
-        logging.getLogger().addHandler(self._log_handler)
-        adapter_table = None
-        main_table = Table(box=None, padding=(0, 1))
-        main_table.add_column(justify="right")
-        main_table.add_column(justify="left")
-        try:
-            with Live(refresh_per_second=30) as live_display:
-                while True:
-                    if self.conn is None:
-                        pid = ""
-                        backend_status = "[red3]● Offline"
-                        monitoring_connections = Table(
-                            "",
-                            box=None,
-                            caption_justify="right",
-                            show_header=False,
-                            pad_edge=False,
-                        )
-                        adapter_table = Table("", box=None, caption_justify="right")
-
-                    if self.conn is None:
-                        try:
-                            self.conn = NamedConnection(Client((self.host, self.port)))
-                        except (ConnectionRefusedError, OSError):
-                            self.conn = None
-                            sleep(0.1)
-                        else:
-                            backend_request(self.conn.conn, Action.SET_ROLE_MONITORING)
-
-                    if self.conn is not None:
-                        backend_status = "[green3]● Online"
-
-                        ready = wait([self.conn.conn, self._new_console_line_r])
-
-                        if self._new_console_line_r in ready:
-                            self._new_console_line_r.recv()
-                        elif self.conn.conn in ready:
-                            try:
-                                event = self.conn.conn.recv()
-                            except (ConnectionResetError, OSError, EOFError):
-                                self.conn = None
-                                continue
-                            else:
-                                action: Action = Action(event[0])
-                                if action == Action.ENUMERATE_ADAPTER_CONNECTIONS:
-                                    adapter_table = Table(
-                                        "", box=None, caption_justify="right"
-                                    )
-                                    snapshot: dict[str, tuple[bool, list[str]]] = event[
-                                        1
-                                    ]
-                                    unique_clients: set[str] = set()
-                                    for _, (_, adapter_clients) in snapshot.items():
-                                        unique_clients |= set(adapter_clients)
-                                    for client in unique_clients:
-                                        adapter_table.add_column(
-                                            f"{client}", justify="center"
-                                        )
-
-                                    for adapter, (
-                                        status,
-                                        adapter_clients,
-                                    ) in snapshot.items():
-                                        status_indicator = (
-                                            "[green3]●" if status else "[red3]●"
-                                        )
-                                        client_indicators: list[str] = []
-                                        for client in unique_clients:
-                                            client_indicators.append(
-                                                "[green3]●[/]"
-                                                if client in adapter_clients
-                                                else "[red3]●[/]"
-                                            )
-                                        adapter_table.add_row(
-                                            f"{adapter} {status_indicator}",
-                                            *client_indicators,
-                                        )
-                                elif action == Action.ENUMERATE_MONITORING_CONNECTIONS:
-                                    monitoring_connections = Table(
-                                        "",
-                                        box=None,
-                                        caption_justify="right",
-                                        show_header=False,
-                                        pad_edge=False,
-                                    )
-                                    # Update monitoring connections
-                                    monitoring_response: list[tuple[str, str]] = event[
-                                        1
-                                    ]
-
-                                    for connection, desc in monitoring_response:
-                                        if (
-                                            connection
-                                            == log_manager.backend_logger_conn_description()
-                                            or connection == self.conn.local()
-                                        ):
-                                            style = ("grey50", "grey23")
-                                        else:
-                                            style = ("grey", "grey50")
-
-                                        monitoring_connections.add_row(
-                                            f"[{style[0]}]{connection}[/] [{style[1]}]({desc})[/]"
-                                        )
-                                    for _ in range(
-                                        self.CONNECTIONS_MIN_HEIGHT
-                                        - len(monitoring_response)
-                                    ):
-                                        monitoring_connections.add_row("")
-
-                                elif action == Action.BACKEND_STATS:
-                                    # Update Backend stats
-                                    pid_response: int = cast(int, event[1])
-                                    pid = str(pid_response)
-
-                    main_table = Table(box=None, padding=(0, 1))
-                    main_table.add_column(justify="right")
-                    main_table.add_column(justify="left")
-                    main_table.add_row("Status :", backend_status)
-                    main_table.add_row("PID :", pid)
-                    main_table.add_row("Logger connections :", monitoring_connections)
-                    main_table.add_row(
-                        "Adapter connections :",
-                        (adapter_table if adapter_table is not None else Text("")),
-                    )
-
-                    # Build the console panel
-                    with self.console_lock:
-                        console_content = "\n".join(self.console_lines) or " "
-                    console_panel = Panel(
-                        console_content,
-                        title="Console",
-                        height=self._n_console_lines + 2,  # +2 for panel borders
-                        border_style="dim",
-                        padding=(0, 1),
-                    )
-
-                    # Group the main table and console panel vertically
-                    group = Group(main_table, console_panel)
-                    live_display.update(group)
-
-                    if self.live_delay is not None:
-                        sleep(self.live_delay)
-                    else:
-                        break
-        except KeyboardInterrupt:
-            pass
-
-    def _format_record(self, record: logging.LogRecord) -> str:
-        color = LOGGING_COLORS.get(record.levelno)
-        relative_time = record.created - self._start_time
-
-        line = f"[{color}]{relative_time:7.3f} {record.levelname:<8} {record.msg}[/]"
-        if record.name == LoggerAlias.BACKEND.value:
-            line = f"[bold]{line}[/bold]"
-        return line
-
-    def _add_line_status_screen(self, record: logging.LogRecord) -> None:
-        """
-        Add a log message to the console buffer, with color formatting by log level.
-        Thread-safe.
-        """
-        formated_text = self._format_record(record)
-        with self.console_lock:
-            self.console_lines.append(formated_text)
-            if len(self.console_lines) > self._n_console_lines:
-                self.console_lines = self.console_lines[-self._n_console_lines :]
-        self._new_console_line_w.send(b"\x00")

syndesi/cli/backend_wrapper.py

@@ -1,61 +0,0 @@
-import argparse
-from contextlib import nullcontext
-
-from rich.console import Console
-
-from syndesi.adapters.backend.backend import Backend
-from syndesi.tools.backend_api import BACKEND_PORT, LOCALHOST
-
-
-class BackendWrapper:
-    def __init__(self, remaining_args: list[str]) -> None:
-        argument_parser = argparse.ArgumentParser()
-
-        argument_parser.add_argument(
-            "-a",
-            "--address",
-            type=str,
-            default=LOCALHOST,
-            help="Listening address, set it to the interface that will be used by the client",
-        )
-        argument_parser.add_argument("-p", "--port", type=int, default=BACKEND_PORT)
-        argument_parser.add_argument(
-            "-s",
-            "--shutdown-delay",
-            type=int,
-            default=None,
-            help="Delay before the backend shutdowns automatically",
-        )
-        argument_parser.add_argument(
-            "-q", "--quiet", default=False, action="store_true"
-        )
-        argument_parser.add_argument(
-            "-v", "--verbose", default=False, action="store_true"
-        )
-
-        args = argument_parser.parse_args(remaining_args)
-
-        self.address = args.address
-        self.port = args.port
-        self.shutdown_delay = args.shutdown_delay
-        self.quiet = args.quiet
-        self.verbose = args.verbose
-
-    def run(self) -> None:
-        console = Console()
-        with (
-            console.status(
-                f"[bold green]Syndesi backend running on {self.address}", spinner="dots"
-            )
-            if not self.quiet
-            else nullcontext()
-        ):
-            backend = Backend(
-                host=self.address,
-                port=self.port,
-                backend_shutdown_delay=self.shutdown_delay,
-            )
-            try:
-                backend.start()
-            except KeyboardInterrupt:
-                pass

syndesi/scripts/syndesi_backend.py

@@ -1,37 +0,0 @@
-# File : syndesi_backend.py
-# Author : Sébastien Deriaz
-# License : GPL
-
-import argparse
-
-from ..cli.backend_console import BackendConsole
-from ..cli.backend_status import BackendStatus
-from ..cli.backend_wrapper import BackendWrapper
-
-
-def main() -> None:
-    argument_parser = argparse.ArgumentParser(prog="syndesi-backend")
-
-    argument_parser.add_argument(
-        "--status", action="store_true", help="Show backend status"
-    )
-
-    argument_parser.add_argument(
-        "--console", action="store_true", help="Run backend console"
-    )
-
-    args, remaining_args = argument_parser.parse_known_args()
-
-    if args.status:
-        status = BackendStatus(remaining_args)
-        status.run()
-    elif args.console:
-        console = BackendConsole(remaining_args)
-        console.run()
-    else:
-        backend = BackendWrapper(remaining_args)
-        backend.run()
-
-
-if __name__ == "__main__":
-    main()

syndesi/tools/backend_api.py

@@ -1,175 +0,0 @@
-# File : backend_api.py
-# Author : Sébastien Deriaz
-# License : GPL
-
-from dataclasses import dataclass
-from enum import Enum
-from multiprocessing.connection import Connection, wait
-from typing import Any, Protocol
-
-from syndesi.tools.errors import BackendCommunicationError, BackendError
-
-BACKEND_PORT = 59677
-LOCALHOST = "127.0.0.1"
-
-default_host = LOCALHOST
-# AUTHKEY = b'syndesi'
-
-# Backend protocol format
-# (action, arguments)
-# If the command succeeds, it is returned as :
-# (action, other arguments)
-# If the command fails, it is returned as :
-# (error, error_description)
-
-# The backend links the client with an adapter when SELECT_ADAPTER is sent along with an adapter descriptor
-
-EXTRA_BUFFER_RESPONSE_TIME = 1
-
-
-class Action(Enum):
-    # All adapters
-    SELECT_ADAPTER = "select"
-    OPEN = "open"  # (descriptor,stop_condition) -> ()
-    CLOSE = "close"  # (descriptor,force) -> ()
-    # FORCE_CLOSE = "force_close"  # (descriptor,) -> ()
-    WRITE = "write"  # (descriptor,data) -> ()
-    READ = "read"  # (descriptor,full_output,temporary_timeout,temporary_stop_condition) -> (data,metrics)
-    SET_STOP_CONDITIONs = "set_stop_condition"  # (descriptor,stop_condition)
-    FLUSHREAD = "flushread"
-    START_READ = "start_read"  # Start a read (descriptor,response_time)
-    RESPONSE_TIMEOUT = "response_timeout"
-
-    # Signal
-    ADAPTER_SIGNAL = "adapter_signal"
-
-    # Other
-    SET_ROLE_ADAPTER = (
-        "set_role_adapter"  # Define the client as an adapter (exchange of data)
-    )
-    SET_ROLE_MONITORING = "set_role_monitoring"  # The client queries for backend info
-    SET_ROLE_LOGGER = "set_role_logger"  # The client receives logs
-    SET_LOG_LEVEL = "set_log_level"
-    PING = "ping"
-    STOP = "stop"
-
-    # Backend debugger
-    ENUMERATE_ADAPTER_CONNECTIONS = "enumerate_adapter_connections"
-    ENUMERATE_MONITORING_CONNECTIONS = "enumerate_monitoring_connections"
-    BACKEND_STATS = "backend_stats"
-
-    # Errors
-    ERROR_GENERIC = "error_generic"
-    ERROR_UNKNOWN_ACTION = "error_unknown_action"
-    ERROR_INVALID_REQUEST = "error_invalid_request"
-    ERROR_ADAPTER_NOT_OPENED = "error_adapter_not_opened"
-    ERROR_INVALID_ROLE = "error_invalid_role"
-    ERROR_ADAPTER_DISCONNECTED = "error_adapter_disconnected"
-    ERROR_BACKEND_DISCONNECTED = "error_backend_disconnected"
-    ERROR_FAILED_TO_OPEN = "error_failed_to_open"
-
-
-def is_action_error(action: Action) -> bool:
-    return action.value.startswith("error_")
-
-class BackendException(Exception):
-    pass
-
-class ValidFragment(Protocol):
-    data: bytes
-
-@dataclass
-class Fragment:
-    data: bytes
-    timestamp: float | None
-
-    def __str__(self) -> str:
-        return f"{self.data!r}"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    def __getitem__(self, key: slice) -> "Fragment":
-        # if self.data is None:
-        #     raise IndexError('Cannot index invalid fragment')
-        return Fragment(self.data[key], self.timestamp)
-
-BackendResponse = tuple[object, ...]
-
-
-def frontend_send(conn: Connection, action: Action, *args: Any) -> bool:
-    try:
-        conn.send((action.value, *args))
-    except (BrokenPipeError, OSError):
-        return False
-    else:
-        return True
-
-
-def backend_request(
-    conn: Connection,
-    action: Action,
-    *args: Any,
-    timeout: float = EXTRA_BUFFER_RESPONSE_TIME,
-) -> BackendResponse:
-    try:
-        conn.send((action.value, *args))
-    except (BrokenPipeError, OSError) as err:
-        raise BackendCommunicationError("Failed to communicate with backend") from err
-    else:
-        ready = wait([conn], timeout=timeout)
-        if conn not in ready:
-            raise BackendCommunicationError(
-                "Failed to receive backend response in time"
-            )
-
-        try:
-            raw_response: object = conn.recv()
-        except (EOFError, ConnectionResetError) as err:
-            raise BackendCommunicationError(
-                f"Failed to receive backend response to {action.value}"
-            ) from err
-
-        # Check if the response is correctly formatted
-        if not (isinstance(raw_response, tuple) and isinstance(raw_response[0], str)):
-            raise BackendCommunicationError(
-                f"Invalid response received from backend : {raw_response}"
-            )
-
-        response_action: Action = Action(raw_response[0])
-        arguments: tuple[Any, ...] = raw_response[1:]
-
-        if is_action_error(response_action):
-            if len(arguments) > 0:
-                if isinstance(arguments[0], str):
-                    error_message: str = arguments[0]
-                else:
-                    error_message = "failed to read error message"
-            else:
-                error_message = "Missing error message"
-            raise BackendError(f"{response_action} : {error_message}")
-        return arguments
-
-
-backend_send = frontend_send
-
-
-def raise_if_error(response: BackendResponse) -> None:
-    action = Action(response[0])
-    if is_action_error(action):
-        if len(response) > 1:
-            description = response[1]
-        else:
-            description = f"{action}"
-        raise BackendException(f"{action.name}/{description}")
-    return
-
-
-class AdapterBackendStatus(Enum):
-    DISCONNECTED = 0
-    CONNECTED = 1
-
-
-class ClientStatus(Enum):
-    DISCONNECTED = 0
-    CONNECTED = 1