marilib-pkg 0.6.0__py3-none-any.whl

marilib/protocol.py

@@ -0,0 +1,109 @@
+# TODO: import this from like PyDotBot or similar
+
+import dataclasses
+import typing
+from abc import ABC
+from dataclasses import dataclass
+from enum import IntEnum
+
+
+class ProtocolPayloadParserException(Exception):
+    """Exception raised on invalid or unsupported payload."""
+
+
+class PacketType(IntEnum):
+    """Types of MAC layer packet."""
+
+    BEACON = 1
+    JOIN_REQUEST = 2
+    JOIN_RESPONSE = 4
+    KEEP_ALIVE = 8
+    DATA = 16
+
+
+@dataclass
+class PacketFieldMetadata:
+    """Data class that describes a packet field metadata."""
+
+    name: str = ""
+    disp: str = ""
+    length: int = 1
+    signed: bool = False
+    type_: typing.Any = int
+
+    def __post_init__(self):
+        if not self.disp:
+            self.disp = self.name
+
+
+@dataclass
+class Packet(ABC):
+    """Base class for packet classes."""
+
+    @property
+    def size(self) -> int:
+        return sum(field.length for field in self.metadata)
+
+    def from_bytes(self, bytes_):
+        fields = dataclasses.fields(self)
+        # base class makes metadata attribute mandatory so there's at least one
+        # field defined in subclasses
+        # first elements in fields has to be metadata
+        if not fields or fields[0].name != "metadata":
+            raise ValueError("metadata must be defined first")
+        metadata = fields[0].default_factory()
+        for idx, field in enumerate(fields[1:]):
+            if metadata[idx].type_ is list:
+                element_class = typing.get_args(field.type)[0]
+                field_attribute = getattr(self, field.name)
+                # subclass element is a list and previous attribute is called
+                # "count" and should have already been retrieved from the byte
+                # stream
+                for _ in range(self.count):
+                    element = element_class()
+                    if len(bytes_) < element.size:
+                        raise ValueError("Not enough bytes to parse")
+                    field_attribute.append(element.from_bytes(bytes_))
+                    bytes_ = bytes_[element.size :]
+            elif metadata[idx].type_ in [bytes, bytearray]:
+                # subclass element is bytes and previous attribute is called
+                # "count" and should have already been retrieved from the byte
+                # stream
+                length = metadata[idx].length
+                if hasattr(self, "count"):
+                    length = self.count
+                setattr(self, field.name, bytes_[0:length])
+                bytes_ = bytes_[length:]
+            else:
+                length = metadata[idx].length
+                if len(bytes_) < length:
+                    raise ValueError("Not enough bytes to parse")
+                setattr(
+                    self,
+                    field.name,
+                    int.from_bytes(
+                        bytes=bytes_[0:length],
+                        signed=metadata[idx].signed,
+                        byteorder="little",
+                    ),
+                )
+                bytes_ = bytes_[length:]
+        return self
+
+    def to_bytes(self, byteorder="little") -> bytes:
+        buffer = bytearray()
+        metadata = dataclasses.fields(self)[0].default_factory()
+        for idx, field in enumerate(dataclasses.fields(self)[1:]):
+            value = getattr(self, field.name)
+            if isinstance(value, list):
+                for element in value:
+                    buffer += element.to_bytes()
+            elif isinstance(value, (bytes, bytearray)):
+                buffer += value
+            else:
+                buffer += int(value).to_bytes(
+                    length=metadata[idx].length,
+                    byteorder=byteorder,
+                    signed=metadata[idx].signed,
+                )
+        return buffer

marilib/serial_hdlc.py

