dcmspec 0.2.3__tar.gz → 0.3.0__tar.gz

{dcmspec-0.2.3 → dcmspec-0.3.0}/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 These release notes summarize key changes, improvements, and breaking updates for each version of **dcmspec**.
 
+## [0.3.0] - 2025-11-27
+
+### Added
+
+- CSV output mode in `SpecPrinter` via `print_csv` method
+- Excel OOXML output mode in `SpecPrinter` via `print_xlsx` method
+- Optional `output` parameter in `SpecPrinter` for writing to files
+- Optional `column_width` parameter in `print_table` and `print_xlsx`
+- `--print-mode` option in `modattributes` CLI for CSV and OOXML output
+- `--output` option in `modattributes` CLI for directing output to files
+
+### Changed
+
+- Switch PyPI version badge in `README` from `badge.fury.io` to `shields.io` for faster updates
+- Update modattributes CLI example for CSV and XLSX output
+- Improved nesting level color schemes for consistency and better contrast and readability.
+
+### Fixed
+
+- Correct handling of `include_table` names in `DOMTableSpecParser`
+- Correct handling of empty node attributes in `SpecPrinter`
+
 ## [0.2.3] - 2025-09-29
 
 ### Fixed

{dcmspec-0.2.3 → dcmspec-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcmspec
-Version: 0.2.3
+Version: 0.3.0
 Summary: Toolkit for extracting, parsing, and processing DICOM specifications.
 License: Apache-2.0
 License-File: LICENSE
@@ -25,8 +25,10 @@ Provides-Extra: pdf
 Requires-Dist: anytree (>=2.13.0,<3.0.0)
 Requires-Dist: bs4 (>=0.0.2,<0.0.3)
 Requires-Dist: camelot-py (>=1.0.0,<2.0.0) ; extra == "pdf"
+Requires-Dist: html2text (>=2025.4.15,<2026.0.0)
 Requires-Dist: lxml (>=5.4.0,<6.0.0)
 Requires-Dist: opencv-python-headless (>=4.12.0.88,<5.0.0) ; extra == "pdf"
+Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0) ; extra == "pdf"
 Requires-Dist: pandas (>=2.3.1,<3.0.0) ; extra == "pdf"
 Requires-Dist: pdfplumber (>=0.11.7,<0.12.0) ; extra == "pdf"
