rolfedh-doc-utils 0.1.30__py3-none-any.whl → 0.1.32__py3-none-any.whl

callout_lib/converter_bullets.py

@@ -16,7 +16,7 @@ class BulletListConverter:
     USER_VALUE_PATTERN = re.compile(r'(?<!<)<([a-zA-Z][^>]*)>')
 
     @staticmethod
-    def convert(callout_groups: List[CalloutGroup], explanations: Dict[int, Callout]) -> List[str]:
+    def convert(callout_groups: List[CalloutGroup], explanations: Dict[int, Callout], table_title: str = "") -> List[str]:
         """
         Create bulleted list from callout groups and explanations.
 
@@ -33,12 +33,20 @@ class BulletListConverter:
 
         Args:
             callout_groups: List of CalloutGroup objects from code block
+            table_title: Optional table title (e.g., ".Descriptions of delete event")
+                        Will be converted to lead-in sentence
             explanations: Dict mapping callout numbers to Callout objects
 
         Returns:
             List of strings representing the bulleted list
         """
-        lines = ['']  # Start with blank line before list
+        # Convert table title to lead-in sentence if present
+        if table_title:
+            # Remove leading dot and trailing period if present
+            title_text = table_title.lstrip('.').rstrip('.')
+            lines = [f'\n{title_text}:']  # Use colon for bulleted list lead-in
+        else:
+            lines = ['']  # Start with blank line before list
 
         # Process each group (which may contain one or more callouts)
         for group in callout_groups:

callout_lib/converter_deflist.py

@@ -16,7 +16,7 @@ class DefListConverter:
     USER_VALUE_PATTERN = re.compile(r'(?<!<)<([a-zA-Z][^>]*)>')
 
     @staticmethod
-    def convert(callout_groups: List[CalloutGroup], explanations: Dict[int, Callout]) -> List[str]:
+    def convert(callout_groups: List[CalloutGroup], explanations: Dict[int, Callout], table_title: str = "") -> List[str]:
         """
         Create definition list from callout groups and explanations.
 
@@ -29,11 +29,19 @@ class DefListConverter:
         Args:
             callout_groups: List of CalloutGroup objects from code block
             explanations: Dict mapping callout numbers to Callout objects
+            table_title: Optional table title (e.g., ".Descriptions of delete event")
+                        Will be converted to lead-in sentence (e.g., "Descriptions of delete event, where:")
 
         Returns:
             List of strings representing the definition list
         """
-        lines = ['\nwhere:']
+        # Convert table title to lead-in sentence if present
+        if table_title:
+            # Remove leading dot and trailing period if present
+            title_text = table_title.lstrip('.').rstrip('.')
+            lines = [f'\n{title_text}, where:']
+        else:
+            lines = ['\nwhere:']
 
         # Process each group (which may contain one or more callouts)
         for group in callout_groups:

callout_lib/detector.py

@@ -60,6 +60,8 @@ class CalloutDetector:
     def __init__(self):
         """Initialize detector with table parser."""
         self.table_parser = TableParser()
+        self.last_table_title = ""  # Track title from most recent table extraction
+        self.last_table = None  # Track last table found for validation diagnostics
 
     def find_code_blocks(self, lines: List[str]) -> List[CodeBlock]:
         """Find all code blocks in the document."""
@@ -181,6 +183,10 @@ class CalloutDetector:
 
     def _extract_from_table(self, table) -> Tuple[Dict[int, Callout], int]:
         """Extract callout explanations from a table format."""
+        # Store table for use by converters and validation
+        self.last_table = table
+        self.last_table_title = table.title if hasattr(table, 'title') else ""
+
         explanations = {}
         table_data = self.table_parser.extract_callout_explanations_from_table(table)
 
@@ -215,6 +221,10 @@ class CalloutDetector:
         Extract callout explanations from a 3-column table format.
         Format: Item (number) | Value | Description
         """
+        # Store table for use by converters and validation
+        self.last_table = table
+        self.last_table_title = table.title if hasattr(table, 'title') else ""
+
         explanations = {}
         table_data = self.table_parser.extract_3column_callout_explanations(table)
 
@@ -256,6 +266,10 @@ class CalloutDetector:
 
     def _extract_from_list(self, lines: List[str], start_line: int) -> Tuple[Dict[int, Callout], int]:
         """Extract callout explanations from list format (<1> text)."""
+        # Clear table data since list format doesn't have tables
+        self.last_table = None
+        self.last_table_title = ""
+
         explanations = {}
         i = start_line + 1  # Start after the closing delimiter
 
@@ -310,17 +324,33 @@ class CalloutDetector:
             cleaned.append(self.CALLOUT_WITH_COMMENT.sub('', line).rstrip())
         return cleaned
 
-    def validate_callouts(self, callout_groups: List[CalloutGroup], explanations: Dict[int, Callout]) -> Tuple[bool, set, set]:
+    def validate_callouts(self, callout_groups: List[CalloutGroup], explanations: Dict[int, Callout]) -> Tuple[bool, List[int], List[int]]:
         """
         Validate that callout numbers in code match explanation numbers.
