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

syndesi/adapters/timeout.py

@@ -8,12 +8,9 @@ from typing import Any, Protocol
 
 from ..tools.types import NumberLike, is_number
 
-# from .backend.timeout import TimeoutAction, JsonKey
-
-
 class TimeoutAction(Enum):
     ERROR = "error"
-    RETURN = "return"
+    RETURN_EMPTY = "return_empty"
 
 
 class IsInitialized(Protocol):
@@ -78,10 +75,9 @@ class Timeout:
             return None
         else:
             return self._response
-        
-    def is_initialized(self) -> bool:
-        return not self._response is Ellipsis
 
+    def is_initialized(self) -> bool:
+        return self._response is not Ellipsis
 
 
 def any_to_timeout(value: Any) -> Timeout:
@@ -93,26 +89,3 @@ def any_to_timeout(value: Any) -> Timeout:
         return value
     else:
         raise ValueError(f"Could not convert {value} to Timeout")
-
-
-# class TimeoutException(Exception):
-#     def __init__(self, value: NumberLike, limit: NumberLike) -> None:
-#         super().__init__()
-#         self._value = value
-#         self._limit = limit
-
-#     def __str__(self) -> str:
-#         try:
-#             value_string = f"{self._value * 1e3:.3f}ms"
-#         except (ValueError, TypeError):
-#             value_string = "not received"
-
-#         try:
-#             limit_string = f"{self._limit * 1e3:.3f}ms"
-#         except (ValueError, TypeError):
-#             limit_string = "not received"
-
-#         return f"{value_string} / {limit_string}"
-
-#     def __repr__(self) -> str:
-#         return self.__str__()

syndesi/adapters/visa.py

@@ -20,7 +20,7 @@ class Visa(Adapter):
         self,
         descriptor: str,
         alias: str = "",
-        stop_condition: StopCondition | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
         timeout: None | float | Timeout | EllipsisType = ...,
         encoding: str = "utf-8",
         event_callback: Callable[[AdapterSignal], None] | None = None,
@@ -30,7 +30,7 @@ class Visa(Adapter):
         super().__init__(
             VisaDescriptor.from_string(descriptor),
             alias=alias,
-            stop_conditions=stop_condition,
+            stop_conditions=stop_conditions,
             timeout=timeout,
             encoding=encoding,
             event_callback=event_callback,

syndesi/cli/backend_status.py

@@ -95,8 +95,6 @@ class BackendStatus:
         # Buffer for last N_CONSOLE_LINES log messages
         self.console_lines: list[str] = []
         self.console_lock = threading.Lock()  # Lock for thread safety
-        # self._backend_logger = BackendLogger()  # use_queue=True)
-        # self._backend_logger.start()
         log_manager.enable_backend_logging()
         self._start_time = time.time()
         self.conn: NamedConnection | None = None
@@ -155,7 +153,9 @@ class BackendStatus:
                                     adapter_table = Table(
                                         "", box=None, caption_justify="right"
                                     )
-                                    snapshot: dict[str, tuple[bool, list[str]]] = event[1]
+                                    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)
@@ -191,7 +191,9 @@ class BackendStatus:
                                         pad_edge=False,
                                     )
                                     # Update monitoring connections
