tdl-xoa-driver 1.0.0__py3-none-any.whl

xoa_driver/internals/core/transporter/logger/__logger.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+import typing as t
+import logging
+
+from .__state_off import StateOff
+from .__state_on_default import StateOnDefault
+from .__state_on_loguru import StateOnLoguru
+from .__state_on_user import StateOnUser
+
+
+class TransportationLogger:
+    __slots__ = ("enabled", "identity_name", "_logger", "__state")
+
+    def __init__(self, cid: str, enabled: bool = False, logger: CustomLogger | None = None) -> None:
+        self.enabled = enabled
+        self.identity_name = f"{cid}"
+        self.__state = self.__select_state(logger)
+        self._logger = self.__state.setup(self.identity_name, logger)
+
+    def __select_state(self, logger) -> t.Type[LoggerState]:
+        if not self.enabled:
+            return StateOff
+        elif self.enabled and logger is None:
+            return StateOnDefault
+        elif isinstance(logger, logging.Logger):
+            return StateOnDefault
+        try:
+            from loguru import Logger as LoguruLogger
+        except ImportError:
+            pass
+        else:
+            if isinstance(logger, LoguruLogger):
+                return StateOnLoguru
+        return StateOnUser
+
+    def info(self, msg: t.Any) -> None:
+        self.__state.info(self, msg)
+
+    def error(self, msg: t.Any) -> None:
+        self.__state.error(self, msg)
+
+    def debug_request(self, request: object) -> None:
+        self.__state.debug_request(self, request)
+
+    def debug_response(self, response: object) -> None:
+        self.__state.debug_response(self, response)
+
+    def debug_push(self, response: object) -> None:
+        self.__state.debug_push(self, response)
+
+
+class CustomLogger(t.Protocol):
+    """
+        The custom logger must be an instance of python Logger or Loguru Logger.
+        by providing the custom class of the logger we will not waranty as all of 
+        the messages will be visible to the user.
+    """
+    def debug(self, msg, /, *args, **kwargs: t.Any) -> None:
+        ...
+
+    def info(self, msg, /, *args, **kwargs: t.Any) -> None:
+        ...
+
+    def warning(self, msg, /, *args, **kwargs: t.Any) -> None:
+        ...
+
+    def error(self, msg, /, *args, **kwargs: t.Any) -> None:
+        ...
+
+
+class LoggerState(t.Protocol):
+    @staticmethod
+    def setup(connid: str, logger) -> CustomLogger | None:
+        return None
+
+    @staticmethod
+    def info(inst: "TransportationLogger", msg: t.Any) -> None:
+        ...
+
+    @staticmethod
+    def error(inst: "TransportationLogger", msg: t.Any) -> None:
+        ...
+
+    @staticmethod
+    def debug_request(inst: "TransportationLogger", request: object) -> None:
+        ...
+
+    @staticmethod
+    def debug_response(inst: "TransportationLogger", response: object) -> None:
+        ...
+
+    @staticmethod
+    def debug_push(inst: "TransportationLogger", response: object) -> None:
+        ...

xoa_driver/internals/core/transporter/logger/__state_off.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+import typing as t
+
+if t.TYPE_CHECKING:
+    from .__logger import TransportationLogger
+
+
+class StateOff:
+
+    @staticmethod
+    def setup(connid: str, logger) -> None:
+        return None
+
+    @staticmethod
+    def info(inst: "TransportationLogger", msg: t.Any) -> None:
+        return None
+
+    @staticmethod
+    def error(inst: "TransportationLogger", msg: t.Any) -> None:
+        return None
+
+    @staticmethod
+    def debug_request(inst: "TransportationLogger", request: object) -> None:
+        return None
+
+    @staticmethod
+    def debug_response(inst: "TransportationLogger", response: object) -> None:
+        return None
+
+    @staticmethod
+    def debug_push(inst: "TransportationLogger", response: object) -> None:
+        return None

xoa_driver/internals/core/transporter/logger/__state_on_default.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+import sys
+import typing as t
+import logging
+
+if t.TYPE_CHECKING:
+    from .__logger import TransportationLogger
+
+
+RESET = "\x1b[0m"
+YELLOW = "\x1b[30;43m"
+GREEN = "\x1b[30;42m"
+MAGENTA = "\x1b[1;45m"
+
+SYMBOL_REQUEST = f"{GREEN} -> {RESET}"
+SYMBOL_PUSH = f"{MAGENTA} -P {RESET}"
+SYMBOL_RESPONSE = f"{YELLOW} <- {RESET}"
+
+
+class XoaLoggerAdapter(logging.LoggerAdapter):
+    def process(self, msg: t.Any, kwargs: t.MutableMapping[str, t.Any]):
+        if not self.extra:
+            return f"{msg}", kwargs
+        return f"[{self.extra['connid']}] {msg}", kwargs
+
+
+class StateOnDefault:
+    @staticmethod
+    def setup(connid: str, logger: logging.Logger | None) -> XoaLoggerAdapter:
+        log_stream_formatter = logging.Formatter(
+            fmt="%(asctime)s | %(levelname)-8s | %(message)s"
+        )
+        console_handler = logging.StreamHandler(stream=sys.stdout)
+        console_handler.setFormatter(log_stream_formatter)
+        if not logger:
+            logger = logging.getLogger("XOA_Driver")
+            logger.propagate = False
+            logger.addHandler(console_handler)
+            logger.setLevel(logging.DEBUG)
+        return XoaLoggerAdapter(logger, {'connid': connid})
+
+    @staticmethod
+    def info(inst: "TransportationLogger", msg: t.Any) -> None:
+        _logger = t.cast(logging.Logger, inst._logger)
+        if _logger.isEnabledFor(logging.INFO):
+            _logger.info(msg)
+
+    @staticmethod
+    def error(inst: "TransportationLogger", msg: t.Any) -> None:
+        _logger = t.cast(logging.Logger, inst._logger)
+        if _logger.isEnabledFor(logging.ERROR):
+            _logger.error(msg)
+
+    @staticmethod
+    def debug_request(inst: "TransportationLogger", request: object) -> None:
+        _logger = t.cast(logging.Logger, inst._logger)
+        if _logger.isEnabledFor(logging.DEBUG):
+            _logger.debug(f"{SYMBOL_REQUEST} {request!r}")
+
+    @staticmethod
+    def debug_response(inst: "TransportationLogger", response: object) -> None:
+        _logger = t.cast(logging.Logger, inst._logger)
+        if _logger.isEnabledFor(logging.DEBUG):
+            _logger.debug(f"{SYMBOL_RESPONSE} {response!r}")
+
+    @staticmethod
+    def debug_push(inst: "TransportationLogger", response: object) -> None:
+        _logger = t.cast(logging.Logger, inst._logger)
+        if _logger.isEnabledFor(logging.DEBUG):
+            _logger.debug(f"{SYMBOL_PUSH} {response!r}")

xoa_driver/internals/core/transporter/logger/__state_on_loguru.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+import sys
+import typing as t
+
+if t.TYPE_CHECKING:
+    try:
+        from loguru import Logger
+    except ImportError:
+        pass
+    from .__logger import TransportationLogger
+
+
+SYMBOL_REQUEST = "<G><w> -> </w></G>"
+SYMBOL_PUSH = "<M><w> -P </w></M>"
+SYMBOL_RESPONSE = "<Y><e> <- </e></Y>"
+
+
+class StateOnLoguru:
+
+    @staticmethod
+    def setup(connid: str, logger: "Logger") -> "Logger":
+        logger.remove()  # All configured handlers are removed
+        fmt = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <level>{message}</level>"
+        logger.add(sys.stdout, format=fmt)
+        logger = logger.bind(connid=connid)
+        return logger
+
+    @staticmethod
+    def info(inst: "TransportationLogger", msg: t.Any) -> None:
+        _loger = t.cast("Logger", inst._logger)
+        _loger.opt(lazy=True, colors=True).info(msg)
+
+    @staticmethod
+    def error(inst: "TransportationLogger", msg: t.Any) -> None:
+        _loger = t.cast("Logger", inst._logger)
+        _loger.opt(lazy=True, colors=True).error(msg)
+
+    @staticmethod
+    def debug_request(inst: "TransportationLogger", request: object) -> None:
+        _loger = t.cast("Logger", inst._logger)
+        _loger.opt(lazy=True, colors=True).debug(f"{SYMBOL_REQUEST} {request!r}")
+
+    @staticmethod
+    def debug_response(inst: "TransportationLogger", response: object) -> None:
+        _loger = t.cast("Logger", inst._logger)
+        _loger.opt(lazy=True, colors=True).debug(f"{SYMBOL_RESPONSE} {response!r}")
+
+    @staticmethod
+    def debug_push(inst: "TransportationLogger", response: object) -> None:
+        _loger = t.cast("Logger", inst._logger)
+        _loger.opt(lazy=True, colors=True).debug(f"{SYMBOL_PUSH} {response!r}")

xoa_driver/internals/core/transporter/logger/__state_on_user.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+import typing as t
+
+if t.TYPE_CHECKING:
+    from .__logger import (
+        TransportationLogger,
+        CustomLogger,
+    )
+
+
+RESET = "\x1b[0m"
+YELLOW = "\x1b[30;43m"
+GREEN = "\x1b[30;42m"
+MAGENTA = "\x1b[1;45m"
+
+SYMBOL_REQUEST = f"{GREEN} -> {RESET}"
+SYMBOL_PUSH = f"{MAGENTA} -P {RESET}"
+SYMBOL_RESPONSE = f"{YELLOW} <- {RESET}"
+
+class StateOnUser:
+    @staticmethod
+    def setup(connid: str, logger: "CustomLogger") -> "CustomLogger" | None:
+        return logger
+
+    @staticmethod
+    def info(inst: "TransportationLogger", msg: t.Any) -> None:
+        _logger = t.cast("CustomLogger", inst._logger)
+        _logger.info(msg)
+
+    @staticmethod
+    def error(inst: "TransportationLogger", msg: t.Any) -> None:
+        _logger = t.cast("CustomLogger", inst._logger)
+        _logger.error(msg)
+
+    @staticmethod
+    def debug_request(inst: "TransportationLogger", request: object) -> None:
+        _logger = t.cast("CustomLogger", inst._logger)
+        _logger.debug(f"{SYMBOL_REQUEST} {request!r}")
+
+    @staticmethod
+    def debug_response(inst: "TransportationLogger", response: object) -> None:
+        _logger = t.cast("CustomLogger", inst._logger)
+        _logger.debug(f"{SYMBOL_RESPONSE} {response!r}")
+
+    @staticmethod
+    def debug_push(inst: "TransportationLogger", response: object) -> None:
+        _logger = t.cast("CustomLogger", inst._logger)
+        _logger.debug(f"{SYMBOL_PUSH} {response!r}")

xoa_driver/internals/core/transporter/protocol/_constants.py

@@ -0,0 +1,77 @@
+from enum import IntEnum
+from typing import Final
+
+
+NOTHING: Final = 0xFF
+WILDCARD: Final = 0xFE
+NOVALUE: Final = "N/A"
+MAGIC_WORD: Final = b"XENA"
+# MAGIC_WORD = 0x58454E41
+
+
+def indices_format(number: int) -> str:
+    return f"!{number}I"
+
+
+class CommandType(IntEnum):
+    """BXMP request type"""
+
+    COMMAND_CHAIN = 1
+    COMMAND_QUERY = 2
+    COMMAND_VALUE = 3
+    COMMAND_STATUS = 4
+
+
+class CommandStatus(IntEnum):
+    """Status codes in BXMP response message to request type <COMMAND_STATUS = 4>"""
+
+    OK = 0
+    """OK"""
+    NOCONNECTIONS = 1
+    """chassis has no available connection slots"""
+    NOTLOGGEDON = 2
+    """no command can be submitted before logon"""
+    NOTRESERVED = 3
+    """parameter cannot be set because containing resource not reserved"""
+    NOTWRITABLE = 4
+    """parameter cannot be set because it is not in a writable state"""
+    NOTREADABLE = 5
+    """parameter is write-only"""
+    NOTVALID = 6
+    """operation not valid in current state"""
+    BADHEADER = 7
+    """invalid magic word"""
+    BADCOMMAND = 8
+    """invalid command"""
+    BADPARAMETER = 9
+    """invalid parameter code"""
+    BADMODULE = 10
+    """invalid module index"""
+    BADPORT = 11
+    """invalid port index"""
+    BADINDEX = 12
+    """invalid parameter index"""
+    BADSIZE = 13
+    """invalid size of data"""
+    BADVALUE = 14
+    """invalid value of data"""
+    FAILED = 15
+    """failed to perform operation"""
+    MEMORYFAILURE = 16
+    """failed to allocate memory"""
+    NOLICPE = 17
+    """no free PE license"""
+    NOLICPORT = 18
+    """no free Port license"""
+    NOTSUPPORTED = 19
+    """feature not supported"""
+    PENDING = 20
+    """status return will wait until command has been executed"""
+    MODULE_OPERATION_NOT_SUPPORTED_BY_CHASSIS = 21
+    """module is not supported by chassis - e.g. because multi-image requires x64 OS."""
+    XLSFAILED = 22
+    """could not establish connection to Xena License Server"""
+    XLSDENIED = 23
+    """request for resource rejected by Xena License Server"""
+    XLSINVALID = 24
+    """Trying to run Valkyrie VE with VulcanVE-300 resource"""

xoa_driver/internals/core/transporter/protocol/_utils.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+from typing import Generator
+from . import _constants as const
+
+
+def repr_bytes(data: bytes) -> list[str]:
+    return data.hex(",").split(",")
+
+
+def get_code_str(x) -> Generator[int | str, None, None]:
+    code, ty = (
+        x.header.cmd_code,
+        x.header.cmd_type,
+    )
+    yield const.CommandType(ty).name
+    if ty == const.CommandType.COMMAND_STATUS:
+        yield const.CommandStatus(code).name
+    else:
+        yield code
+
+
+def format_repr(obj) -> str:
+    ty_str, code_str = get_code_str(obj)
+    return (
+        f"{str(obj.header.request_identifier):5s} "
+        f"{str(obj.header.module_index):3s} "
+        f"{str(obj.header.port_index):3s} "
+        f"{str(obj.index_values):10s} "
+        f"{str(obj.class_name):25s} "
+        f"{str(code_str):6s} "
+        f"{str(ty_str):15s} "
+        f"{obj.values}"
+    )
+
+
+def format_str(obj) -> str:
+    bin_str = repr_bytes(bytes(obj))
+    ty_str, code_str = get_code_str(obj)
+    obj_name = type(obj).__name__
+    if obj_name == 'Response':
+        cmd_p = 'Replied' if obj.header.request_identifier != 0 else 'Pushed'
+    else:
+        cmd_p = [code_str, ty_str]
+
+    return "\n" + "\n".join(
+        (
+            f"{obj_name}              : {bin_str}",
+            f"class_name           : {obj.class_name}",
+            f"magic_word           : {obj.header.magic_word}",
+            f"number_of_indices    : {obj.header.number_of_indices}",
+            f"number_of_value_bytes: {obj.header.number_of_value_bytes}",
+            f"command_parameter    : {obj.header.command_parameter}:{cmd_p}",
+            f"module_index         : {obj.header.module_index}",
+            f"port_index           : {obj.header.port_index}",
+            f"request_identifier   : {obj.header.request_identifier}",
+            f"index_values         : {obj.index_values}",
+            f"values               : {obj.values}",
+        )
+    )