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

syndesi/remote/remote.py

@@ -0,0 +1,188 @@
+DEFAULT_REMOTE_PORT = 59677
+
+
+# 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
+
+# Delay to let the adapter connect
+DEFAULT_ADAPTER_OPEN_TIMEOUT = 0.5
+
+
+# def add_backend_address_port_arguments(
+#     parser: argparse.ArgumentParser, client_side: bool
+# ) -> None:
+#     """
+#     Add -a/--address and -p/--port to a given ArgumentParser. The description of -a/--address
+#     is different based on the value of client_side
+#     """
+#     if client_side:
+#         address_help = "Address of the backend"
+#     else:
+#         address_help = (
+#             "Backend listening address, set it to the host address used by clients"
+#         )
+
+#     parser.add_argument(
+#         "-a", "--address", type=str, default=LOCALHOST, help=address_help
+#     )
+#     parser.add_argument("-p", "--port", type=int, default=BACKEND_PORT)
+
+
+# class Action(Enum):
+#     """
+#     Backend actions 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,temp_timeout,temp_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 True if the action describes an error
+#     """
+#     return action.value.startswith("error_")
+
+
+# class BackendException(Exception):
+#     """
+#     Generic backend error
+#     """
+
+
+# def frontend_send(conn: Connection, action: Action, *args: Any) -> bool:
+#     """
+#     Send an action to the frontend
+#     """
+#     try:
+#         conn.send((action.value, *args))
+#     except (BrokenPipeError, OSError):
+#         return False
+#     return True
+
+
+# def backend_request(
+#     conn: Connection,
+#     action: Action,
+#     *args: Any,
+#     timeout: float = EXTRA_BUFFER_RESPONSE_TIME,
+# ) -> BackendResponse:
+#     """
+#     Send a request to the backend an expect a response with the time specified by timeout
+#     """
+#     try:
+#         conn.send((action.value, *args))
+#     except (BrokenPipeError, OSError) as err:
+#         raise BackendCommunicationError("Failed to communicate with backend") from err
+
+#     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:
+#     """
+#     Raise error if the action is an error, ignore otherwise
+#     """
+#     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}")
+
+
+# class AdapterBackendStatus(Enum):
+#     """
+#     Adapter backend status enum
+#     """
+
+#     DISCONNECTED = 0
+#     CONNECTED = 1
+
+
+# class ClientStatus(Enum):
+#     """
+#     Client status enum
+#     """
+
+#     DISCONNECTED = 0
+#     CONNECTED = 1

syndesi/scripts/syndesi.py

@@ -1,16 +1,23 @@
 # File : syndesi.py
 # Author : Sébastien Deriaz
 # License : GPL
+"""
+Main syndesi CLI script
+"""
 
 import argparse
 from enum import Enum
 
 from ..cli.shell import AdapterShell, AdapterType
-from ..tools.log import log
+from ..tools.logmanager import log
 from ..version import __version__
 
 
 class SyndesiCommands(Enum):
+    """
+    Syndesi script commands enum
+    """
+
     SERIAL = "serial"
     IP = "ip"
     MODBUS = "modbus"
@@ -18,6 +25,9 @@ class SyndesiCommands(Enum):
 
 
 def main() -> None:
+    """
+    Main syndesi entry point
+    """
     parser = argparse.ArgumentParser(
         prog="syndesi", description="Syndesi command line tool", epilog=""
     )
@@ -43,7 +53,7 @@ def main() -> None:
     elif command == SyndesiCommands.VISA:
         AdapterShell(AdapterType.VISA, remaining_args).run()
     else:
-        raise RuntimeError(f"Command '{command.value}' is not supported yet")
+        raise NotImplementedError(f"Command '{command.value}' is not supported yet")
 
 
 if __name__ == "__main__":

syndesi/tools/errors.py

@@ -1,9 +1,14 @@
 # File : errors.py
 # Author : Sébastien Deriaz
 # License : GPL
+"""
+Syndesi errors
+"""
 
 from pathlib import Path
 
+from syndesi.tools.types import NumberLike
+
 PACKAGE_PATH = Path(__file__).resolve().parent.parent
 
 
@@ -11,40 +16,53 @@ class SyndesiError(Exception):
     """Base class for all Syndesi errors"""
 
 
