Synchronize Memory requirements tables

Updated scripts for generating memory requirements and updated
CSS files.

Signed-off-by: Arkadiusz Balys <arkadiusz.balys@nordicsemi.no>

Author: ArekBalysNordic

docs/_extensions/memory_data.py

@@ -3,8 +3,7 @@
 
 SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 
-Sphinx extension for partition layout bar charts.
-
+Sphinx extension for Matter reference partition layout bar charts.
 """
 
 from __future__ import annotations
@@ -17,7 +16,7 @@
 from docutils import nodes
 from docutils.parsers.rst import directives
 from docutils.statemachine import StringList
-from memory_data import load_memory_yaml, plain_tab_label, sort_boards_by_internal_memory
+from memory_data import load_board_data
 from sphinx.application import Sphinx
 from sphinx.util.docutils import SphinxDirective
 
@@ -38,14 +37,14 @@
     "#65a30d",
 ]
 
-
 _LAYOUT_FIXED_COLORS = {
     "padding": "#e2e8f0",
     "boot_partition": "#2563eb",
     "slot0_partition": "#16a34a",
     "slot1_partition": "#0369a1",
     "factory_data_partition": "#ea580c",
     "storage_partition": "#ca8a04",
+    "tfm_storage_partition": "#0d9488",
 }
 
 TOOLTIP_ALIGN_START_THRESHOLD_PCT = 20.0
@@ -70,7 +69,6 @@ def _hex_label(size_bytes: int) -> str:
 
 
 def _display_widths(sizes_bytes: list[int]) -> list[float]:
-    """Map partition sizes to bar widths proportional to byte size."""
     if not sizes_bytes:
         return []
     total = sum(max(size, 0) for size in sizes_bytes) or 1
@@ -201,63 +199,155 @@ def _render_region_html(region: dict[str, Any]) -> str:
     )
 
 
-def _render_board_layout_html(board: dict[str, Any]) -> str:
-    regions = "".join(_render_region_html(region) for region in board.get("regions", []))
+def _format_offset(offset_bytes: int) -> str:
+    return f"{offset_bytes} (0x{offset_bytes:x})"
+
+
+def _format_size(size_bytes: int) -> str:
+    return f"{_bytes_label(size_bytes)} ({_hex_label(size_bytes)})"
+
+
+def _iter_partition_rows(
+    partitions: list[dict[str, Any]],
+    *,
+    depth: int = 0,
+) -> list[tuple[str, int, int]]:
+    rows: list[tuple[str, int, int]] = []
+    indent = "  " * depth
+    for part in partitions:
+        rows.append((f"{indent}{part['label']}", int(part["offset_bytes"]), int(part["size_bytes"])))
+        children = part.get("children") or []
+        if children:
+            rows.extend(_iter_partition_rows(children, depth=depth + 1))
+    return rows
+
+
+def _append_rst_paragraph(state, parent: nodes.Element, rst_text: str) -> None:
+    paragraph = nodes.paragraph()
+    content = StringList([rst_text], "<memory_layout_table>")
+    state.nested_parse(content, 0, paragraph)
+    if len(paragraph) == 1 and isinstance(paragraph[0], nodes.paragraph):
+        inner = paragraph[0]
+        paragraph.remove(inner)
+        paragraph.extend(inner.children)
+    parent += paragraph
+
+
+def _build_region_table(region: dict[str, Any]) -> nodes.table:
+    table = nodes.table()
+    table["classes"] = ["memory-layout-table"]
+
+    tgroup = nodes.tgroup(cols=3)
+    table += tgroup
+    tgroup.extend([nodes.colspec(colwidth=24), nodes.colspec(colwidth=12), nodes.colspec(colwidth=12)])
+
+    thead = nodes.thead()
+    tgroup += thead
+    header_row = nodes.row()
+    thead += header_row
+    for title in ("Partition", "Offset", "Size"):
+        entry = nodes.entry()
+        entry += nodes.Text(title)
+        header_row += entry
+
+    tbody = nodes.tbody()
+    tgroup += tbody
+    for label, offset_bytes, size_bytes in _iter_partition_rows(region.get("partitions") or []):
+        row = nodes.row()
+        tbody += row
+
+        label_entry = nodes.entry()
+        label_entry += nodes.Text(label)
+        row += label_entry
+
+        offset_entry = nodes.entry()
+        offset_entry += nodes.Text(_format_offset(offset_bytes))
+        row += offset_entry
+
+        size_entry = nodes.entry()
+        size_entry += nodes.Text(_format_size(size_bytes))
+        row += size_entry
+
+    return table
+
+
+def build_layout_table_nodes(directive: SphinxDirective, data: dict[str, Any]) -> nodes.Element:
+    wrapper = nodes.container()
+    wrapper["classes"] = ["memory-layout-table-board"]
+
+    regions = data.get("reference_regions") or []
+    for index, region in enumerate(regions):
+        if index:
+            wrapper += nodes.raw("", '<div class="memory-layout-table-region-spacer"></div>', format="html")
+
+        total_bytes = int(region["total_bytes"])
+        title = nodes.paragraph()
+        title["classes"] = ["memory-layout-table-region-title"]
+        emphasis = nodes.strong()
+        emphasis += nodes.Text(
+            f'{region["title"]} (size: {_hex_label(total_bytes)} = {_bytes_label(total_bytes)})'
+        )
+        title += emphasis
+        wrapper += title
+
+        if region.get("address_note_rst"):
+            _append_rst_paragraph(directive.state, wrapper, str(region["address_note_rst"]))
+
+        wrapper += _build_region_table(region)
+
+    return wrapper
+
+
+def _render_board_layout_html(data: dict[str, Any]) -> str:
+    regions = "".join(_render_region_html(region) for region in data.get("reference_regions", []))
+    board_name = data.get("board", {}).get("name", "")
     return (
         f'<div class="memory-layout-board" '
-        f'data-board="{html.escape(board["board_id"], quote=True)}">'
+        f'data-board="{html.escape(board_name, quote=True)}">'
         f"{regions}</div>"
     )
 
 
-def _build_layout_tabs_rst(
-    directive: SphinxDirective,
-    boards: list[dict[str, Any]],
-    render_fn,
-    empty_message: str,
-) -> list[nodes.Node]:
-    if not boards:
-        note = nodes.paragraph()
-        note += nodes.emphasis(text=empty_message)
-        return [note]
-
-    lines = [".. tabs::", ""]
-    for board in boards:
-        lines.append(f"   .. group-tab:: {plain_tab_label(board['tab_title'])}")
-        lines.append("")
-        for intro_line in board.get("tab_intro_rst", "").splitlines():
-            lines.append(f"      {intro_line}")
-        lines.append("")
-        lines.append("      .. raw:: html")
-        lines.append("")
-        for html_line in render_fn(board).splitlines():
-            lines.append(f"         {html_line}")
-        lines.append("")
-
-    container = nodes.container()
-    directive.state.nested_parse(StringList(lines, "<memory_layout>"), 0, container)
-    return container.children
-
-
-class MemoryLayouts(SphinxDirective):
-    """Render reference memory layout charts from a YAML data file."""
+class MemoryLayoutBoard(SphinxDirective):
+    """Render reference memory layout charts from docs/data/memory/<board>.yaml."""
 
     required_arguments = 0
     optional_arguments = 0
     final_argument_whitespace = True
     has_content = False
     option_spec = {
-        "file": directives.unchanged_required,
+        "board": directives.unchanged_required,
     }
 
     def run(self) -> list[nodes.Node]:
-        data = load_memory_yaml(self, self.options["file"])
-        return _build_layout_tabs_rst(
-            self,
-            sort_boards_by_internal_memory(data.get("boards", [])),
-            _render_board_layout_html,
-            "No memory layout data found.",
-        )
+        data = load_board_data(self.options["board"])
+        if not data.get("reference_regions"):
+            note = nodes.paragraph()
+            note += nodes.emphasis(text="No memory layout data found.")
+            return [note]
+        container = nodes.container()
+        container += nodes.raw("", _render_board_layout_html(data), format="html")
+        return [container]
+
+
+class MemoryLayoutTable(SphinxDirective):
+    """Render reference memory layout tables from docs/data/memory/<board>.yaml."""
+
+    required_arguments = 0
+    optional_arguments = 0
+    final_argument_whitespace = True
+    has_content = False
+    option_spec = {
+        "board": directives.unchanged_required,
+    }
+
+    def run(self) -> list[nodes.Node]:
+        data = load_board_data(self.options["board"])
+        if not data.get("reference_regions"):
+            note = nodes.paragraph()
+            note += nodes.emphasis(text="No memory layout data found.")
+            return [note]
+        return [build_layout_table_nodes(self, data)]
 
 
 def add_memory_layout_viz_resources(app: Sphinx) -> None:
@@ -268,7 +358,8 @@ def add_memory_layout_viz_resources(app: Sphinx) -> None:
 
 
 def setup(app: Sphinx) -> dict[str, Any]:
-    app.add_directive("memory-layouts", MemoryLayouts)
+    app.add_directive("memory-layout-board", MemoryLayoutBoard)
+    app.add_directive("memory-layout-table", MemoryLayoutTable)
     app.connect("builder-inited", add_memory_layout_viz_resources)
     return {
         "version": __version__,