@@ -0,0 +1,228 @@
+"""Module implementing HDLC protocol primitives."""
+
+import logging
+from enum import Enum
+
+HDLC_FLAG = b"\x7e"
+HDLC_FLAG_ESCAPED = b"\x5e"
+HDLC_ESCAPE = b"\x7d"
+HDLC_ESCAPE_ESCAPED = b"\x5d"
+HDLC_FCS_INIT = 0xFFFF
+HDLC_FCS_OK = 0xF0B8
+
+# fmt: off
+FCS16TAB = (
+    0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
+    0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7,
+    0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E,
+    0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
+    0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD,
+    0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
+    0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C,
+    0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
+    0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
+    0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
+    0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A,
+    0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
+    0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9,
+    0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
+    0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738,
+    0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
+    0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7,
+    0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
+    0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036,
+    0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
+    0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5,
+    0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
+    0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134,
+    0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
+    0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3,
+    0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
+    0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
+    0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
+    0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1,
+    0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
+    0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330,
+    0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78,
+)
+# fmt: on
+
+
+class HDLCDecodeException(Exception):
+    """Exception raised when decoding wrong HDLC frames."""
+
+
+def _fcs_update(fcs, byte):
+    return (fcs >> 8) ^ FCS16TAB[((fcs ^ ord(byte)) & 0xFF)]
+
+
+def _to_byte(value):
+    return int(value).to_bytes(1, "little")
+
+
+def _escape_byte(byte) -> bytes:
+    result = bytearray()
+    if byte == HDLC_ESCAPE:
+        result += HDLC_ESCAPE
+        result += HDLC_ESCAPE_ESCAPED
+    elif byte == HDLC_FLAG:
+        result += HDLC_ESCAPE
+        result += HDLC_FLAG_ESCAPED
+    else:
+        result += byte
+    return result
+
+
+def hdlc_encode(payload: bytes) -> bytes:
+    """Encodes a payload in an HDLC frame.
+    >>> hdlc_encode(b"test")
+    bytearray(b'~test\\x88\\x07~')
+    >>> hdlc_encode(b"")
+    bytearray(b'~\\x00\\x00~')
+    >>> hdlc_encode(b"\\x00\\x00\\xf6\\xf6\\xf6\\xf6")
+    bytearray(b'~\\x00\\x00\\xf6\\xf6\\xf6\\xf6\\xb2+~')
+    >>> hdlc_encode(b"\\x00\\x01\\n\\n\\n")
+    bytearray(b'~\\x00\\x01\\n\\n\\n\\x9c\\xf2~')
+    >>> hdlc_encode(b"~test~")
+    bytearray(b'~}^test}^\\x9d\\xa6~')
+    >>> hdlc_encode(b"~test}")
+    bytearray(b'~}^test}]\\x06\\x94~')
+    >>> hdlc_encode(b"\\xe7\\x94:\\xa6")
+    bytearray(b'~\\xe7\\x94:\\xa6\\x83}^~')
+    >>> hdlc_encode(b"'$W\\x82")
+    bytearray(b"~\\'$W\\x82\\x13}]~")
+    """
+    # initialize output buffer
+    hdlc_frame = bytearray()
+
+    # initialize frame check sequence
+    fcs = HDLC_FCS_INIT
+
+    # add start flag
+    hdlc_frame += HDLC_FLAG
+
+    # write payload in frame
+    for byte in payload:
+        fcs = _fcs_update(fcs, _to_byte(byte))
+        hdlc_frame += _escape_byte(_to_byte(byte))
+    fcs = 0xFFFF - fcs
+
+    # add FCS
+    hdlc_frame += _escape_byte(_to_byte(fcs & 0xFF))
+    hdlc_frame += _escape_byte(_to_byte((fcs & 0xFF00) >> 8))
+
+    # add end flag
+    hdlc_frame += HDLC_FLAG
+
+    return hdlc_frame
+
+
+def hdlc_decode(frame: bytes) -> bytes:
+    """Decodes an HDLC frame and return the payload it contains.
+
+    >>> hdlc_decode(b"~test\\x88\\x07~")
+    bytearray(b'test')
+    >>> hdlc_decode(b"~\\x00\\x00\\xf6\\xf6\\xf6\\xf6\\xb2+~")
+    bytearray(b'\\x00\\x00\\xf6\\xf6\\xf6\\xf6')
+    >>> hdlc_decode(b"~\\x00\\x01\\n\\n\\n\\x9c\\xf2~")
+    bytearray(b'\\x00\\x01\\n\\n\\n')
+    >>> hdlc_decode(b"~}^test}^\\x9d\\xa6~")
+    bytearray(b'~test~')
+    >>> hdlc_decode(b"~}^test}]\\x06\\x94~")
+    bytearray(b'~test}')
+    >>> hdlc_decode(b"~\\xe7\\x94:\\xa6\\x83}^~")
+    bytearray(b'\\xe7\\x94:\\xa6')
+    >>> hdlc_decode(b"~\\'$W\\x82\\x13}]~")
+    bytearray(b"\\'$W\\x82")
+    >>> hdlc_decode(b"~\\x00\\x00~")
+    bytearray(b'')
+    >>> hdlc_decode(b"~test\\x42\\x42~")
+    Traceback (most recent call last):
+    marilib.serial_hdlc.HDLCDecodeException: Invalid FCS
+    >>> hdlc_decode(b"~\\x00~")
+    Traceback (most recent call last):
+    marilib.serial_hdlc.HDLCDecodeException: Invalid payload
+    """
+    output = bytearray()
+    fcs = HDLC_FCS_INIT
+    escape_byte = False
+    for byte in frame[1:-1]:
+        byte = _to_byte(byte)
+        if byte == HDLC_ESCAPE:
+            escape_byte = True
+        elif escape_byte is True:
+            if byte == HDLC_ESCAPE_ESCAPED:
+                output += HDLC_ESCAPE
+                fcs = _fcs_update(fcs, HDLC_ESCAPE)
+            elif byte == HDLC_FLAG_ESCAPED:
+                output += HDLC_FLAG
+                fcs = _fcs_update(fcs, HDLC_FLAG)
+            escape_byte = False
+        else:
+            output += byte
+            fcs = _fcs_update(fcs, byte)
+    if len(output) < 2:
+        raise HDLCDecodeException("Invalid payload")
+    if fcs != HDLC_FCS_OK:
+        raise HDLCDecodeException("Invalid FCS")
+    return output[:-2]
+
+
+class HDLCState(Enum):
+    """State of the HDLC handler."""
+
+    IDLE = 0
+    RECEIVING = 1
+    READY = 2
+
+
+class HDLCHandler:
+    """Handles the reception of an HDLC frame byte by byte."""
+
+    def __init__(self):
+        self.state = HDLCState.IDLE
+        self.fcs = HDLC_FCS_INIT
+        self.output = bytearray()
+        self.escape_byte = False
+        self._logger = logging.getLogger(__name__)
+
+    @property
+    def payload(self):
+        """Returns the payload contained in a frame."""
+        if self.state != HDLCState.READY:
+            raise HDLCDecodeException("Incomplete HDLC frame")
+
+        self.state = HDLCState.IDLE
+        if len(self.output) < 2:
+            self._logger.error("Invalid payload")
+            return bytearray()
+        if self.fcs != HDLC_FCS_OK:
+            self._logger.error("Invalid FCS")
+            return bytearray()
+        self.fcs = HDLC_FCS_INIT
+        return self.output[:-2]
+
+    def handle_byte(self, byte):
+        """Handle new byte received."""
+        if self.state in [HDLCState.IDLE, HDLCState.READY] and byte == HDLC_FLAG:
+            self.output = bytearray()
+            self.fcs = HDLC_FCS_INIT
+            self.state = HDLCState.RECEIVING
+        elif self.output and self.state == HDLCState.RECEIVING and byte == HDLC_FLAG:
+            # End of frame
+            self.state = HDLCState.READY
+        elif self.state == HDLCState.RECEIVING and byte != HDLC_FLAG:
+            # Middle of the frame
+            if byte == HDLC_ESCAPE:
+                self.escape_byte = True
+            elif self.escape_byte is True:
+                if byte == HDLC_ESCAPE_ESCAPED:
+                    self.output += HDLC_ESCAPE
+                    self.fcs = _fcs_update(self.fcs, HDLC_ESCAPE)
+                elif byte == HDLC_FLAG_ESCAPED:
+                    self.output += HDLC_FLAG
+                    self.fcs = _fcs_update(self.fcs, HDLC_FLAG)
+                self.escape_byte = False
+            else:
+                self.output += byte
+                self.fcs = _fcs_update(self.fcs, byte)