-class BackendCommunicationError(SyndesiError):
-    """Error with backend communication"""
+class AdapterError(SyndesiError):
+    """Adapter error"""
 
 
-class BackendError(SyndesiError):
-    """Error inside the backend"""
+class AdapterConfigurationError(AdapterError):
+    """Adapter configuration error"""
 
 
-class AdapterBackendError(BackendError):
-    """Error inside an adapter backend"""
+class AdapterOpenError(AdapterError):
+    """Adapter failed to open"""
 
 
-class AdapterError(SyndesiError):
-    """Error inside an adapter frontend"""
-
-
-def make_error_description(e: Exception) -> str:
-    tb = e.__traceback__
-    if tb is None:
-        error_message = ""
-    else:
-        while True:
-            if tb.tb_next is None:
-                break
-            file = Path(tb.tb_next.tb_frame.f_code.co_filename).resolve()
-            if not file.is_relative_to(PACKAGE_PATH):
-                break
-            tb = tb.tb_next
-
-        _type = type(e)
-        extra_arguments = (str(e),)
-        frame = tb.tb_frame
-        line_no = tb.tb_lineno
-        filename = frame.f_code.co_filename
-        error_message = f"{_type} : {extra_arguments} {filename}:{line_no}"
-
-    return error_message
+class AdapterWriteError(AdapterError):
+    """Adapter failed to write"""
+
+
+class AdapterDisconnected(AdapterError):
+    """Adapter disconnected"""
+
+
+class WorkerThreadError(AdapterError):
+    """Adapters worker thread error"""
+
+
+class AdapterReadError(AdapterError):
+    """Error while performing read operation"""
+
+
+class ProtocolError(SyndesiError):
+    """Protocol error"""
+
+
+class ProtocolWriteError(SyndesiError):
+    """Protocol error when writing"""
+
+
+class ProtocolReadError(SyndesiError):
+    """Protocol error when reading"""
+
+
+class AdapterTimeoutError(AdapterError):
+    """
+    Adapter timeout error
+    """
+
+    def __init__(self, timeout: NumberLike) -> None:
+        self.timeout = timeout
+        super().__init__(
+            f"No response received from target within {self.timeout} seconds"
+        )

syndesi/tools/log_settings.py

@@ -1,17 +1,30 @@
-# File : log.py
+# File : log_settings.py
 # Author : Sébastien Deriaz
 # License : GPL
-#
-# Log utilities
-# Set log level, destination, etc...
-
+"""
+Log utilities
+Set log level, destination, etc...
+"""
+import logging
 from enum import Enum
 
 
 class LoggerAlias(Enum):
+    """
+    Name of the Syndesi loggers inside the logging module
+    """
+
     ADAPTER = "syndesi.adapter"
     PROTOCOL = "syndesi.protocol"
     CLI = "syndesi.cli"
-    BACKEND = "syndesi.backend"
-    ADAPTER_BACKEND = "syndesi.adapter_backend"
-    BACKEND_LOGGER = "syndesi.backend_logger"
+    REMOTE = "syndesi.remote"
+    ADAPTER_WORKER = "syndesi.adapterworker"
+
+
+LOGGING_COLORS = {
+    logging.DEBUG: "grey66",
+    logging.INFO: "green",
+    logging.WARNING: "yellow",
+    logging.ERROR: "red",
+    logging.CRITICAL: "bold purple",
+}

syndesi/tools/{log.py → logmanager.py}

@@ -1,15 +1,22 @@
 # File : logmanager.py
 # Author : Sébastien Deriaz
 # License : GPL
-
+"""
+Log manager implementation
+"""
 import logging
 import threading
 from typing import TextIO
 
-from .backend_logger import BackendLogger
 from .log_settings import LoggerAlias
 
+
 class LogManager:
+    """
+    Log manager, responsible for logging configuration, backend logging and
+    printing to console and/or to a file
+    """
+
     _lock = threading.Lock()
 
     DEFAULT_FORMATTER = logging.Formatter(
@@ -23,13 +30,11 @@ class LogManager:
         self._loggers: list[str] = []
         self._level = self.DEFAULT_LOG_LEVEL
         self._stream_handler: logging.StreamHandler[TextIO] | None = None
-        self._backend_logger: BackendLogger | None = None
-
-    def enable_backend_logging(self) -> None:
-        self._backend_logger = BackendLogger()
-        self._backend_logger.start()
 
     def set_log_level(self, level: str | int) -> None:
+        """
+        Set log level
+        """
         if isinstance(level, str):
             if not hasattr(logging, level.upper()):
                 raise ValueError(f"Invalid log level: {level}")
@@ -43,6 +48,9 @@ class LogManager:
         self.update_loggers()
 
     def set_console_log(self, enabled: bool) -> None:
+        """
+        Enable or disable console logging
+        """
         if enabled:
             self._stream_handler = logging.StreamHandler()
             self._stream_handler.setFormatter(self.DEFAULT_FORMATTER)
@@ -50,6 +58,9 @@ class LogManager:
             self._stream_handler = None
 
     def set_log_file(self, file: str | None) -> None:
+        """
+        Define a file for loggers output
+        """
         if file is not None:
             self._file_handler = logging.FileHandler(file)
             self._file_handler.setFormatter(self.DEFAULT_FORMATTER)
@@ -59,6 +70,9 @@ class LogManager:
             self._file_handler = None
 
     def set_logger_filter(self, loggers: list[str] | str) -> None:
+        """
+        Select loggers
+        """
         self._all_loggers = False
         self._loggers = []
         if isinstance(loggers, list):
@@ -72,6 +86,9 @@ class LogManager:
             raise ValueError("Invalid argument loggers")
 
     def update_loggers(self) -> None:
+        """
+        Update configuration of each logger
+        """
         # 1) Remove everything
         for alias in LoggerAlias:
             logger = logging.getLogger(alias.value)
@@ -86,12 +103,6 @@ class LogManager:
                     logger.addHandler(self._stream_handler)
                 logger.setLevel(self._level)
 
-    def backend_logger_conn_description(self) -> str:
-        if self._backend_logger is None:
-            return ""
-        else:
-            return self._backend_logger.conn_description
-
 
 log_manager = LogManager()
 

syndesi/tools/types.py

@@ -1,6 +1,9 @@
 # File : types.py
 # Author : Sébastien Deriaz
 # License : GPL
+"""
+Type tools
+"""
 
 from typing import TYPE_CHECKING, Any, TypeGuard
 
@@ -16,7 +19,8 @@ if TYPE_CHECKING:
 else:
     NumberLike = int | float | np.number  # runtime will resolve string
 
-def is_number(X: Any) -> TypeGuard[NumberLike]:
+
+def is_number(x: Any) -> TypeGuard[NumberLike]:
     """
     Check if the given X is an instance of int or float
 
@@ -29,9 +33,8 @@ def is_number(X: Any) -> TypeGuard[NumberLike]:
     result : bool
     """
     if np is None:
-        return isinstance(X, int | float)
-    else:
-        return isinstance(X, int | float | np.number)
+        return isinstance(x, int | float)
+    return isinstance(x, int | float | np.number)
 
 
 def assert_number(*args: Any) -> None:
@@ -57,7 +60,6 @@ def to_bytes(data: str | bytes) -> bytes:
     """
     if isinstance(data, bytes):
         return data
-    elif isinstance(data, str):
+    if isinstance(data, str):
         return data.encode("utf-8")
-    else:
-        raise ValueError(f"Invalid data type : {type(data)}")
+    raise ValueError(f"Invalid data type : {type(data)}")

syndesi/version.py

@@ -1,3 +1,7 @@
-__version__ = "0.4.2"
+"""
+Syndesi version file
+"""
+
+__version__ = "0.5.0"
 NAME = "Syndesi"
 AUTHOR = "Sébastien Deriaz"

{syndesi-0.4.2.dist-info → syndesi-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syndesi
-Version: 0.4.2
+Version: 0.5.0
 Summary: Syndesi
 Author-email: Sébastien Deriaz <sebastien.deriaz1@gmail.com>
 License: GPL

syndesi-0.5.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+syndesi/__init__.py,sha256=Lapn-qSSzcSGPgGVX_TLBM-FJyBzr0JKd3EmgwaYBn8,624
+syndesi/__main__.py,sha256=S9G9k0SHGJJ9qMdF_txtYryiPdEPTI10bgQ-M-rVITs,75
+syndesi/component.py,sha256=zdky9tOtN-Z0qEcGWfJ1d-xRmbqQaOyXfvV7HgS-M2A,8402
+syndesi/version.py,sha256=NdA_xw1pibpr0hHkrQoBM6UBvPRxxSywMz2CF2kMq7I,98
+syndesi/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/adapters/adapter.py,sha256=w1zZhg9PPxRUnC2mjh7iWKv9bAYGi7yhmG2BZs3tV1g,15282
+syndesi/adapters/adapter_worker.py,sha256=vll3TWvZ1G4eTs4aJqQwxsFfD1LtIhXX2MRnMAYl4K0,28467
+syndesi/adapters/auto.py,sha256=_hXCGM6TCe_cgLyQ_6CUDo8_lqXNB7nTsxkn25kCC5U,2355
+syndesi/adapters/descriptors.py,sha256=GehtGriResi4IBE1fo2xPA8CK-q64p8acghORKY1I18,1021
+syndesi/adapters/ip.py,sha256=Kd_q0-sONL8vFRbEz3Zvj17IhffEJ6QfLBe1-86SIV4,7849
+syndesi/adapters/serialport.py,sha256=RHLqy11L2t-k6XvPRjRjh6KArcZqPIdukywiYwQTRNk,6105
+syndesi/adapters/stop_conditions.py,sha256=5d1F3YQxGj69oDD9iKKbt2uYOZlSchQdiuLSCy5uME8,10150
+syndesi/adapters/timeout.py,sha256=TZdPWBqAyW7Wes2tarbM1fiJL3Gw5xd5J2YRAtVITZw,3184
+syndesi/adapters/visa.py,sha256=xeKRu4P4c_hhcBF327Raq59SvrD11aiFNI_Q1aFrgBk,8455
+syndesi/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/cli/console.py,sha256=pwEOukoRDq-AnJSMfmd8jyKjm_2DT8CoWU2OENWSnMI,8864
+syndesi/cli/shell.py,sha256=0jNE7LT22RRru3BCHEobUSmLDNNeDhk-OGL5eUGkFNs,7969
+syndesi/cli/shell_tools.py,sha256=wqa0d5yELV1my_NhcLw00OXmYP8vKlrlkPqjLF2dCNs,3335
+syndesi/cli/terminal.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/cli/terminal_apps.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/cli/terminal_tools.py,sha256=HuhJebeF_SWywwMhw3G91poSphTDF_aaaiw_m8Z5HIM,301
+syndesi/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/protocols/delimited.py,sha256=6MJDV1Schll9bFk9OHvID6GVg4Fj2s_NzmmfMnR-qqk,5549
+syndesi/protocols/modbus.py,sha256=8VmjPVeEjgcwXHghdSw5n1MYxd3cVyXu_Wb_9eJR-9I,94938
+syndesi/protocols/protocol.py,sha256=Pv92qL__weswyu60ZTMcjy17Rp-ToHChFJHfPmPcOhw,6490
+syndesi/protocols/raw.py,sha256=_UrfDkXT3LpI2vQut8AhN6zorFD-fcnzctR8nYQEtT0,2022
+syndesi/protocols/scpi.py,sha256=hZRA4sDd--xfQHHNA-3M4yTGe6GJtirmOgW8YoHraCc,2985
+syndesi/remote/remote.py,sha256=7ykrmNjCGxTnwwIC2qzeXSne3C2fgpVRYXFB7AOXlt0,5759
+syndesi/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/scripts/syndesi.py,sha256=bEueSyCsWr_HVvPxfXffogVXLm-LetDmLQvESaZZS30,1512
+syndesi/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syndesi/tools/errors.py,sha256=_BZXlETGGkHS_IgPM7Z7-KJkIAQVtJ8MTdpGpWM6B-Q,1331
+syndesi/tools/log_settings.py,sha256=0iy6mQPnAnuGvwsoZPBhCdA5fCMfgSpMhMbJe1sT9bY,604
+syndesi/tools/logmanager.py,sha256=d-CUgPRK8kNED3vwUKF6wJdLSbeGAf3PJh9XBVqTdOs,4455
+syndesi/tools/types.py,sha256=jSLpR-ymLnhCT2BqRNU_g_qhOGWUn5mZ4FobAhFx05k,1393
+syndesi-0.5.0.dist-info/licenses/LICENSE,sha256=7oldAMqsditrYeX4dzMFHpFZ-6AkyGi3bha2zeaJB0A,34492
+syndesi-0.5.0.dist-info/METADATA,sha256=W4Q_6ClHfYhZvPQ0anw66yfYLqmeCfJ7ZoexqOujXD8,2827
+syndesi-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syndesi-0.5.0.dist-info/entry_points.txt,sha256=1JbZYMX6PrakEg-6b_M_f58QJ1mGFJKJd7puoPQPyKM,112
+syndesi-0.5.0.dist-info/top_level.txt,sha256=HrY36JU6hFYp_6qv-GuVBBtHYYemn8qhCrqpvXBd1Lg,8
+syndesi-0.5.0.dist-info/RECORD,,