-        Returns tuple of (is_valid, code_nums, explanation_nums).
+        Returns tuple of (is_valid, code_nums_list, explanation_nums_list).
+
+        Returns:
+            - is_valid: True if unique callout numbers match
+            - code_nums_list: List of callout numbers from code (unique, sorted)
+            - explanation_nums_list: List of callout numbers from explanations
+              (preserves duplicates if from table, sorted)
         """
-        # Extract all callout numbers from groups
-        code_nums = set()
+        # Extract unique callout numbers from code groups
+        code_nums_set = set()
         for group in callout_groups:
-            code_nums.update(group.callout_numbers)
+            code_nums_set.update(group.callout_numbers)
+
+        # Get explanation numbers, preserving duplicates if from a table
+        if self.last_table:
+            # Use table parser to get raw callout numbers (with duplicates)
+            explanation_nums_list = self.table_parser.get_table_callout_numbers(self.last_table)
+        else:
+            # List format: dict keys are already unique
+            explanation_nums_list = list(explanations.keys())
+
+        explanation_nums_set = set(explanation_nums_list)
 
-        explanation_nums = set(explanations.keys())
+        # Validation compares unique numbers only
+        is_valid = code_nums_set == explanation_nums_set
 
-        is_valid = code_nums == explanation_nums
-        return is_valid, code_nums, explanation_nums
+        return is_valid, sorted(code_nums_set), sorted(explanation_nums_list)

callout_lib/table_parser.py

@@ -38,6 +38,7 @@ class AsciiDocTable:
     end_line: int
     attributes: str  # Table attributes like [cols="1,3"]
     rows: List[TableRow]
+    title: str = ""  # Block title like ".Table description"
 
 
 class TableParser:
@@ -47,8 +48,8 @@ class TableParser:
     TABLE_START = re.compile(r'^\[.*?\]$')
     TABLE_DELIMITER = re.compile(r'^\|===\s*$')
 
-    # Pattern for table cell separator
-    CELL_SEPARATOR = re.compile(r'^\|')
+    # Pattern for table cell separator (| or cell type specifier like a|, s|, etc.)
+    CELL_SEPARATOR = re.compile(r'^(\||[ashdmev]\|)')
 
     # Pattern for conditional directives
     IFDEF_PATTERN = re.compile(r'^(ifdef::|ifndef::).+\[\]\s*$')
@@ -56,6 +57,26 @@ class TableParser:
 
     # Pattern for callout number (used for callout table detection)
     CALLOUT_NUMBER = re.compile(r'^<(\d+)>\s*$')
+    PLAIN_NUMBER = re.compile(r'^(\d+)\s*$')
+
+    def _is_callout_or_number(self, text: str) -> tuple[bool, int]:
+        """
+        Check if text is a callout number (<1>) or plain number (1).
+        Returns (is_match, number) or (False, 0) if no match.
+        """
+        text = text.strip()
+
+        # Try callout format first: <1>
+        match = self.CALLOUT_NUMBER.match(text)
+        if match:
+            return (True, int(match.group(1)))
+
+        # Try plain number format: 1
+        match = self.PLAIN_NUMBER.match(text)
+        if match:
+            return (True, int(match.group(1)))
+
+        return (False, 0)
 
     def _finalize_row_if_complete(self, current_row_cells, conditionals_before_row,
                                    conditionals_after_row, expected_columns, rows):
@@ -103,16 +124,27 @@ class TableParser:
         while i < len(lines):
             # Look for table delimiter
             if self.TABLE_DELIMITER.match(lines[i]):
-                # Check if there are attributes on the line before
+                # Check for attributes and title before the table
                 attributes = ""
+                title = ""
                 start_line = i
 
+                # Check line before delimiter for attributes [cols="..."]
                 if i > 0 and self.TABLE_START.match(lines[i - 1]):
                     attributes = lines[i - 1]
                     start_line = i - 1
 
+                    # Check line before attributes for title .Title
+                    if i > 1 and lines[i - 2].strip().startswith('.') and not lines[i - 2].strip().startswith('..'):
+                        title = lines[i - 2].strip()
+                        start_line = i - 2
+                elif i > 0 and lines[i - 1].strip().startswith('.') and not lines[i - 1].strip().startswith('..'):
+                    # Title directly before delimiter (no attributes)
+                    title = lines[i - 1].strip()
+                    start_line = i - 1
+
                 # Parse table content
-                table = self._parse_table(lines, start_line, i)
+                table = self._parse_table(lines, start_line, i, title)
                 if table:
                     tables.append(table)
                     i = table.end_line + 1
@@ -121,11 +153,13 @@ class TableParser:
 
         return tables
 
-    def _parse_table(self, lines: List[str], start_line: int, delimiter_line: int) -> Optional[AsciiDocTable]:
+    def _parse_table(self, lines: List[str], start_line: int, delimiter_line: int, title: str = "") -> Optional[AsciiDocTable]:
         """
         Parse a single table starting at the delimiter.
 
         AsciiDoc table format:
+        .Optional title
+        [optional attributes]
         |===
         |Cell1
         |Cell2
@@ -137,7 +171,15 @@ class TableParser:
         # Get attributes and parse column count
         attributes = ""
         if start_line < delimiter_line:
-            attributes = lines[start_line]
+            # Check if start line is title or attributes
+            start_content = lines[start_line].strip()
+            if start_content.startswith('.') and not start_content.startswith('..'):
+                # Start line is title, attributes might be on next line
+                if start_line + 1 < delimiter_line:
+                    attributes = lines[start_line + 1]
+            else:
+                # Start line is attributes
+                attributes = lines[start_line]
 
         expected_columns = self._parse_column_count(attributes)
 
@@ -170,16 +212,13 @@ class TableParser:
                         conditionals_after=conditionals_after_row.copy()
                     ))
 
-                # Get attributes if present
-                attributes = ""
-                if start_line < delimiter_line:
-                    attributes = lines[start_line]
-
+                # Get attributes if present (already extracted above)
                 return AsciiDocTable(
                     start_line=start_line,
                     end_line=i,
                     attributes=attributes,
-                    rows=rows
+                    rows=rows,
+                    title=title
                 )
 
             # Check for conditional directives
@@ -230,19 +269,15 @@ class TableParser:
                 i += 1
                 continue
 
-            # Check for cell separator (|)
+            # Check for cell separator (|) or cell type specifier (a|, s|, etc.)
             if self.CELL_SEPARATOR.match(line):
-                # Check if this is a cell type specifier on its own line (e.g., "a|" or "s|")
-                cell_content = line[1:].strip()  # Remove leading | and whitespace
-
-                # If line is just "a|", "s|", "h|", etc. (cell type specifier alone)
-                if len(cell_content) == 2 and cell_content[0] in 'ashdmev' and cell_content[1] == '|':
-                    # This is a cell type specifier on its own line
-                    if cell_content[0] == 'a':
-                        in_asciidoc_cell = True
-                    # Don't create a cell yet - content comes on following lines
-                    i += 1
-                    continue
+                # Determine if line starts with | or with a cell type specifier
+                if line.startswith('|'):
+                    # Standard cell separator
+                    cell_content = line[1:]  # Remove leading |
+                else:
+                    # Cell type specifier without leading | (e.g., "a|text")
+                    cell_content = line
 
                 # Save previous cell if exists
                 if current_cell_lines:
@@ -260,16 +295,13 @@ class TableParser:
                             conditionals_after_row, expected_columns, rows
                         )
 
-                # Extract cell content from this line (text after |)
-                cell_content = line[1:]  # Remove leading |
-
-                # Check for inline cell type specifier (a|text, s|text, etc.)
-                # Cell type specifiers are single characters followed by |
-                if len(cell_content) > 0 and cell_content[0] in 'ashdmev' and len(cell_content) > 1 and cell_content[1] == '|':
+                # Check for cell type specifier (a|, s|, etc.)
+                # Type specifiers are single characters followed by |
+                if len(cell_content) > 1 and cell_content[0] in 'ashdmev' and cell_content[1] == '|':
                     # Track if this is an AsciiDoc cell (a|)
                     if cell_content[0] == 'a':
                         in_asciidoc_cell = True