@@ -43,9 +45,9 @@ Project-URL: Source, https://github.com/dwikler/dcmspec
 Description-Content-Type: text/markdown
 
 [![tests](https://github.com/dwikler/dcmspec/actions/workflows/test.yml/badge.svg)](https://github.com/dwikler/dcmspec/actions/workflows/test.yml)
-[![PyPI version](https://badge.fury.io/py/dcmspec.svg)](https://badge.fury.io/py/dcmspec)
+[![PyPI version](https://img.shields.io/pypi/v/dcmspec.svg)](https://pypi.org/project/dcmspec/)
 [![Python versions](https://img.shields.io/pypi/pyversions/dcmspec.svg)](https://pypi.org/project/dcmspec/)
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17233195.svg)](https://doi.org/10.5281/zenodo.17233195)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17742287.svg)](https://doi.org/10.5281/zenodo.17742287)
 
 # dcmspec
 

{dcmspec-0.2.3 → dcmspec-0.3.0}/README.md

@@ -1,7 +1,7 @@
 [![tests](https://github.com/dwikler/dcmspec/actions/workflows/test.yml/badge.svg)](https://github.com/dwikler/dcmspec/actions/workflows/test.yml)
-[![PyPI version](https://badge.fury.io/py/dcmspec.svg)](https://badge.fury.io/py/dcmspec)
+[![PyPI version](https://img.shields.io/pypi/v/dcmspec.svg)](https://pypi.org/project/dcmspec/)
 [![Python versions](https://img.shields.io/pypi/pyversions/dcmspec.svg)](https://pypi.org/project/dcmspec/)
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17233195.svg)](https://doi.org/10.5281/zenodo.17233195)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17742287.svg)](https://doi.org/10.5281/zenodo.17742287)
 
 # dcmspec
 

{dcmspec-0.2.3 → dcmspec-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dcmspec"
-version = "0.2.3"
+version = "0.3.0"
 description = "Toolkit for extracting, parsing, and processing DICOM specifications."
 authors = [{ name = "David Wikler", email = "david.wikler@ulb.be" }]
 license = { text = "Apache-2.0" }
@@ -29,6 +29,8 @@ dependencies = [
     "requests (>=2.32.3,<3.0.0)",
     "lxml (>=5.4.0,<6.0.0)",
     "rich (>=14.0.0,<15.0.0)",
+    "html2text (>=2025.4.15,<2026.0.0)",
+    "openpyxl (>=3.1.5,<4.0.0)",
 ]
 
 [project.urls]

{dcmspec-0.2.3 → dcmspec-0.3.0}/src/dcmspec/apps/cli/iodattributes.py

@@ -58,12 +58,25 @@ def main():
     parser.add_argument("--config", help="Path to the configuration file")
     parser.add_argument(
         "--print-mode", 
-        choices=["table", "tree", "none"],
+        choices=["table", "tree", "csv", "xlsx", "none"],
         default="table",
-        help="Print as 'table' (default), 'tree', or 'none' to skip printing"
+        help="Print as 'table' (default), 'tree', 'csv', 'xlsx' (requires --output), or 'none' to skip printing"
+    )
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="Disable colorized output (default: color enabled for terminal, disabled for file output)"
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        help="Path to output file. If not specified (and not xlsx), prints to stdout."
     )
     args = parser.parse_args()
 
+    if args.print_mode == "xlsx" and not args.output:
+        parser.error("--output is required when --print-mode xlsx")
+
     cache_file_name = "Part3.xhtml"
     model_file_name = f"Part3_{args.table}_expanded.json"
     table_id = args.table 
@@ -114,11 +127,21 @@ def main():
     )
 
     # Print the model
-    printer = IODSpecPrinter(model)
+    printer = IODSpecPrinter(model, output=getattr(args, "output", None))
+
+    # Only disable color if --no-color is set; SpecPrinter disables color for file outputs automatically
+    use_color = not args.no_color
+
     if args.print_mode == "tree":
-        printer.print_tree(colorize=True)
+        printer.print_tree(
+            attr_names=["elem_tag", "elem_type", "elem_name"], attr_widths=[11, 2, 100], colorize=use_color
+            )
     elif args.print_mode == "table":
-        printer.print_table(colorize=True)
+        printer.print_table(colorize=use_color, column_widths=[30, 11, 4, 60])
+    elif args.print_mode == "csv":
+        printer.print_csv(colorize=use_color)
+    elif args.print_mode == "xlsx":
+        printer.print_xlsx(column_widths=[60, 16, 10, 100], colorize=use_color)
     # else: do not print anything if print_mode == "none"
 
 if __name__ == "__main__":

{dcmspec-0.2.3 → dcmspec-0.3.0}/src/dcmspec/apps/cli/modattributes.py

@@ -4,7 +4,7 @@ Features:
 - Download and parse DICOM Module Attributes tables from Part 3 of the DICOM standard.
 - Optionally merge additional information (VR, VM, Keyword, Status) from Part 6.
 - Cache the resulting model as a JSON file for future runs and as a structured representation of the standard.
-- Print the resulting model as a table or tree.
+- Print the resulting model as a table, tree, csv, or xlsx.
 - Supports caching, configuration files, and command-line options for flexible workflows.
 
 Usage:
@@ -113,12 +113,12 @@ def main():
 
     The tool parses the specified Module Attributes table to extract all attributes, tags, types,
     and descriptions for the module. Optionally, it can merge in VR, VM, Keyword, or Status information
-    from Part 6. The output can be printed as a table or tree.
+    from Part 6. The output can be printed as a table, tree, csv, or xlsx (xlsx requires --output).
 
     The resulting model is cached as a JSON file. The primary purpose of this cache file is to provide
-    a structured, machine-readable representation of the module's attributes, which can be used for further processing
-    or integration in other tools. As a secondary benefit, the cache file is also used to speed up subsequent runs
-    of the CLI scripts.
+    a structured, machine-readable representation of the module's attributes, which can be used for
+    further processing or integration in other tools. As a secondary benefit, the cache file is also used
+    to speed up subsequent runs of the CLI scripts.
 
     Usage:
         poetry run python -m src.dcmspec.apps.cli.modattributes <table_id> [options]
@@ -129,14 +129,17 @@ def main():
         --include-depth (int): Depth to which included tables should be parsed (default: unlimited).
         --force-parse: Force reparsing of the DOM and regeneration of the JSON model.
         --force-download: Force download of the input file and regeneration of the model.
-        --print-mode (str): Print as 'table' (default), 'tree', or 'none' to skip printing.
+        --print-mode (str): Print as 'table' (default), 'tree', 'csv', 'xlsx', or 'none' to skip printing.
+                            'xlsx' requires --output.
+        --output (str): Path to output file. If not specified (and not xlsx), prints to stdout.
         --add-part6 (list): Specification(s) to merge from Part 6 (e.g., --add-part6 VR VM).
         --force-update: Force update of the specifications merged from part 6, even if cached.
         -d, --debug: Enable debug logging to the console.
         -v, --verbose: Enable verbose (info-level) logging to the console.
 
-    Example:
+    Examples:
         poetry run python -m src.dcmspec.apps.cli.modattributes table_C.7-1 --add-part6 VR VM
+        poetry run python -m src.dcmspec.apps.cli.modattributes table_C.7-1 --print-mode xlsx --output module.xlsx
 
     """
     # Parse command-line arguments
@@ -164,9 +167,19 @@ def main():
     )
     parser.add_argument(
         "--print-mode", 
-        choices=["table", "tree", "none"],
+        choices=["table", "tree", "csv", "xlsx", "none"],
         default="table",
-        help="Print as 'table' (default), 'tree', or 'none' to skip printing"
+        help="Print as 'table' (default), 'tree', 'csv', 'xlsx' (requires --output), or 'none' to skip printing"
+    )
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="Disable colorized output (default: color enabled for terminal, disabled for file output)"
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        help="Path to output file. If not specified (and not xlsx), prints to stdout."
     )
     parser.add_argument(
         "--add-part6",
@@ -189,9 +202,12 @@ def main():
         action="store_true",
         help="Enable verbose (info-level) logging to the console"
     )
-    
+
     args = parser.parse_args()
 
+    if args.print_mode == "xlsx" and not args.output:
+        parser.error("--output is required when --print-mode xlsx")
+
     # Set up logger
     logger = logging.getLogger("modattributes")
     handler = logging.StreamHandler()
@@ -254,11 +270,18 @@ def main():
         model = module_model
 
     logger.debug("Model ready for printing/output")
-    printer = SpecPrinter(model)
+    printer = SpecPrinter(model, output=args.output)
+
+    # Only disable color if --no-color is set; SpecPrinter disables color for file outputs automatically
+    use_color = not args.no_color
     if args.print_mode == "tree":
-        printer.print_tree(colorize=True)
+        printer.print_tree(attr_names=["elem_tag", "elem_type", "elem_name"], attr_widths=[11, 2, 100], colorize=use_color)
     elif args.print_mode == "table":
-        printer.print_table(colorize=True)
+        printer.print_table(colorize=use_color, column_widths=[30, 11, 4, 60])
+    elif args.print_mode == "csv":
+        printer.print_csv(colorize=use_color)
+    elif args.print_mode == "xlsx":
+        printer.print_xlsx(column_widths=[60, 16, 10, 100], colorize=use_color)
     # else: do not print anything if print_mode == "none"
 
 if __name__ == "__main__":

{dcmspec-0.2.3 → dcmspec-0.3.0}/src/dcmspec/dom_table_spec_parser.py

@@ -3,15 +3,18 @@
 Provides the DOMSpecParser class for parsing DICOM specification tables from XHTML documents,
 converting them into structured in-memory representations using anytree.
 """
+
 from contextlib import contextmanager
 import re
 import unicodedata
+from typing import Any, Dict, Optional, Union
+
 from unidecode import unidecode
 from anytree import Node
 from bs4 import BeautifulSoup, Tag
-from typing import Any, Dict, Optional, Union
-from dcmspec.spec_parser import SpecParser
+import html2text
 
+from dcmspec.spec_parser import SpecParser
 from dcmspec.dom_utils import DOMUtils
 from dcmspec.progress import Progress, ProgressObserver, ProgressStatus, calculate_percent
 
@@ -506,6 +509,7 @@ class DOMTableSpecParser(SpecParser):
 
         return logical_cells, logical_col_idx, physical_col_idx
 
+
     def _extract_cell_value(
         self,
         cell: Tag,
@@ -518,11 +522,27 @@ class DOMTableSpecParser(SpecParser):
             if unformatted_list and logical_col_idx < len(unformatted_list)
             else True
         )
-        if use_unformatted:
-            return self._clean_extracted_text(cell.get_text(separator="\n", strip=True))
-        else:
+
+        # Guard clause: if formatted HTML is required, return content as-is
+        if not use_unformatted:
+            # Keep original HTML content
             return self._clean_extracted_text(cell.decode_contents())
 
+        # Use html2text for better readability of unformatted text extraction
+        converter = self._create_html2text_converter()
+        raw_text = converter.handle(str(cell))
+        return self._clean_extracted_text(raw_text)
+
+
+    def _create_html2text_converter(self) -> html2text.HTML2Text:
+        """Create and configure an html2text converter for consistent text extraction."""
+        converter = html2text.HTML2Text()
+        converter.ignore_links = True       # Remove URLs
+        converter.ignore_images = True      # Remove image references
+        converter.ignore_emphasis = True    # Remove Markdown emphasis
+        converter.body_width = 0            # Disable word wrapping
+        return converter
+
     def _update_rowspan_trackers(
         self,
         physical_col_idx: int,
@@ -781,15 +801,7 @@ class DOMTableSpecParser(SpecParser):
         return header
 
     def _clean_extracted_text(self, text: str) -> str:
-        """Clean extracted text using Unicode normalization and regex.
-
-        Args:
-            text (str): The text to be cleaned.
-
-        Returns:
-            str: The cleaned text.
-
-        """
+        """Clean extracted text using Unicode normalization and regex."""
         # Normalize unicode characters to compatibility form
         cleaned = unicodedata.normalize('NFKC', text)
 
@@ -805,27 +817,48 @@ class DOMTableSpecParser(SpecParser):
         # Remove stray  character
         cleaned = cleaned.replace('\u00c2', '')
 
+        # Collapse multiple newlines (including those separated by spaces/tabs) into a single newline
+        cleaned = re.sub(r'(\n\s*){2,}', '\n', cleaned)
+
         return cleaned.strip()
 
-    def _sanitize_string(self, input_string: str) -> str:
-        """Sanitize string to use it as a node attribute name.
+    @staticmethod
+    def _sanitize_string(input_string: str) -> str:
+        r"""Sanitize a string to make it safe for use as a node attribute name.
 
-        - Convert non-ASCII characters to closest ASCII equivalents
-        - Replace space characters and slashes with underscores
-        - Replace parentheses characters with dashes
+        Transformations applied:
+        - Convert to lowercase.
+        - Transliterate non-ASCII characters to ASCII.
+        - Replace spaces, slashes, newlines, and dots with underscores ("_").
+        - Replace parentheses with dashes ("-").
+        - Remove all characters except letters, digits, underscores, and dashes.
+        - Collapse multiple consecutive underscores into a single underscore.
+        - Remove leading and trailing underscores for cleanliness.
+        - Return a default name if the result is empty after sanitization.
 
         Args:
-            input_string (str): The string to be sanitized.
+            input_string (str): The original string to sanitize.
 
         Returns:
-            str: The sanitized string.
+            str: A sanitized version of the input string, suitable for use as an identifier.
+                    or "unnamed_node" if sanitization results in an empty string.
+
+        Example:
+            >>> DOMTableSpecParser._sanitize_string(
+            '>>Include\\nTable C.36.2.2.19-1 "RT Beam Limiting Device Definition Macro Attributes"\\n.'
+            )
+            'include_table_c_36_2_2_19-1_rt_beam_limiting_device_definition_macro_attributes'
+            >>> DOMTableSpecParser._sanitize_string('...')
+            'unnamed_node'
 
         """
-        # Normalize the string to NFC form and transliterate to ASCII
         normalized_str = unidecode(input_string.lower())
-        # Replace spaces and slashes with underscores, parentheses with dashes, and single quotes with underscores
-        return re.sub(
-            r"[ /\-()']",
-            lambda match: "-" if match.group(0) in "()" else "_",
-            normalized_str,
-        )
+        sanitized = re.sub(r"[ /\n\\.]", "_", normalized_str)  # spaces, slashes, newlines, dots → _
+        sanitized = re.sub(r"[()]", "-", sanitized)            # parentheses → -
+        sanitized = re.sub(r"[^a-z0-9_-]", "", sanitized)      # remove other chars
+        sanitized = re.sub(r"_+", "_", sanitized)              # collapse multiple underscores
+        sanitized = sanitized.strip("_")                       # remove leading/trailing underscores
+
+        # Fallback to default name if sanitization resulted in empty string
+        return sanitized or "unnamed_node"
+

dcmspec-0.3.0/src/dcmspec/iod_spec_printer.py

@@ -0,0 +1,254 @@
+"""Printer class for DICOM IOD specification model in dcmspec.
+
+Provides the SpecPrinter class for printing DICOM IOD specification models (SpecModel)
+to standard output, either as a hierarchical tree or as a flat table, using rich formatting.
+"""
+import re
+from typing import Generator, List, Optional, Tuple
+
+from anytree import PreOrderIter
+from anytree import RenderTree
+from rich.table import Table, box
+from rich.text import Text
+
+from dcmspec.spec_printer import LEVEL_COLORS, SPECIAL_COLORS, SpecPrinter
+
+class IODSpecPrinter(SpecPrinter):
+    """Printer for DICOM IOD specification models with mixed node types.
+
+    Overrides print_table to display IOD Modules nodes as a one-cell title row (spanning all columns)
+    The table columns are those of the Module Attributes nodes.
+    """
+
+    def print_tree(
+        self,
+        attr_names=None,
+        attr_widths=None,
+        colorize: bool = False,
+    ) -> None:
+        """Print the specification model as a hierarchical tree to the console or file.
+
+        Args:
+            attr_names (Optional[Union[str, list[str]]]): Attribute name(s) to display for each node.
+            attr_widths (Optional[list[int]]): List of widths for each attribute in attr_names.
+            colorize (bool): Whether to colorize the output by node depth. Ignored when writing to file.
+
+        Returns:
+            None
+
+        """
+        if self.output:
+            colorize = False
+
+        for pre, fill, node in RenderTree(self.model.content):
+            if node.name == "content":
+                continue
+
+            if hasattr(node, "module"):
+                # Module title row: always use title color if colorize
+                iod_title = getattr(node, "module", getattr(node, "name", ""))
+                iod_usage = getattr(node, "usage", "")
+                iod_title_text = f"{iod_title} Module ({iod_usage})" if iod_usage else iod_title
+                node_text = Text(iod_title_text, style=SPECIAL_COLORS["title"] if colorize else None)
+            else:
+                attr_text = self._format_tree_row(node, attr_names, attr_widths)
+                row_style = self._get_tree_row_style(node, colorize)
+                node_text = Text(attr_text, style=row_style)
+            self.console.print(Text(pre) + node_text)
+
+        if self.console.file:
+            self.console.file.flush()
+
+    def print_table(self, column_widths=None, colorize: bool = False) -> None:
+        """Print the specification model as a flat table with module title rows.
+
+        Args:
+            column_widths (Optional[List[int]]): List of widths for each column's content.
+                These widths do not include borders or padding added by Rich.
+                If provided, each column will be set to the specified content width.
+                If None, all columns default to width 20.            
+                If the list is shorter than the number of columns, remaining columns default to width 20.
+
+            colorize (bool): Whether to colorize the output by node depth.
+
+        """
+        # Disable colorization if writing to file
+        if self.output:
+            colorize = False
+
+        table = Table(show_header=True, header_style="bold magenta", show_lines=True, box=box.ASCII_DOUBLE_HEAD)
+
+        attr_headers = list(self.model.metadata.header)
+        for i, header in enumerate(attr_headers):
+            width = column_widths[i] if column_widths and i < len(column_widths) else 20
+            table.add_column(header, width=width)
+
+        for row, row_style, _ in self._iterate_rows_iod(colorize):
+            table.add_row(*row, style=row_style)
+
+        self.console.print(table)
+
+        if self.console.file:
+            self.console.file.flush()  # Ensure data is written immediately
+
+    def print_csv(self, colorize: bool = False) -> None:
+        """Print the specification model as CSV to the console or file, with module title rows.
+
+        Traverses the content tree and prints each node's attributes in CSV format,
+        with column headers from the metadata node. Optionally colorizes rows.
+
+        Args:
+            colorize (bool): Whether to colorize the output by node depth. Ignored when writing to file.
+
+        Returns:
+            None
+
+        """
+        # Disable colorization if writing to file
+        if self.output:
+            colorize = False
+
+        # Print CSV header
+        header_row = ",".join(f'"{h}"' for h in self.model.metadata.header)
+        self.console.print(header_row)
+
+        # Add data rows (including module title rows)
+        for row, row_style, _ in self._iterate_rows_iod(colorize):
+            # Escape quotes inside each field by doubling them, then wrap in quotes
+            csv_row = ",".join(
+                f'"{("" if cell is None else str(cell)).replace(chr(34), chr(34) + chr(34))}"'
+                for cell in row
+            )
+            self.console.print(csv_row, style=row_style)
+
+        if self.console.file:
+            self.console.file.flush()
+
+    def print_xlsx(self, column_widths: Optional[list] = None, colorize: bool = False) -> None:
+        """Print the specification model to an OOXML format Excel (.xlsx) file.
+
+        Traverses the content tree and writes each node's attributes into an Excel sheet,
+        with column headers from the metadata node. Handles newlines and applies background
+        colorization using the same color scheme as console output (LEVEL_COLORS and SPECIAL_COLORS).
+        Each module in the IOD is written to a separate worksheet, named after the module, and attribute rows
+        for each module are written to their corresponding worksheet.
+
+        Args:
+            column_widths (list): Optional list of column widths for Excel columns.
+            colorize (bool): Whether to apply color styling to cell backgrounds.
+
+        Returns:
+            None
+
+        """
+        if not self.output:
+            raise ValueError("Output file path must be specified when constructing SpecPrinter for print_xlsx).")
+
+        header_style, data_style = self._create_styles()
+        wb = self._setup_workbook()
+        ws = None
+        current_module = None
+        rows_for_ws = []
+
+        def flush_ws():
+            if ws and rows_for_ws:
+                self._write_data_rows(ws, rows_for_ws, data_style, colorize)
+                rows_for_ws.clear()
+
+        used_names = set()
+        for row, row_style, module_name in self._iterate_rows_iod(colorize=colorize, include_module_titles=False):
+            if module_name != current_module:
+                flush_ws()
+                
+                ws = self._setup_worksheet(wb, self._sanitize_sheet_name(module_name, used_names))
+                self._write_headers(ws, self.model.metadata.header, header_style)
+                if column_widths:
+                    self._set_column_widths(ws, column_widths)
+                current_module = module_name
+            rows_for_ws.append((row, row_style))
+
+        flush_ws()
+        wb.save(self.output)
+        
+    @staticmethod
+    def _sanitize_sheet_name(name: str, used_names: set = None) -> str:
+        """Sanitize and ensure uniqueness of a worksheet name for Excel compatibility.
+
+        This function replaces invalid characters with underscores and trims the name to 31 characters.
+        If the name is empty or None, it uses 'Sheet'. If the name is already used, it appends a numeric
+        suffix to ensure uniqueness within the workbook.
+
+        Args:
+            name (str): The proposed worksheet name.
+            used_names (set, optional): Set of already used worksheet names.
+
+        Returns:
+            str: A sanitized and unique worksheet name suitable for Excel.
+
+        """
+        orig_name = re.sub(r'[\[\]\*:/\\\?]', '_', name) if name else "Sheet"
+        orig_name = orig_name[:31] if orig_name else "Sheet"
+        if used_names is None:
+            used_names = set()
+        sheet_name = orig_name
+        i = 1
+        while sheet_name in used_names or not sheet_name:
+            suffix = f"_{i}"
+            sheet_name = (
+                (orig_name[:31-len(suffix)] + suffix) 
+                if len(orig_name) + len(suffix) > 31 
+                else orig_name + suffix
+            )
+            i += 1
+        used_names.add(sheet_name)
+        return sheet_name
+
+    def _iterate_rows_iod(
+            self, 
+            colorize: bool = False, 
+            include_module_titles: bool = True
+            ) -> Generator[Tuple[List[str], Optional[str], Optional[str]], None, None]:
+        """Generate rows for IODSpecPrinter with module title rows, module grouping, and optional styling.
+
+        Iterates through the model content tree and yields tuples representing each row to be printed.
+        For module nodes, optionnaly yields a module title row with the module name and styling.
+        For attribute rows, yields the attribute values, row style, and the current module name for grouping.
+
+        Args:
+            colorize (bool): Whether to apply color styling to rows.
+            include_module_titles (bool): Whether to yield module title rows (True for table/csv, False for xlsx).
+
+        Yields:
+            tuple: (row_data, row_style, module_name) where row_data is a list of cell values,
+                    row_style is an RGB color string (e.g., "rgb(255,255,0)") from LEVEL_COLORS or SPECIAL_COLORS,
+                    or None if not colorized, and module_name is the current module for grouping.
+
+        """      
+        attr_headers = list(self.model.metadata.header)
+        current_module = None
+        for node in PreOrderIter(self.model.content):
+            if node.name == "content":
+                continue
+            if hasattr(node, "module"):
+                current_module = getattr(node, "module", None)
+                if include_module_titles:
+                    iod_title = getattr(node, "module", getattr(node, "name", ""))
+                    iod_usage = getattr(node, "usage", "")
+                    iod_title_text = f"{iod_title} Module ({iod_usage})" if iod_usage else iod_title
+                    row_style = SPECIAL_COLORS["title"] if colorize else None
+                    yield [iod_title_text] + [""] * (len(attr_headers) - 1), row_style, current_module or "Other"
+                # else: skip module title rows for xlsx
+            else:
+                # Use the most recent current_ie for all attribute rows
+                row = [getattr(node, attr, "") for attr in self.model.metadata.column_to_attr.values()]
+                row_style = None
+                if colorize:
+                    if self.model._is_include(node):
+                        row_style = SPECIAL_COLORS["include"]
+                    elif self.model._is_title(node):
+                        row_style = SPECIAL_COLORS["title"]
+                    else:
+                        # use (node.depth - 2) since attributes are children of module nodes,
+                        # which are themselves children of content (root) node
+                        row_style = LEVEL_COLORS[(node.depth - 2) % len(LEVEL_COLORS)]
+                yield row, row_style, current_module or "Other"