-                                    monitoring_response: list[tuple[str, str]] = event[1]
+                                    monitoring_response: list[tuple[str, str]] = event[
+                                        1
+                                    ]
 
                                     for connection, desc in monitoring_response:
                                         if (
@@ -206,10 +208,6 @@ class BackendStatus:
                                         monitoring_connections.add_row(
                                             f"[{style[0]}]{connection}[/] [{style[1]}]({desc})[/]"
                                         )
-                                        # if connection == status_conn:
-                                        #     logger_connections.add_row(f"[grey50]{connection}[/]")
-                                        # else:
-                                        #     logger_connections.add_row(c_string)
                                     for _ in range(
                                         self.CONNECTIONS_MIN_HEIGHT
                                         - len(monitoring_response)
@@ -273,4 +271,4 @@ class BackendStatus:
             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')
+        self._new_console_line_w.send(b"\x00")

syndesi/cli/console.py

@@ -222,60 +222,7 @@ class Shell:
             FormattedText([(f"class:{style.value}", text)]), style=self._toolkit_styles
         )
 
-    # def ask(self, question: str):
-    #     loop = self.session.app.loop
-    #     fut = asyncio.run_coroutine_threadsafe(self._ask_on_app_loop(question), loop)
-    #     return fut.result()
-
-    # async def _ask_on_app_loop(self, question: str):
-    #     def _blocking_prompt():
-    #         temp_session = prompt_toolkit.PromptSession()
-    #         return temp_session.prompt(question)
-    #         # Or just: return input(question) if styling isn't needed
-
-    #     return await prompt_toolkit.application.run_in_terminal(_blocking_prompt)
-
-    # def ask(self, question: str):
-    #     loop = self.session.app.loop
-    #     fut = asyncio.run_coroutine_threadsafe(self._ask_dialog(question), loop)
-    #     return fut.result()
-
-    # async def _ask_dialog(self, question: str):
-    #     dlg = yes_no_dialog(title="Adapter Disconnected", text=question)
-    #     return await dlg.run_async()
-
     def ask(self, question: str, callback: Callable[[str], None]) -> None:
         self.ask_event.set()
         self.ask_callback = callback
-        self.reprompt(question)
-
-    #     loop = self.session.app.loop
-    #     fut = asyncio.run_coroutine_threadsafe(self._ask_inline(question), loop)
-    #     return fut.result()
-
-    # async def _ask_inline(self, question: str) -> bool:
-    #     from prompt_toolkit.patch_stdout import patch_stdout
-    #     from prompt_toolkit.shortcuts import prompt
-
-    #     # patch_stdout ensures print() doesn't mess up your REPL display
-    #     with patch_stdout():
-    #         ans = await prompt(f"{question} (y/n) ").strip().lower()
-    #     return ans.startswith("y")
-
-    # def ask(self, question: str):
-    #     fut = asyncio.run_coroutine_threadsafe(
-    #         self._ask_on_app_loop(question), self.session.app.loop
-    #     )
-    #     answer = fut.result()  # blocks THIS thread until user answers
-    #     return answer
-
-    # # on your shell object (runs on the app loop):
-    # async def _ask_on_app_loop(self, question):
-    #     def _blocking_prompt():
-    #         # Use your existing shell ask/prompt; it runs while the UI is suspended.
-    #         # If you have a PromptSession: return self.shell.session.prompt(...)
-    #         return self.session.prompt(question)
-
-    #     self.session.app.run
-    #     # Suspends rendering & CPR handling safely, runs in a thread pool.
-    #     return await prompt_toolkit.application.run_in_terminal(_blocking_prompt)
+        self.reprompt(question)

syndesi/cli/shell.py

@@ -173,7 +173,7 @@ class AdapterShell:
                 backend_port=args.backend_port,
             )
 
-        self.adapter.set_default_timeout(Timeout(action="return"))
+        self.adapter.set_default_timeout(Timeout(action="return_empty"))
 
         # Add the protocol
         _format = Format(args.format)
@@ -205,13 +205,6 @@ class AdapterShell:
     def run(self) -> None:
         # try:
         self.adapter.open()
-        # except Exception:  # TODO : Change this to a suitable exception
-        #     self.shell.print(
-        #         f"Failed to open adapter {self.adapter.descriptor}",
-        #         style=Shell.Style.ERROR,
-        #     )
-        #     self.adapter.close()  # TODO : Maybe force here ?
-        # else:
         self.shell.print(
             f"Opened adapter {self.adapter.descriptor}", style=Shell.Style.NOTE
         )
@@ -227,12 +220,6 @@ class AdapterShell:
                 if answer.lower() == "y":
                     # try:
                     self._protocol.open()
-                    # except Exception:  # TODO : Change this
-                    #     self.shell.print(
-                    #         "Failed to open adapter", style=Shell.Style.WARNING
-                    #     )
-                    # else:
-                    #     self.shell.print("Adapter opened", style=Shell.Style.NOTE)
                 else:
                     # Set the stop flag, exit will be effective on reprompt
                     self.shell.stop()