-                    cell_content = cell_content[2:]  # Remove type specifier and second |
+                    cell_content = cell_content[2:]  # Remove type specifier and |
 
                 cell_content = cell_content.strip()
 
@@ -350,6 +382,8 @@ class TableParser:
         """
         Determine if a table is a callout explanation table.
         A callout table has two columns: callout number and explanation.
+        Accepts both callout format (<1>) and plain numbers (1).
+        Skips header rows if present.
         """
         if not table.rows:
             return False
@@ -358,15 +392,23 @@ class TableParser:
         if not all(len(row.cells) == 2 for row in table.rows):
             return False
 
-        # Check if first cell of each row is a callout number
-        for row in table.rows:
+        # Determine if there's a header row and skip it
+        has_header = self._has_header_row(table)
+        data_rows = table.rows[1:] if has_header else table.rows
+
+        if not data_rows:
+            return False
+
+        # Check if first cell of each data row is a callout number (either <1> or 1)
+        for row in data_rows:
             first_cell = row.cells[0]
             if not first_cell.content:
                 return False
 
-            # First line of first cell should be a callout number
+            # First line of first cell should be a callout number or plain number
             first_line = first_cell.content[0].strip()
-            if not self.CALLOUT_NUMBER.match(first_line):
+            is_match, _ = self._is_callout_or_number(first_line)
+            if not is_match:
                 return False
 
         return True
@@ -375,23 +417,36 @@ class TableParser:
         """
         Check if table has a header row.
         Common header patterns: "Item", "Value", "Description", "Column", etc.
+
+        A row is a header if:
+        - It does NOT start with a callout number (<1> or 1)
+        - It contains common header keywords in the cells
         """
         if not table.rows:
             return False
 
         first_row = table.rows[0]
-        if not first_row.cells:
+        if not first_row.cells or len(first_row.cells) < 2:
             return False
 
+        # If first cell is a callout number, this is NOT a header
+        first_cell = first_row.cells[0]
+        if first_cell.content:
+            first_cell_text = first_cell.content[0].strip()
+            is_callout, _ = self._is_callout_or_number(first_cell_text)
+            if is_callout:
+                return False
+
         # Collect text from all cells in first row
         header_text = ' '.join(
             cell.content[0] if cell.content else ''
             for cell in first_row.cells
         ).lower()
 
-        # Check for common header keywords
+        # Check for common header keywords (as whole words)
         header_keywords = ['item', 'description', 'value', 'column', 'parameter', 'field', 'name']
-        return any(keyword in header_text for keyword in header_keywords)
+        import re
+        return any(re.search(r'\b' + re.escape(keyword) + r'\b', header_text) for keyword in header_keywords)
 
     def is_3column_callout_table(self, table: AsciiDocTable) -> bool:
         """
@@ -417,19 +472,52 @@ class TableParser:
         if not all(len(row.cells) == 3 for row in data_rows):
             return False
 
-        # Check if first cell of each data row contains a plain number (1, 2, 3...)
+        # Check if first cell of each data row contains a callout or plain number (1, 2, 3... or <1>, <2>...)
         for row in data_rows:
             first_cell = row.cells[0]
             if not first_cell.content:
                 return False
 
-            # First line of first cell should be a number
+            # First line of first cell should be a callout number or plain number
             first_line = first_cell.content[0].strip()
-            if not first_line.isdigit():
+            is_match, _ = self._is_callout_or_number(first_line)
+            if not is_match:
                 return False
 
         return True
 
+    def get_table_callout_numbers(self, table: AsciiDocTable) -> List[int]:
+        """
+        Extract just the callout numbers from a table (in order, with duplicates).
+        Used for validation and diagnostics.
+
+        Returns:
+            List of callout numbers in the order they appear in the table.
+            Preserves duplicates to help identify table errors.
+        """
+        callout_numbers = []
+
+        # Determine if there's a header row and skip it
+        has_header = self._has_header_row(table)
+        data_rows = table.rows[1:] if has_header else table.rows
+
+        for row in data_rows:
+            # Handle both 2-column and 3-column tables
+            if len(row.cells) < 2:
+                continue
+
+            first_cell = row.cells[0]
+            if not first_cell.content:
+                continue
+
+            # Extract callout number (supports both <1> and 1 formats)
+            first_line = first_cell.content[0].strip()
+            is_match, callout_num = self._is_callout_or_number(first_line)
+            if is_match:
+                callout_numbers.append(callout_num)
+
+        return callout_numbers
+
     def extract_callout_explanations_from_table(self, table: AsciiDocTable) -> Dict[int, Tuple[List[str], List[str]]]:
         """
         Extract callout explanations from a table.
@@ -437,24 +525,32 @@ class TableParser:
 
         The conditionals list includes any ifdef/ifndef/endif statements that should
         be preserved when converting the table to other formats.
+
+        Accepts both callout format (<1>) and plain numbers (1).
+        Skips header rows if present.
+
+        Note: If table contains duplicate callout numbers, the last one wins.
+        Use get_table_callout_numbers() to detect duplicates.
         """
         explanations = {}
 
-        for row in table.rows:
+        # Determine if there's a header row and skip it
+        has_header = self._has_header_row(table)
+        data_rows = table.rows[1:] if has_header else table.rows
+
+        for row in data_rows:
             if len(row.cells) != 2:
                 continue
 
             callout_cell = row.cells[0]
             explanation_cell = row.cells[1]
 
-            # Extract callout number
+            # Extract callout number (supports both <1> and 1 formats)
             first_line = callout_cell.content[0].strip()
-            match = self.CALLOUT_NUMBER.match(first_line)
-            if not match:
+            is_match, callout_num = self._is_callout_or_number(first_line)
+            if not is_match:
                 continue
 
-            callout_num = int(match.group(1))
-
             # Collect explanation lines, preserving blank lines and conditionals inline
             # Blank lines will need to become continuation markers (+) in definition lists
             explanation_lines = []
@@ -478,12 +574,14 @@ class TableParser:
         Returns dict mapping callout number to tuple of (value_lines, description_lines, conditionals).
 
         Format: Item | Value | Description
-        - Item: Number (1, 2, 3...) corresponding to callout number
+        - Item: Number (1, 2, 3...) or callout (<1>, <2>...) corresponding to callout number
         - Value: The code/value being explained
         - Description: Explanation text
 
         The conditionals list includes any ifdef/ifndef/endif statements that should
         be preserved when converting the table to other formats.
+
+        Accepts both callout format (<1>) and plain numbers (1).
         """
         explanations = {}
 