marilib/serial_uart.py

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: 2022-present Inria
+# SPDX-FileCopyrightText: 2022-present Alexandre Abadie <alexandre.abadie@inria.fr>
+# SPDX-FileCopyrightText: 2025-present Geovane Fedrecheski <geovane.fedrecheski@inria.fr>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Serial interface."""
+
+import logging
+import sys
+import threading
+import time
+from typing import Callable
+
+import serial
+from serial.tools import list_ports
+
+SERIAL_PAYLOAD_CHUNK_SIZE = 64
+SERIAL_PAYLOAD_CHUNK_DELAY = 0.002  # 2 ms
+SERIAL_DEFAULT_PORT = "/dev/ttyACM0"
+SERIAL_DEFAULT_BAUDRATE = 1_000_000
+
+
+def get_default_port():
+    """Return default serial port."""
+    ports = [port for port in list_ports.comports()]
+    if sys.platform != "win32":
+        ports = sorted([port for port in ports if "J-Link" == port.product])
+    if not ports:
+        return SERIAL_DEFAULT_PORT
+    # return first JLink port available
+    return ports[0].device
+
+
+class SerialInterfaceException(Exception):
+    """Exception raised when serial port is disconnected."""
+
+
+class SerialInterface(threading.Thread):
+    """Bidirectional serial interface."""
+
+    def __init__(self, port: str, baudrate: int, callback: Callable):
+        self.lock = threading.Lock()
+        self.callback = callback
+        self.serial = serial.Serial(port, baudrate)
+        super().__init__(daemon=True)
+        self._logger = logging.getLogger(__name__)
+        self.start()
+        self._logger.info("Serial port thread started")
+
+    def run(self):
+        """Listen continuously at each byte received on serial."""
+        self.serial.flush()
+        try:
+            while 1:
+                try:
+                    byte = self.serial.read(1)
+                except (TypeError, serial.serialutil.SerialException):
+                    byte = None
+                if byte is None:
+                    self._logger.info("Serial port disconnected")
+                    break
+                self.callback(byte)
+        except serial.serialutil.PortNotOpenError as exc:
+            self._logger.error(f"{exc}")
+            raise SerialInterfaceException(f"{exc}") from exc
+        except serial.serialutil.SerialException as exc:
+            self._logger.error(f"{exc}")
+            raise SerialInterfaceException(f"{exc}") from exc
+
+    def stop(self):
+        self.serial.close()
+        self.join()
+
+    def write(self, bytes_):
+        """Write bytes on serial."""
+        # Send 64 bytes at a time
+        pos = 0
+        while (pos % SERIAL_PAYLOAD_CHUNK_SIZE) == 0 and pos < len(bytes_):
+            self.serial.write(bytes_[pos : pos + SERIAL_PAYLOAD_CHUNK_SIZE])
+            self.serial.flush()
+            pos += SERIAL_PAYLOAD_CHUNK_SIZE
+            time.sleep(SERIAL_PAYLOAD_CHUNK_DELAY)
+        # self.serial.flush()

marilib/tui.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+from marilib.marilib import MarilibBase
+
+
+class MarilibTUI(ABC):
+    @abstractmethod
+    def render(self, mari: MarilibBase):
+        pass
+
+    @abstractmethod
+    def close(self):
+        pass

marilib/tui_cloud.py

@@ -0,0 +1,158 @@
+from datetime import datetime, timedelta
+
+from rich.columns import Columns
+from rich.console import Console, Group
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from marilib import MarilibCloud
+from marilib.model import MariGateway
+from marilib.tui import MarilibTUI
+
+
+class MarilibTUICloud(MarilibTUI):
+    """A Text-based User Interface for MarilibCloud."""
+
+    def __init__(
+        self,
+        max_tables=4,
+        re_render_max_freq=0.2,
+    ):
+        self.console = Console()
+        self.live = Live(console=self.console, auto_refresh=False, transient=True)
+        self.live.start()
+        self.max_tables = max_tables
+        self.re_render_max_freq = re_render_max_freq
+        self.last_render_time = datetime.now()
+
+    def get_max_rows(self) -> int:
+        """Calculate maximum rows based on terminal height."""
+        terminal_height = self.console.height
+        available_height = terminal_height - 10 - 2 - 2 - 1 - 2
+        return max(2, available_height)
+
+    def render(self, mari: MarilibCloud):
+        """Render the TUI layout."""
+        with mari.lock:
+            if datetime.now() - self.last_render_time < timedelta(seconds=self.re_render_max_freq):
+                return
+            self.last_render_time = datetime.now()
+            layout = Layout()
+            layout.split(
+                Layout(self.create_header_panel(mari), size=6),
+                Layout(self.create_gateways_panel(mari)),
+            )
+            self.live.update(layout, refresh=True)
+
+    def create_header_panel(self, mari: MarilibCloud) -> Panel:
+        """Create the header panel with MQTT connection and network info."""
+        status = Text()
+        status.append("MarilibCloud is ", style="bold")
+        status.append("connected", style="bold green")
+        status.append(
+            f" to MQTT broker {mari.mqtt_interface.host}:{mari.mqtt_interface.port} "
+            f"at topic /mari/{mari.network_id_str}/to_cloud "
+            f"since {mari.started_ts.strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+        status.append("  |  ")
+        secs = int((datetime.now() - mari.last_received_mqtt_data_ts).total_seconds())
+        status.append(
+            f"last received: {secs}s ago",
+            style="bold green" if secs <= 1 else "bold red",
+        )
+
+        status.append("\n\nNetwork ID: ", style="bold cyan")
+        status.append(f"0x{mari.network_id:04X}")
+        status.append("  |  ")
+        status.append("Gateways: ", style="bold cyan")
+        status.append(f"{len(mari.gateways)}")
+        status.append("  |  ")
+        status.append("Nodes: ", style="bold cyan")
+        status.append(f"{len(mari.nodes)}")
+
+        return Panel(status, title="[bold]MarilibCloud Status", border_style="blue")
+
+    def create_gateway_table(self, gateway: MariGateway) -> Table:
+        """Create a table for a single gateway with 3 rows and 2 columns."""
+        table = Table(
+            show_header=False,
+            border_style="blue",
+            padding=(0, 1),
+        )
+        table.add_column("Field", style="bold", width=18, justify="right")
+        table.add_column("Value")
+
+        # Row 1: Gateway info
+        node_count = f"{len(gateway.nodes)} / {gateway.info.schedule_uplink_cells}"
+        schedule_info = f"#{gateway.info.schedule_id} {gateway.info.schedule_name}"
+        table.add_row(
+            f"[bold cyan]0x{gateway.info.address:016X}[/bold cyan]",
+            f"Nodes: {node_count}  |  Schedule: {schedule_info}",
+        )
+
+        # Row 2: Schedule usage
+        schedule_repr = gateway.info.repr_schedule_cells_with_colors()
+        table.add_row("[bold cyan]Live schedule[/bold cyan]", schedule_repr)
+
+        # Row 3: Node list
+        if gateway.nodes:
+            node_addresses = [f"0x{node.address:016X}" for node in gateway.nodes]
+            node_display = " ".join(node_addresses)
+        else:
+            node_display = "—"
+
+        table.add_row("[bold cyan]Nodes[/bold cyan]", node_display)
+
+        return table
+
+    def create_gateways_panel(self, mari: MarilibCloud) -> Panel:
+        """Create the panel that contains individual gateway tables."""
+        gateways = list(mari.gateways.values())
+
+        if not gateways:
+            empty_table = Table(title="No Gateways Connected")
+            return Panel(
+                empty_table,
+                title="[bold]Connected Gateways",
+                border_style="blue",
+            )
+
+        # Create individual tables for each gateway
+        gateway_tables = []
+        max_displayable_gateways = self.max_tables
+        gateways_to_display = gateways[:max_displayable_gateways]
+        remaining_gateways = max(0, len(gateways) - max_displayable_gateways)
+
+        for gateway in gateways_to_display:
+            gateway_tables.append(self.create_gateway_table(gateway))
+
+        # Arrange tables in columns
+        if len(gateway_tables) > 1:
+            content = Columns(gateway_tables, equal=True, expand=True)
+        else:
+            content = gateway_tables[0]
+
+        if remaining_gateways > 0:
+            panel_content = Group(
+                content,
+                Text(
+                    f"\n...and {remaining_gateways} more gateway(s)",
+                    style="bold yellow",
+                ),
+            )
+        else:
+            panel_content = content
+
+        return Panel(
+            panel_content,
+            title="[bold]Connected Gateways",
+            border_style="blue",
+        )
+
+    def close(self):
+        """Clean up the live display."""
+        self.live.stop()
+        print("")