syndesi/cli/shell_tools.py

@@ -2,11 +2,6 @@
 # Author : Sébastien Deriaz
 # License : GPL
 
-import inspect
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
-from typing import Any
-
 
 # @dataclass
 # class CommandSpec:

syndesi/protocols/delimited.py

@@ -107,13 +107,7 @@ class Delimited(Protocol):
         command = self._format_command(command)
         self._adapter.write(self._to_bytes(command))
 
-    def query(
-        self,
-        data: str,
-        timeout: Timeout | None | EllipsisType = ...,
-        decode: bool = True,
-        full_output: bool = False,
-    ) -> str | tuple[str, AdapterSignal]:
+    def query(self, data: str, timeout: Timeout | None | EllipsisType = ...) -> str:
         """
         Writes then reads from the device and return the result
 
@@ -130,13 +124,13 @@ class Delimited(Protocol):
         """
         self._adapter.flushRead()
         self.write(data)
-        return self.read(timeout=timeout, decode=decode, full_output=full_output)
+        return self.read(timeout=timeout)
 
     def read_raw(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[bytes, AdapterReadPayload | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
         """
         Reads command and formats it as a str
 
@@ -151,30 +145,28 @@ class Delimited(Protocol):
         """
 
         # Send up to the termination
-        raw_data, signal = self._adapter.read_detailed(
-            timeout=timeout, stop_condition=stop_condition
+        signal = self._adapter.read_detailed(
+            timeout=timeout, stop_conditions=stop_conditions
         )
-
-        return raw_data, signal
+        return signal.data()
 
     def read_detailed(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[str, AdapterReadPayload | None]:
-        raw_data, signal = self.read_raw(timeout=timeout, stop_condition=stop_condition)
-
-        data_out = self._decode(raw_data)
-        return data_out, signal
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
+        signal = self._adapter.read_detailed(
+            timeout=timeout, stop_conditions=stop_conditions
+        )
+        return signal
 
     def read(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-        decode: bool = True,
-        full_output: bool = False,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> str:
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return self._decode(signal.data())
 
     def _decode(self, data: bytes) -> str:
         try:
@@ -188,16 +180,4 @@ class Delimited(Protocol):
                 # Add the termination back in since it was removed by the adapter
                 data_string += self._receive_termination
 
-        return data_string
-
-    # @overload
-    # def _append_missing_termination(self, data : str) -> str: ...
-    # @overload
-    # def _append_missing_termination(self, data : bytes) -> bytes: ...
-    # def _append_missing_termination(self, data : Union[str, bytes]) -> Union[str, bytes]:
-    #     if isinstance(data, str):
-    #         return data + self._receive_termination
-    #     elif isinstance(data, bytes): # type bytes
-    #         return data + self._receive_termination.encode(self._encoding)
-    #     else:
-    #         raise ValueError(f"Couldn't append termination do {data}")
+        return data_string

syndesi/protocols/modbus.py

@@ -14,7 +14,7 @@ from unittest.mock import DEFAULT
 from ..adapters.adapter import Adapter
 from ..adapters.ip import IP
 from ..adapters.serialport import SerialPort
-from ..adapters.stop_condition import Length
+from ..adapters.stop_condition import Continuation, Length
 from ..adapters.timeout import Timeout
 from .protocol import Protocol
 
@@ -328,10 +328,12 @@ class Modbus(Protocol):
     def _error_code(self, response: bytes) -> int:
         return response[1]
 
-    def _parse_pdu(self, _pdu: bytes) -> bytes:
+    def _parse_pdu(self, _pdu: bytes | None) -> bytes:
         """
         Return data from PDU
         """
+        if _pdu is None:
+            raise RuntimeError("Failed to read modbus data")
         if self._modbus_type == ModbusType.TCP:
             # Return raw data
             # data = _pdu
@@ -391,12 +393,13 @@ class Modbus(Protocol):
         )
 
         n_coil_bytes = ceil(number_of_coils / 8)
-        pdu: bytes = self._adapter.query(
+        pdu: bytes | None = self._adapter.query(
             self._make_pdu(query),
             # timeout=Timeout(continuation=1),
-            stop_condition=Length(
-                self._length(n_coil_bytes + 2)
-            ),  # TODO : convert to multiple stop conditions here
+            stop_conditions=[
+                Length(self._length(n_coil_bytes + 2)),
+                Continuation(time=1),
+            ],  # TODO : convert to multiple stop conditions here
         )
         response = self._parse_pdu(pdu)
         self._raise_if_error(response, exception_codes=EXCEPTIONS)
@@ -465,7 +468,7 @@ class Modbus(Protocol):
         response = self._parse_pdu(
             self._adapter.query(
                 self._make_pdu(query),
-                stop_condition=Length(self._length(byte_count + 2)),
+                stop_conditions=Length(self._length(byte_count + 2)),
             )
         )
         self._raise_if_error(response, exception_codes=EXCEPTIONS)
@@ -515,7 +518,7 @@ class Modbus(Protocol):
         response = self._parse_pdu(
             self._adapter.query(
                 self._make_pdu(query),
-                stop_condition=Length(self._length(2 + number_of_registers * 2)),
+                stop_conditions=Length(self._length(2 + number_of_registers * 2)),
             )
         )
         self._raise_if_error(response, exception_codes=EXCEPTIONS)
@@ -769,7 +772,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(len(query)))
+                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -805,7 +808,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(len(query)))
+                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1198,7 +1201,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(5))
+                self._make_pdu(query), stop_conditions=Length(self._length(5))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1250,7 +1253,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(5))
+                self._make_pdu(query), stop_conditions=Length(self._length(5))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1451,7 +1454,7 @@ class Modbus(Protocol):
         )
         response = self._parse_pdu(
             self._adapter.query(
-                self._make_pdu(query), stop_condition=Length(self._length(len(query)))
+                self._make_pdu(query), stop_conditions=Length(self._length(len(query)))
             )
         )
         self._raise_if_error(response, EXCEPTIONS)