@@ -499,16 +597,15 @@ class TableParser:
             value_cell = row.cells[1]
             desc_cell = row.cells[2]
 
-            # Extract item number (maps to callout number)
+            # Extract item number (maps to callout number) - supports both <1> and 1 formats
             if not item_cell.content:
                 continue
 
             item_num_str = item_cell.content[0].strip()
-            if not item_num_str.isdigit():
+            is_match, callout_num = self._is_callout_or_number(item_num_str)
+            if not is_match:
                 continue
 
-            callout_num = int(item_num_str)
-
             # Collect value lines (column 2), preserving all content including conditionals
             value_lines = []
             for line in value_cell.content:
@@ -539,8 +636,12 @@ class TableParser:
         Returns:
             AsciiDocTable if a callout table is found, None otherwise
         """
-        # Skip blank lines and continuation markers after code block
+        # Skip the closing delimiter of the code block (----, ...., etc.)
         i = code_block_end + 1
+        if i < len(lines) and lines[i].strip() in ['----', '....', '====']:
+            i += 1
+
+        # Skip blank lines and continuation markers after code block
         while i < len(lines) and (not lines[i].strip() or lines[i].strip() == '+'):
             i += 1
 
@@ -562,12 +663,26 @@ class TableParser:
 
             # Check for table delimiter
             if self.TABLE_DELIMITER.match(line):
-                # Found a table, parse it
+                # Found a table, extract attributes and title
+                attributes = ""
+                title = ""
                 start_line = j
+
+                # Check line before delimiter for attributes [cols="..."]
                 if j > 0 and self.TABLE_START.match(lines[j - 1]):
+                    attributes = lines[j - 1]
+                    start_line = j - 1
+
+                    # Check line before attributes for title .Title
+                    if j > 1 and lines[j - 2].strip().startswith('.') and not lines[j - 2].strip().startswith('..'):
+                        title = lines[j - 2].strip()
+                        start_line = j - 2
+                elif j > 0 and lines[j - 1].strip().startswith('.') and not lines[j - 1].strip().startswith('..'):
+                    # Title directly before delimiter (no attributes)
+                    title = lines[j - 1].strip()
                     start_line = j - 1
 
-                table = self._parse_table(lines, start_line, j)
+                table = self._parse_table(lines, start_line, j, title)
                 if table and (self.is_callout_table(table) or self.is_3column_callout_table(table)):
                     return table
 

convert_callouts_interactive.py

@@ -20,6 +20,9 @@ from callout_lib import (
     CodeBlock,
 )
 
+# Import version
+from doc_utils.version import __version__
+
 
 # Colors for output
 class Colors:
@@ -307,7 +310,20 @@ class InteractiveCalloutConverter:
             explanations, explanation_end = self.detector.extract_callout_explanations(new_lines, block.end_line)
 
             if not explanations:
-                print_colored(f"Warning: No explanations found for block at line {block.start_line + 1}", Colors.YELLOW)
+                # Get callout numbers for warning message
+                all_callout_nums = []
+                for group in callout_groups:
+                    all_callout_nums.extend(group.callout_numbers)
+
+                warning_msg = (
+                    f"WARNING: {input_file.name} line {block.start_line + 1}: "
+                    f"Code block has callouts {sorted(set(all_callout_nums))} but no explanations found after it. "
+                    f"This may indicate: explanations are shared with another code block, "
+                    f"explanations are in an unexpected location, or documentation error (missing explanations). "
+                    f"Consider reviewing this block manually."
+                )
+                print_colored(warning_msg, Colors.YELLOW)
+                self.warnings.append(warning_msg)
                 continue
 
             # Validate
@@ -332,9 +348,9 @@ class InteractiveCalloutConverter:
             else:
                 converted_content = self.detector.remove_callouts_from_code(block.content)
                 if format_choice == 'bullets':
-                    output_list = BulletListConverter.convert(callout_groups, explanations)
+                    output_list = BulletListConverter.convert(callout_groups, explanations, self.detector.last_table_title)
                 else:  # deflist
-                    output_list = DefListConverter.convert(callout_groups, explanations)
+                    output_list = DefListConverter.convert(callout_groups, explanations, self.detector.last_table_title)
 
             # Replace in document
             has_source_prefix = self.detector.CODE_BLOCK_START.match(new_lines[block.start_line])
@@ -431,6 +447,11 @@ Examples:
         """
     )
 
+    parser.add_argument(
+        '--version',
+        action='version',
+        version=f'%(prog)s {__version__}'
+    )
     parser.add_argument(
         'path',
         nargs='?',
@@ -521,6 +542,8 @@ Examples:
         print_colored(f"\n⚠  {len(converter.warnings)} Warning(s):", Colors.YELLOW)
         for warning in converter.warnings:
             print_colored(f"  {warning}", Colors.YELLOW)
+        print()
+        print_colored("Suggestion: Fix the callout mismatches in the files above and rerun this command.", Colors.YELLOW)
 
     if args.dry_run and files_modified > 0:
         print_colored("\nDRY RUN - No files were modified", Colors.YELLOW)

convert_callouts_to_deflist.py

@@ -22,6 +22,12 @@ from callout_lib import (
     CommentConverter,
 )
 
+# Import warnings report generator
+from doc_utils.warnings_report import generate_warnings_report
+
+# Import version
+from doc_utils.version import __version__
+
 
 # Colors for output
 class Colors:
@@ -40,11 +46,12 @@ class CalloutConverter:
     """Converts callout-style documentation to various formats."""
 
     def __init__(self, dry_run: bool = False, verbose: bool = False, output_format: str = 'deflist',
-                 max_comment_length: int = 120):
+                 max_comment_length: int = 120, force: bool = False):
         self.dry_run = dry_run
         self.verbose = verbose
         self.output_format = output_format  # 'deflist', 'bullets', or 'comments'
         self.max_comment_length = max_comment_length  # Max length for inline comments
+        self.force = force  # Force strip callouts even with warnings
         self.changes_made = 0
         self.warnings = []  # Collect warnings for summary
         self.long_comment_warnings = []  # Warnings for comments exceeding max length
@@ -103,11 +110,50 @@ class CalloutConverter:
 
             if not explanations:
                 self.log(f"No explanations found after block at line {block.start_line + 1}")
-                continue
+                # Warn user about code blocks with callouts but no explanations
+                warning_msg = (
+                    f"WARNING: {input_file.name} line {block.start_line + 1}: "
+                    f"Code block has callouts {sorted(set(all_callout_nums))} but no explanations found after it. "
+                    f"This may indicate: explanations are shared with another code block, "
+                    f"explanations are in an unexpected location, or documentation error (missing explanations). "
+                    f"Consider reviewing this block manually."
+                )
+                print_colored(warning_msg, Colors.YELLOW)
+                self.warnings.append(warning_msg)
+
+                # In force mode, strip callouts anyway
+                if not self.force:
+                    continue
+                else:
+                    self.log(f"FORCE MODE: Stripping callouts from block at line {block.start_line + 1} despite missing explanations")
+
+                    # Just strip callouts without creating explanation list
+                    converted_content = self.detector.remove_callouts_from_code(block.content)
+
+                    # Replace in document
+                    has_source_prefix = self.detector.CODE_BLOCK_START.match(new_lines[block.start_line])
+                    if has_source_prefix:
+                        content_start = block.start_line + 2  # After [source] and ----
+                    else:
+                        content_start = block.start_line + 1  # After ---- only
+                    content_end = block.end_line
+
+                    # Build new section with just code (no explanations)
+                    new_section = (
+                        new_lines[:content_start] +
+                        converted_content +
+                        [new_lines[content_end]] +  # Keep closing delimiter
+                        new_lines[content_end + 1:]  # Keep rest of file
+                    )
+
+                    new_lines = new_section
+                    conversions += 1
+                    self.changes_made += 1
+                    continue
 
             # Validate callouts match
             is_valid, code_nums, explanation_nums = self.detector.validate_callouts(callout_groups, explanations)
-            if not is_valid:
+            if not is_valid and explanations:  # Only validate if we have explanations
                 # Format warning message with file and line numbers
                 line_range = f"{block.start_line + 1}-{block.end_line + 1}"
                 warning_msg = (
@@ -116,7 +162,12 @@ class CalloutConverter:
                 )
                 print_colored(warning_msg, Colors.YELLOW)
                 self.warnings.append(warning_msg)
-                continue
+
+                # In force mode, convert anyway
+                if not self.force:
+                    continue
+                else:
+                    self.log(f"FORCE MODE: Converting block at line {block.start_line + 1} despite callout mismatch")
 
             self.log(f"Converting block at line {block.start_line + 1}")
 
@@ -144,7 +195,7 @@ class CalloutConverter:
                     # Fall back to definition list
                     self.log(f"Falling back to definition list for block at line {block.start_line + 1}")
                     converted_content = self.detector.remove_callouts_from_code(block.content)
-                    output_list = DefListConverter.convert(callout_groups, explanations)
+                    output_list = DefListConverter.convert(callout_groups, explanations, self.detector.last_table_title)
                     use_deflist_fallback = True
                 else:
                     output_list = []  # No separate list after code block for comments
@@ -153,9 +204,9 @@ class CalloutConverter:
                 converted_content = self.detector.remove_callouts_from_code(block.content)
 
                 if self.output_format == 'bullets':
-                    output_list = BulletListConverter.convert(callout_groups, explanations)
+                    output_list = BulletListConverter.convert(callout_groups, explanations, self.detector.last_table_title)
                 else:  # default to 'deflist'
-                    output_list = DefListConverter.convert(callout_groups, explanations)
+                    output_list = DefListConverter.convert(callout_groups, explanations, self.detector.last_table_title)
 
             # Replace in document
             # Check if block has [source] prefix
@@ -170,23 +221,40 @@ class CalloutConverter:
             # For deflist/bullets format, remove old explanations and add new list
             if self.output_format == 'comments' and not use_deflist_fallback:
                 # Remove old callout explanations (list or table format)
+                # Find where explanations/table actually starts to preserve content in between
+                if self.detector.last_table:
+                    explanation_start_line = self.detector.last_table.start_line
+                else:
+                    # List format: skip blank lines after code block
+                    explanation_start_line = block.end_line + 1
+                    while explanation_start_line < len(new_lines) and not new_lines[explanation_start_line].strip():
+                        explanation_start_line += 1
+
                 new_section = (
                     new_lines[:content_start] +
                     converted_content +
                     [new_lines[content_end]] +  # Keep closing delimiter
+                    new_lines[content_end + 1:explanation_start_line] +  # Preserve content between code and explanations
                     new_lines[explanation_end + 1:]  # Skip explanations/table, keep rest
                 )
             else:
                 # Remove old callout explanations and add new list
-                explanation_start = block.end_line + 1
-                while explanation_start < len(new_lines) and not new_lines[explanation_start].strip():
-                    explanation_start += 1
+                # Find where explanations/table actually starts
+                if self.detector.last_table:
+                    # Table format: preserve content between code block and table start
+                    explanation_start_line = self.detector.last_table.start_line
+                else:
+                    # List format: skip blank lines after code block
+                    explanation_start_line = block.end_line + 1
+                    while explanation_start_line < len(new_lines) and not new_lines[explanation_start_line].strip():
+                        explanation_start_line += 1
 
                 # Build the new section
                 new_section = (
                     new_lines[:content_start] +
                     converted_content +
                     [new_lines[content_end]] +  # Keep closing delimiter
+                    new_lines[content_end + 1:explanation_start_line] +  # Preserve content between code and explanations
                     output_list +
                     new_lines[explanation_end + 1:]
                 )
@@ -330,6 +398,11 @@ Example transformation (deflist format):
         """
     )
 
+    parser.add_argument(
+        '--version',
+        action='version',
+        version=f'%(prog)s {__version__}'
+    )
     parser.add_argument(
         'path',
         nargs='?',
@@ -377,6 +450,30 @@ Example transformation (deflist format):
         type=Path,
         help='Path to file containing directories/files to exclude, one per line'
     )
+    parser.add_argument(
+        '--warnings-report',
+        dest='warnings_report',
+        action='store_true',
+        default=True,
+        help='Generate warnings report file (default: enabled)'
+    )
+    parser.add_argument(
+        '--no-warnings-report',
+        dest='warnings_report',
+        action='store_false',
+        help='Disable warnings report file generation'
+    )
+    parser.add_argument(
+        '--warnings-file',
+        type=Path,
+        default=Path('callout-warnings-report.adoc'),
+        help='Path for warnings report file (default: callout-warnings-report.adoc)'
+    )
+    parser.add_argument(
+        '--force',
+        action='store_true',
+        help='Force strip callouts from code blocks even with warnings (USE WITH CAUTION: only after reviewing and fixing callout issues)'
+    )
 
     args = parser.parse_args()
 
@@ -414,9 +511,24 @@ Example transformation (deflist format):
 
     print(f"Found {len(adoc_files)} AsciiDoc file(s) to process")
 
+    # If force mode is enabled, show warning and ask for confirmation
+    if args.force and not args.dry_run:
+        print_colored("\n⚠️  FORCE MODE ENABLED ⚠️", Colors.YELLOW)
+        print_colored("This will strip callouts from code blocks even when warnings are present.", Colors.YELLOW)
+        print_colored("You should only use this option AFTER:", Colors.YELLOW)
+        print_colored("  1. Reviewing all warnings in the warnings report", Colors.YELLOW)
+        print_colored("  2. Manually fixing callout issues where appropriate", Colors.YELLOW)
+        print_colored("  3. Confirming that remaining warnings are acceptable", Colors.YELLOW)
+        print()
+        response = input("Are you sure you want to proceed with force mode? (yes/no): ").strip().lower()
+        if response not in ['yes', 'y']:
+            print_colored("Operation cancelled.", Colors.YELLOW)
+            sys.exit(0)
+        print()
+
     # Create converter
     converter = CalloutConverter(dry_run=args.dry_run, verbose=args.verbose, output_format=args.format,
-                                 max_comment_length=args.max_comment_length)
+                                 max_comment_length=args.max_comment_length, force=args.force)
 
     # Process each file
     files_processed = 0
@@ -459,9 +571,28 @@ Example transformation (deflist format):
 
     # Display warning summary if any warnings were collected
     if converter.warnings:
-        print_colored(f"\n⚠️  {len(converter.warnings)} Warning(s):", Colors.YELLOW)
-        for warning in converter.warnings:
-            print_colored(f"  {warning}", Colors.YELLOW)
+        # Generate warnings report if enabled
+        if args.warnings_report:
+            try:
+                generate_warnings_report(converter.warnings, args.warnings_file)
+                print_colored(f"\n⚠️  {len(converter.warnings)} Warning(s) - See {args.warnings_file} for details", Colors.YELLOW)
+                print()
+                print_colored(f"Suggestion: Review and fix the callout issues listed in {args.warnings_file}, then rerun this command.", Colors.YELLOW)
+            except Exception as e:
+                print_colored(f"\n⚠️  {len(converter.warnings)} Warning(s):", Colors.YELLOW)
+                print_colored(f"Error generating warnings report: {e}", Colors.RED)
+                # Fall back to displaying warnings in console
+                for warning in converter.warnings:
+                    print_colored(f"  {warning}", Colors.YELLOW)
+                print()
+                print_colored("Suggestion: Fix the callout issues listed above and rerun this command.", Colors.YELLOW)
+        else:
+            # Console-only output (legacy behavior)
+            print_colored(f"\n⚠️  {len(converter.warnings)} Warning(s):", Colors.YELLOW)
+            for warning in converter.warnings:
+                print_colored(f"  {warning}", Colors.YELLOW)
+            print()
+            print_colored("Suggestion: Fix the callout issues listed above and rerun this command.", Colors.YELLOW)
         print()
 
     if args.dry_run and files_modified > 0:

doc_utils/version.py

@@ -1,7 +1,7 @@
 """Version information for doc-utils."""
 
 # This should match the version in pyproject.toml
-__version__ = "0.1.30"
+__version__ = "0.1.32"
 
 def get_version():
     """Return the current version string."""

doc_utils/warnings_report.py

@@ -0,0 +1,237 @@
+"""
+Generate AsciiDoc warnings report for callout conversion issues.
+"""
+
+from datetime import datetime
+from typing import List, Dict, Set
+from pathlib import Path
+
+
+class WarningInfo:
+    """Information about a specific warning."""
+
+    def __init__(self, warning_type: str, file_name: str, line_info: str,
+                 code_nums: List[int] = None, explanation_nums: List[int] = None):
+        self.warning_type = warning_type  # 'mismatch' or 'missing'
+        self.file_name = file_name
+        self.line_info = line_info  # e.g., "211" or "55-72"
+        self.code_nums = code_nums or []
+        self.explanation_nums = explanation_nums or []
+
+
+def parse_warning_message(warning_msg: str) -> WarningInfo:
+    """
+    Parse a warning message to extract structured information.
+
+    Examples:
+    - "WARNING: file.adoc lines 55-72: Callout mismatch: code has [1, 2], explanations have [1, 3]"
+    - "WARNING: file.adoc line 211: Code block has callouts [1, 2, 3, 4] but no explanations found..."
+    """
+    import re
+
+    # Extract file name and line info
+    match = re.match(r'WARNING: (.+?) lines? ([\d-]+):', warning_msg)
+    if not match:
+        return None
+
+    file_name = match.group(1)
+    line_info = match.group(2)
+
+    # Determine warning type and extract callout numbers
+    if 'Callout mismatch' in warning_msg:
+        # Parse: "code has [1, 2], explanations have [1, 3]"
+        code_match = re.search(r'code has \[([^\]]+)\]', warning_msg)
+        exp_match = re.search(r'explanations have \[([^\]]+)\]', warning_msg)
+
+        code_nums = []
+        exp_nums = []
+
+        if code_match:
+            code_nums = [int(n.strip()) for n in code_match.group(1).split(',')]
+        if exp_match:
+            exp_nums = [int(n.strip()) for n in exp_match.group(1).split(',')]
+
+        return WarningInfo('mismatch', file_name, line_info, code_nums, exp_nums)
+
+    elif 'but no explanations found' in warning_msg:
+        # Parse: "Code block has callouts [1, 2, 3, 4] but no explanations found"
+        callouts_match = re.search(r'has callouts \[([^\]]+)\]', warning_msg)
+
+        code_nums = []
+        if callouts_match:
+            code_nums = [int(n.strip()) for n in callouts_match.group(1).split(',')]
+
+        return WarningInfo('missing', file_name, line_info, code_nums, [])
+
+    return None
+
+
+def analyze_mismatch(code_nums: List[int], exp_nums: List[int]) -> List[str]:
+    """
+    Analyze what's wrong with a callout mismatch.
+
+    Returns a list of issue descriptions.
+    """
+    issues = []
+    code_set = set(code_nums)
+    exp_set = set(exp_nums)
+
+    # Check for duplicates in explanations
+    exp_counts = {}
+    for num in exp_nums:
+        exp_counts[num] = exp_counts.get(num, 0) + 1
+
+    duplicates = [num for num, count in exp_counts.items() if count > 1]
+    if duplicates:
+        for dup in duplicates:
+            count = exp_counts[dup]
+            issues.append(f"Duplicate callout: {dup} (appears {count} times in explanations)")
+
+    # Check for missing callouts (in code but not in explanations)
+    missing_in_exp = code_set - exp_set
+    if missing_in_exp:
+        for num in sorted(missing_in_exp):
+            issues.append(f"Missing callout: {num} (in code but not in explanations)")
+
+    # Check for extra callouts (in explanations but not in code)
+    extra_in_exp = exp_set - code_set
+    if extra_in_exp:
+        for num in sorted(extra_in_exp):
+            issues.append(f"Extra callout: {num} (in explanations but not in code)")
+
+    # Check for off-by-one errors
+    if code_nums and exp_nums:
+        code_start = min(code_nums)
+        exp_start = min(exp_nums)
+        if code_start != exp_start and not (missing_in_exp or extra_in_exp or duplicates):
+            issues.append(f"Off-by-one error (code starts at {code_start}, explanations start at {exp_start})")
+
+    return issues
+
+
+def generate_warnings_report(warnings: List[str], output_path: Path = None) -> str:
+    """
+    Generate an AsciiDoc warnings report from warning messages.
+
+    Args:
+        warnings: List of warning message strings
+        output_path: Path to write report file (if None, returns content only)
+
+    Returns:
+        The report content as a string
+    """
+    if not warnings:
+        return ""
+
+    # Parse all warnings
+    parsed_warnings = []
+    for warning in warnings:
+        parsed = parse_warning_message(warning)
+        if parsed:
+            parsed_warnings.append(parsed)
+
+    if not parsed_warnings:
+        return ""
+
+    # Group warnings by type
+    mismatch_warnings = [w for w in parsed_warnings if w.warning_type == 'mismatch']
+    missing_warnings = [w for w in parsed_warnings if w.warning_type == 'missing']
+
+    # Generate report content
+    lines = []
+    lines.append("= Callout Conversion Warnings Report")
+    lines.append(":toc:")
+    lines.append("")
+    lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    lines.append("")
+
+    # Summary
+    lines.append("== Summary")
+    lines.append("")
+    lines.append(f"Total warnings: {len(parsed_warnings)}")
+    if mismatch_warnings:
+        lines.append(f"- Callout mismatches: {len(mismatch_warnings)}")
+    if missing_warnings:
+        lines.append(f"- Missing explanations: {len(missing_warnings)}")
+    lines.append("")
+    lines.append("== Recommended Actions")
+    lines.append("")
+    lines.append("1. Review each warning below and fix callout issues where appropriate")
+    lines.append("2. For callout mismatches: Ensure code callouts match explanation numbers")
+    lines.append("3. For missing explanations: Check if explanations are shared with another block or missing")
+    lines.append("4. After fixing issues, rerun the conversion command")
+    lines.append("")
+    lines.append("== Force Mode Option")
+    lines.append("")
+    lines.append("CAUTION: Use this option sparingly and only after reviewing all warnings.")
+    lines.append("")
+    lines.append("If you've reviewed all warnings and confirmed that remaining issues are acceptable,")
+    lines.append("you can use the `--force` option to strip callouts from code blocks despite warnings:")
+    lines.append("")
+    lines.append("[source,bash]")
+    lines.append("----")
+    lines.append("convert-callouts-to-deflist --force modules/")
+    lines.append("----")
+    lines.append("")
+    lines.append("Force mode will:")
+    lines.append("")
+    lines.append("- Strip callouts from blocks with missing explanations (without creating explanation lists)")
+    lines.append("- Convert blocks with callout mismatches using available explanations")
+    lines.append("- Require confirmation before proceeding (unless in dry-run mode)")
+    lines.append("")
+    lines.append("IMPORTANT: Always work in a git branch and review changes with `git diff` before committing.")
+    lines.append("")
+
+    # Callout Mismatch section
+    if mismatch_warnings:
+        lines.append("== Callout Mismatch Warnings")
+        lines.append("")
+        lines.append("Callout numbers in code don't match explanation numbers.")
+        lines.append("")
+
+        for warning in mismatch_warnings:
+            lines.append(f"=== {warning.file_name}")
+            lines.append("")
+            lines.append(f"*Lines {warning.line_info}*")
+            lines.append("")
+            lines.append(f"Code has:: {warning.code_nums}")
+            lines.append(f"Explanations have:: {warning.explanation_nums}")
+            lines.append("")
+
+            issues = analyze_mismatch(warning.code_nums, warning.explanation_nums)
+            if issues:
+                lines.append("Issues detected::")
+                for issue in issues:
+                    lines.append(f"- {issue}")
+                lines.append("")
+
+    # Missing Explanations section
+    if missing_warnings:
+        lines.append("== Missing Explanations Warnings")
+        lines.append("")
+        lines.append("Code blocks with callouts but no explanations found after them.")
+        lines.append("")
+
+        for warning in missing_warnings:
+            lines.append(f"=== {warning.file_name}")
+            lines.append("")
+            lines.append(f"*Line {warning.line_info}*")
+            lines.append("")
+            lines.append(f"Callouts in code:: {warning.code_nums}")
+            lines.append("")
+            lines.append("Possible causes::")
+            lines.append("- Explanations shared with another code block (e.g., in conditional sections)")
+            lines.append("- Explanations in unexpected location")
+            lines.append("- Documentation error (missing explanations)")
+            lines.append("")
+            lines.append("Action:: Review this block manually")
+            lines.append("")
+
+    content = '\n'.join(lines)
+
+    # Write to file if path provided
+    if output_path:
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+
+    return content

{rolfedh_doc_utils-0.1.30.dist-info → rolfedh_doc_utils-0.1.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rolfedh-doc-utils
-Version: 0.1.30
+Version: 0.1.32
 Summary: CLI tools for AsciiDoc documentation projects
 Author: Rolfe Dlugy-Hegwer
 License: MIT License

{rolfedh_doc_utils-0.1.30.dist-info → rolfedh_doc_utils-0.1.32.dist-info}/RECORD

@@ -1,8 +1,8 @@
 archive_unused_files.py,sha256=OJZrkqn70hiOXED218jMYPFNFWnsDpjsCYOmBRxYnHU,2274
 archive_unused_images.py,sha256=fZeyEZtTd72Gbd3YBXTy5xoshAAM9qb4qFPMjhHL1Fg,1864
 check_scannability.py,sha256=O6ROr-e624jVPvPpASpsWo0gTfuCFpA2mTSX61BjAEI,5478
-convert_callouts_interactive.py,sha256=hoDKff3jqyJiGZ3IqjcWF7AXM4XUQE-vVg2NpJYECs4,21066
-convert_callouts_to_deflist.py,sha256=MfNbbTzaODFIK6jdPdCoMCe27KqMjJFjdoIiGazm978,17852
+convert_callouts_interactive.py,sha256=9mmXEIbJo8G2Drj0uMWHFsF59zwJtNPgR2MNsisELLE,22160
+convert_callouts_to_deflist.py,sha256=zbQeig2d69gHJPVEiV9jPUg2IzYFPjVzj1GIUacRk7Q,24895
 doc_utils_cli.py,sha256=J3CE7cTDDCRGkhAknYejNWHhk5t9YFGt27WDVfR98Xk,5111
 extract_link_attributes.py,sha256=wR2SmR2la-jR6DzDbas2PoNONgRZ4dZ6aqwzkwEv8Gs,3516
 find_unused_attributes.py,sha256=77CxFdm72wj6SO81w-auMdDjnvF83jWy_qaM7DsAtBw,4263
@@ -10,11 +10,11 @@ format_asciidoc_spacing.py,sha256=nmWpw2dgwhd81LXyznq0rT8w6Z7cNRyGtPJGRyKFRdc,42
 replace_link_attributes.py,sha256=Cpc4E-j9j-4_y0LOstAKYOPl02Ln_2bGNIeqp3ZVCdA,7624
 validate_links.py,sha256=lWuK8sgfiFdfcUdSVAt_5U9JHVde_oa6peSUlBQtsac,6145
 callout_lib/__init__.py,sha256=8B82N_z4D1LaZVYgd5jZR53QAabtgPzADOyGlnvihj0,665
-callout_lib/converter_bullets.py,sha256=ZYQIddaouEouPkrDRGIt8f35a1rO5M92Ry5Fi5ZL_2g,3926
+callout_lib/converter_bullets.py,sha256=nfH0hz4p8qNM2F-MhtBjwH-lUYcNf2m1sdJebRlCxoo,4405
 callout_lib/converter_comments.py,sha256=do0dH8uOyNFpn5CDEzR0jYYCMIPP3oPFM8cEB-Fp22c,9767
-callout_lib/converter_deflist.py,sha256=cFFxoVAVgEQNercbk4PIJNys9rD4H5kC3FeTG_aoHeE,4448
-callout_lib/detector.py,sha256=im25jLFRQYuD5vXQ5kUlCrl_Zm2x9QJlSDRWlDe_eQc,13999
-callout_lib/table_parser.py,sha256=QO-MkeRwn3c05bBqquQvcqzdhpPEFAhnmGr7VphZhcA,26323
+callout_lib/converter_deflist.py,sha256=LphSVdvCAcH1k7ysiBRQcrfaXRs48lmygSijYXVpu40,4942
+callout_lib/detector.py,sha256=oU36eaSz-damdylPuOftTwNU5ZjVf8GMJ44txcFAFOM,15474
+callout_lib/table_parser.py,sha256=ZucisADE8RDAk5HtIrttaPgBi6Hf8ZUpw7KzfbcmEjc,31450
 doc_utils/__init__.py,sha256=qqZR3lohzkP63soymrEZPBGzzk6-nFzi4_tSffjmu_0,74
 doc_utils/extract_link_attributes.py,sha256=U0EvPZReJQigNfbT-icBsVT6Li64hYki5W7MQz6qqbc,22743
 doc_utils/file_utils.py,sha256=fpTh3xx759sF8sNocdn_arsP3KAv8XA6cTQTAVIZiZg,4247
@@ -27,11 +27,12 @@ doc_utils/unused_adoc.py,sha256=2cbqcYr1os2EhETUU928BlPRlsZVSdI00qaMhqjSIqQ,5263
 doc_utils/unused_attributes.py,sha256=OHyAdaBD7aNo357B0SLBN5NC_jNY5TWXMwgtfJNh3X8,7621
 doc_utils/unused_images.py,sha256=nqn36Bbrmon2KlGlcaruNjJJvTQ8_9H0WU9GvCW7rW8,1456
 doc_utils/validate_links.py,sha256=iBGXnwdeLlgIT3fo3v01ApT5k0X2FtctsvkrE6E3VMk,19610
-doc_utils/version.py,sha256=pnEM8Q0l-kM56_u5y1indjEWaQx61Dkm50erPJRxqH8,203
+doc_utils/version.py,sha256=0NJYwHS5xU9zjMDJzmJazrS_NbnmIeQhFMCZS7ZUNvQ,203
 doc_utils/version_check.py,sha256=-31Y6AN0KGi_CUCAVOOhf6bPO3r7SQIXPxxeffLAF0w,7535
-rolfedh_doc_utils-0.1.30.dist-info/licenses/LICENSE,sha256=vLxtwMVOJA_hEy8b77niTkdmQI9kNJskXHq0dBS36e0,1075
-rolfedh_doc_utils-0.1.30.dist-info/METADATA,sha256=1GESxrnld2SncZtc3TucYNxUOG7nDeQJn5e2trIfWMg,8325
-rolfedh_doc_utils-0.1.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rolfedh_doc_utils-0.1.30.dist-info/entry_points.txt,sha256=vL_LlLKOiurRzchrq8iRUQG19Xi9lSAFVZGjO-xyErk,577
-rolfedh_doc_utils-0.1.30.dist-info/top_level.txt,sha256=J4xtr3zoyCip27b3GnticFVZoyz5HHtgGqHQ-SZONCA,265
-rolfedh_doc_utils-0.1.30.dist-info/RECORD,,
+doc_utils/warnings_report.py,sha256=20yfwqBjOprfFhQwCujbcsvjJCbHHhmH84uAujm-y-o,8877
+rolfedh_doc_utils-0.1.32.dist-info/licenses/LICENSE,sha256=vLxtwMVOJA_hEy8b77niTkdmQI9kNJskXHq0dBS36e0,1075
+rolfedh_doc_utils-0.1.32.dist-info/METADATA,sha256=PVHT2JPkbSx-8AY7xGOYqI-RHT-2I2YTmS41EZmsma8,8325
+rolfedh_doc_utils-0.1.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rolfedh_doc_utils-0.1.32.dist-info/entry_points.txt,sha256=vL_LlLKOiurRzchrq8iRUQG19Xi9lSAFVZGjO-xyErk,577
+rolfedh_doc_utils-0.1.32.dist-info/top_level.txt,sha256=J4xtr3zoyCip27b3GnticFVZoyz5HHtgGqHQ-SZONCA,265
+rolfedh_doc_utils-0.1.32.dist-info/RECORD,,