@@ -1521,7 +1524,7 @@ class Modbus(Protocol):
         response = self._parse_pdu(
             self._adapter.query(
                 self._make_pdu(query),
-                stop_condition=Length(self._length(2 + number_of_read_registers * 2)),
+                stop_conditions=Length(self._length(2 + number_of_read_registers * 2)),
             )
         )
         self._raise_if_error(response, EXCEPTIONS)

syndesi/protocols/raw.py

@@ -49,33 +49,37 @@ class Raw(Protocol):
         self,
         data: bytes,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-        full_output: bool = False,
-    ) -> bytes | tuple[bytes, AdapterSignal]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
         self._adapter.flushRead()
         self.write(data)
-        return self.read(
-            timeout=timeout,
-            stop_condition=stop_condition,
-            full_output=full_output,
-        )
+        return self.read(timeout=timeout, stop_conditions=stop_conditions)
 
-    def read(
+    def query_detailed(
         self,
+        data: bytes,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-        full_output: bool = False,
-    ) -> bytes | tuple[bytes, AdapterSignal]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
+        self._adapter.flushRead()
+        self.write(data)
+        return self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
 
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+    def read(
+        self,
+        timeout: Timeout | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        return signal.data()
 
     def read_detailed(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[bytes, AdapterSignal | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
         return self._adapter.read_detailed(
-            timeout=timeout, stop_condition=stop_condition
+            timeout=timeout, stop_conditions=stop_conditions
         )
 
     def _on_data_ready_event(self, data: AdapterReadPayload) -> None:

syndesi/protocols/scpi.py

@@ -5,7 +5,7 @@
 
 from types import EllipsisType
 
-from syndesi.adapters.backend.adapter_backend import AdapterSignal
+from syndesi.adapters.backend.adapter_backend import AdapterReadPayload
 
 from ..adapters.adapter import Adapter
 from ..adapters.ip import IP
@@ -105,37 +105,40 @@ class SCPI(Protocol):
         self,
         command: str,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> str:
         self._adapter.flushRead()
         self.write(command)
 
-        return self.read(timeout=timeout, stop_condition=stop_condition)
+        return self.read(timeout=timeout, stop_conditions=stop_conditions)
 
     def read_raw(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[bytes, AdapterSignal | None]:
-        return self._adapter.read_detailed(
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> bytes:
+        signal = self.read_detailed(
             timeout=timeout,
-            stop_condition=stop_condition,
+            stop_conditions=stop_conditions,
         )
+        return signal.data()
 
     def read_detailed(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
-    ) -> tuple[str, AdapterSignal | None]:
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
+    ) -> AdapterReadPayload:
 
-        raw_data, signal = self.read_raw(timeout=timeout, stop_condition=stop_condition)
-        data_out = self._unformatCommand(self._from_bytes(raw_data))
-
-        return data_out, signal
+        signal = self._adapter.read_detailed(
+            timeout=timeout, stop_conditions=stop_conditions
+        )
+        return signal
 
     def read(
         self,
         timeout: Timeout | None | EllipsisType = ...,
-        stop_condition: StopCondition | None | EllipsisType = ...,
+        stop_conditions: StopCondition | EllipsisType | list[StopCondition] = ...,
     ) -> str:
-        return self.read_detailed(timeout=timeout, stop_condition=stop_condition)[0]
+        signal = self.read_detailed(timeout=timeout, stop_conditions=stop_conditions)
+        raw_data = signal.data()
+        return self._unformatCommand(self._from_bytes(raw_data))

syndesi/scripts/syndesi.py

@@ -22,9 +22,7 @@ def main() -> None:
         prog="syndesi", description="Syndesi command line tool", epilog=""
     )
 
-    parser.add_argument(
-        "--version", action="version", version=f"%(prog)s {__version__}"
-    )
+    parser.add_argument("--version", action="version", version=f"Syndesi {__version__}")
     parser.add_argument("-v", "--verbose", action="store_true")
     parser.add_argument(
         "command",

syndesi/tools/backend_api.py

@@ -26,25 +26,22 @@ default_host = LOCALHOST
 
 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,) -> ()
+    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_CONDITION = "set_stop_condition"  # (descriptor,stop_condition)
+    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"
-    #GET_BACKEND_TIME = "get_time"
 
     # Signal
     ADAPTER_SIGNAL = "adapter_signal"
-    #ADAPTER_EVENT_DATA_READY = "event_adapter_data_ready"
-    #ADAPTER_EVENT_DISCONNECTED = "event_adapter_disconnected"
-    #ADAPTER_EVENT_READ_INIT = "event_adapter_read_init"
 
     # Other
     SET_ROLE_ADAPTER = (
@@ -72,22 +69,15 @@ class Action(Enum):
     ERROR_FAILED_TO_OPEN = "error_failed_to_open"
 
 
-# def is_event(action: Action) -> bool:
-#     return action.value.startswith("event_")
-
-
 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
@@ -104,23 +94,6 @@ class Fragment:
         #     raise IndexError('Cannot index invalid fragment')
         return Fragment(self.data[key], self.timestamp)
 
-
-# def get_conn_addresses(conn: Connection) -> tuple[str, str]:
-#     try:
-#         fd = conn.fileno()
-#     except OSError:
-#         return ("closed", "closed")
-#     else:
-#         sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
-#         try:
-#             # address, port = sock.getpeername()  # (IP, port) tuple
-#             peer_address = sock.getpeername()
-#             sock_address = sock.getsockname()
-#             return sock_address, peer_address
-#         except Exception:
-#             return ("error", "closed")
-
-
 BackendResponse = tuple[object, ...]
 
 
@@ -199,10 +172,4 @@ class AdapterBackendStatus(Enum):
 
 class ClientStatus(Enum):
     DISCONNECTED = 0
-    CONNECTED = 1
-
-
-# class StatusSnapshot(TypedDict):
-#     type : Literal['snapshot']
-#     adapters :
-#     #clients : List[str]
+    CONNECTED = 1

syndesi/tools/backend_logger.py

@@ -41,7 +41,6 @@ class BackendLogger(threading.Thread):
                         self.conn_description = conn.local()
                     self._logger.info("Backend connected")
 
-
                 try:
                     backend_request(conn.conn, Action.SET_ROLE_LOGGER)
                 except BackendCommunicationError: