rolfedh-doc-utils 0.1.24__py3-none-any.whl → 0.1.26__py3-none-any.whl

convert_callouts_to_deflist.py

@@ -3,18 +3,24 @@
 convert-callouts-to-deflist - Convert AsciiDoc callouts to definition list format
 
 Converts code blocks with callout-style annotations (<1>, <2>, etc.) to cleaner
-definition list format with "where:" prefix.
+definition list format with "where:" prefix, bulleted list format, or inline comments.
 
 This tool automatically scans all .adoc files in the current directory (recursively)
 by default, or you can specify a specific file or directory.
 """
 
-import re
 import sys
 import argparse
 from pathlib import Path
-from typing import List, Dict, Tuple, Optional
-from dataclasses import dataclass
+from typing import List, Tuple
+
+# Import from callout_lib
+from callout_lib import (
+    CalloutDetector,
+    DefListConverter,
+    BulletListConverter,
+    CommentConverter,
+)
 
 
 # Colors for output
@@ -30,374 +36,30 @@ def print_colored(message: str, color: str = Colors.NC) -> None:
     print(f"{color}{message}{Colors.NC}")
 
 
-@dataclass
-class Callout:
-    """Represents a callout with its number and explanation text."""
-    number: int
-    lines: List[str]  # List of lines to preserve formatting
-    is_optional: bool = False
-
-
-@dataclass
-class CalloutGroup:
-    """Represents one or more callouts that share the same code line."""
-    code_line: str  # The actual code line (without callouts)
-    callout_numbers: List[int]  # List of callout numbers on this line
-
-
-@dataclass
-class CodeBlock:
-    """Represents a code block with its content and metadata."""
-    start_line: int
-    end_line: int
-    delimiter: str
-    content: List[str]
-    language: Optional[str] = None
-
-
 class CalloutConverter:
-    """Converts callout-style documentation to definition list format."""
-
-    # Pattern for code block start: [source,language] or [source] with optional attributes
-    # Matches: [source], [source,java], [source,java,subs="..."], [source,java,options="..."], etc.
-    CODE_BLOCK_START = re.compile(r'^\[source(?:,\s*(\w+))?(?:[,\s]+[^\]]+)?\]')
-
-    # Pattern for callout number in code block (can appear multiple times per line)
-    CALLOUT_IN_CODE = re.compile(r'<(\d+)>')
-
-    # Pattern for callout explanation line: <1> Explanation text
-    CALLOUT_EXPLANATION = re.compile(r'^<(\d+)>\s+(.+)$')
+    """Converts callout-style documentation to various formats."""
 
-    # Pattern to detect user-replaceable values in angle brackets
-    # Excludes heredoc syntax (<<) and comparison operators
-    USER_VALUE_PATTERN = re.compile(r'(?<!<)<([a-zA-Z][^>]*)>')
-
-    def __init__(self, dry_run: bool = False, verbose: bool = False, output_format: str = 'deflist'):
+    def __init__(self, dry_run: bool = False, verbose: bool = False, output_format: str = 'deflist',
+                 max_comment_length: int = 120):
         self.dry_run = dry_run
         self.verbose = verbose
-        self.output_format = output_format  # 'deflist' or 'bullets'
+        self.output_format = output_format  # 'deflist', 'bullets', or 'comments'
+        self.max_comment_length = max_comment_length  # Max length for inline comments
         self.changes_made = 0
         self.warnings = []  # Collect warnings for summary
+        self.long_comment_warnings = []  # Warnings for comments exceeding max length
+
+        # Initialize detector and converters
+        self.detector = CalloutDetector()
 
     def log(self, message: str):
         """Print message if verbose mode is enabled."""
         if self.verbose:
             print(f"[INFO] {message}")
 
-    def find_code_blocks(self, lines: List[str]) -> List[CodeBlock]:
-        """Find all code blocks in the document."""
-        blocks = []
-        i = 0
-
-        while i < len(lines):
-            # Check for [source] prefix first
-            match = self.CODE_BLOCK_START.match(lines[i])
-            if match:
-                language = match.group(1)
-                start = i
-                i += 1
-
-                # Find the delimiter line (---- or ....)
-                if i < len(lines) and lines[i].strip() in ['----', '....']:
-                    delimiter = lines[i].strip()
-                    i += 1
-                    content_start = i
-
-                    # Find the closing delimiter
-                    while i < len(lines):
-                        if lines[i].strip() == delimiter:
-                            content = lines[content_start:i]
-                            blocks.append(CodeBlock(
-                                start_line=start,
-                                end_line=i,
-                                delimiter=delimiter,
-                                content=content,
-                                language=language
-                            ))
-                            break
-                        i += 1
-            # Check for plain delimited blocks without [source] prefix
-            elif lines[i].strip() in ['----', '....']:
-                delimiter = lines[i].strip()
-                start = i
-                i += 1
-                content_start = i
-
-                # Find the closing delimiter
-                while i < len(lines):
-                    if lines[i].strip() == delimiter:
-                        content = lines[content_start:i]
-                        # Only add if block contains callouts
-                        if any(self.CALLOUT_IN_CODE.search(line) for line in content):
-                            blocks.append(CodeBlock(
-                                start_line=start,
-                                end_line=i,
-                                delimiter=delimiter,
-                                content=content,
-                                language=None
-                            ))
-                        break
-                    i += 1
-            i += 1
-
-        return blocks
-
-    def extract_callouts_from_code(self, content: List[str]) -> List[CalloutGroup]:
-        """
-        Extract callout numbers from code block content.
-        Returns list of CalloutGroups, where each group contains:
-        - The code line (with user-replaceable value if found, or full line)
-        - List of callout numbers on that line
-
-        Multiple callouts on the same line are grouped together to be merged
-        in the definition list.
-        """
-        groups = []
-
-        for line in content:
-            # Look for all callout numbers on this line
-            callout_matches = list(self.CALLOUT_IN_CODE.finditer(line))
-            if callout_matches:
-                # Remove all callouts from the line to get the actual code
-                line_without_callouts = self.CALLOUT_IN_CODE.sub('', line).strip()
-
-                # Find all angle-bracket enclosed values
-                user_values = self.USER_VALUE_PATTERN.findall(line_without_callouts)
-
-                # Determine what to use as the code line term
-                if user_values:
-                    # Use the rightmost (closest to the callout) user value
-                    code_line = user_values[-1]
-                else:
-                    # No angle-bracket value found - use the actual code line
-                    code_line = line_without_callouts
-
-                # Collect all callout numbers on this line
-                callout_nums = [int(m.group(1)) for m in callout_matches]
-
-                groups.append(CalloutGroup(
-                    code_line=code_line,
-                    callout_numbers=callout_nums
-                ))
-
-        return groups
-
-    def extract_callout_explanations(self, lines: List[str], start_line: int) -> Tuple[Dict[int, Callout], int]:
-        """
-        Extract callout explanations following a code block.
-        Returns dict of callouts and the line number where explanations end.
-        """
-        explanations = {}
-        i = start_line + 1  # Start after the closing delimiter
-
-        # Skip blank lines and continuation markers (+)
-        while i < len(lines) and (not lines[i].strip() or lines[i].strip() == '+'):
-            i += 1
-
-        # Collect consecutive callout explanation lines
-        while i < len(lines):
-            match = self.CALLOUT_EXPLANATION.match(lines[i])
-            if match:
-                num = int(match.group(1))
-                first_line = match.group(2).strip()
-                explanation_lines = [first_line]
-                i += 1
-
-                # Collect continuation lines (lines that don't start with a new callout)
-                # Continue until we hit a blank line, a new callout, or certain patterns
-                while i < len(lines):
-                    line = lines[i]
-                    # Stop if we hit a blank line, new callout, or list start marker
-                    if not line.strip() or self.CALLOUT_EXPLANATION.match(line) or line.startswith('[start='):
-                        break
-                    # Add continuation line preserving original formatting
-                    explanation_lines.append(line)
-                    i += 1
-
-                # Check if marked as optional (only in first line)
-                is_optional = False
-                if first_line.lower().startswith('optional.') or first_line.lower().startswith('optional:'):
-                    is_optional = True
-                    # Remove "Optional." or "Optional:" from first line
-                    explanation_lines[0] = first_line[9:].strip()
-                elif '(Optional)' in first_line or '(optional)' in first_line:
-                    is_optional = True
-                    explanation_lines[0] = re.sub(r'\s*\(optional\)\s*', ' ', first_line, flags=re.IGNORECASE).strip()
-
-                explanations[num] = Callout(num, explanation_lines, is_optional)
-            else:
-                break
-
-        return explanations, i - 1
-
-    def validate_callouts(self, callout_groups: List[CalloutGroup], explanations: Dict[int, Callout],
-                         input_file: Path = None, block_start: int = None, block_end: int = None) -> bool:
-        """
-        Validate that callout numbers in code match explanation numbers.
-        Returns True if valid, False otherwise.
-        """
-        # Extract all callout numbers from groups
-        code_nums = set()
-        for group in callout_groups:
-            code_nums.update(group.callout_numbers)
-
-        explanation_nums = set(explanations.keys())
-
-        if code_nums != explanation_nums:
-            # Format warning message with file and line numbers
-            if input_file and block_start is not None and block_end is not None:
-                # Line numbers are 1-indexed for display
-                line_range = f"{block_start + 1}-{block_end + 1}"
-                warning_msg = (
-                    f"WARNING: {input_file.name} lines {line_range}: Callout mismatch: "
-                    f"code has {sorted(code_nums)}, explanations have {sorted(explanation_nums)}"
-                )
-                print_colored(warning_msg, Colors.YELLOW)
-                # Store warning for summary
-                self.warnings.append(warning_msg)
-            else:
-                self.log(f"Callout mismatch: code has {code_nums}, explanations have {explanation_nums}")
-            return False
-
-        return True
-
-    def remove_callouts_from_code(self, content: List[str]) -> List[str]:
-        """Remove callout numbers from code block content (handles multiple callouts per line)."""
-        cleaned = []
-        for line in content:
-            # Remove all callout numbers and trailing whitespace
-            cleaned.append(self.CALLOUT_IN_CODE.sub('', line).rstrip())
-        return cleaned
-
-    def create_definition_list(self, callout_groups: List[CalloutGroup], explanations: Dict[int, Callout]) -> List[str]:
-        """
-        Create definition list from callout groups and explanations.
-
-        For callouts with user-replaceable values in angle brackets, uses those.
-        For callouts without values, uses the actual code line as the term.
-
-        When multiple callouts share the same code line (same group), their
-        explanations are merged using AsciiDoc list continuation (+).
-        """
-        lines = ['\nwhere:']
-
-        # Process each group (which may contain one or more callouts)
-        for group in callout_groups:
-            code_line = group.code_line
-            callout_nums = group.callout_numbers
-
-            # Check if this is a user-replaceable value (contains angle brackets but not heredoc)
-            # User values are single words/phrases in angle brackets like <my-value>
-            user_values = self.USER_VALUE_PATTERN.findall(code_line)
-
-            if user_values and len(user_values) == 1 and len(code_line) < 100:
-                # This looks like a user-replaceable value placeholder
-                # Format the value (ensure it has angle brackets)
-                user_value = user_values[0]
-                if not user_value.startswith('<'):
-                    user_value = f'<{user_value}>'
-                if not user_value.endswith('>'):
-                    user_value = f'{user_value}>'
-                term = f'`{user_value}`'
-            else:
-                # This is a code line - use it as-is in backticks
-                term = f'`{code_line}`'
-
-            # Add blank line before each term
-            lines.append('')
-            lines.append(f'{term}::')
-
-            # Add explanations for all callouts in this group
-            for idx, callout_num in enumerate(callout_nums):
-                explanation = explanations[callout_num]
-
-                # If this is not the first explanation in the group, add continuation marker
-                if idx > 0:
-                    lines.append('+')
-
-                # Add explanation lines, prepending "Optional. " to first line if needed
-                for line_idx, line in enumerate(explanation.lines):
-                    if line_idx == 0 and explanation.is_optional:
-                        lines.append(f'Optional. {line}')
-                    else:
-                        lines.append(line)
-
-        return lines
-
-    def create_bulleted_list(self, callout_groups: List[CalloutGroup], explanations: Dict[int, Callout]) -> List[str]:
-        """
-        Create bulleted list from callout groups and explanations.
-
-        Follows Red Hat style guide format:
-        - Each bullet starts with `*` followed by backticked code element
-        - Colon separates element from explanation
-        - Blank line between each bullet point
-
-        For callouts with user-replaceable values in angle brackets, uses those.
-        For callouts without values, uses the actual code line as the term.
-
-        When multiple callouts share the same code line (same group), their
-        explanations are merged with line breaks.
-        """
-        lines = ['']  # Start with blank line before list
-
-        # Process each group (which may contain one or more callouts)
-        for group in callout_groups:
-            code_line = group.code_line
-            callout_nums = group.callout_numbers
-
-            # Check if this is a user-replaceable value (contains angle brackets but not heredoc)
-            # User values are single words/phrases in angle brackets like <my-value>
-            user_values = self.USER_VALUE_PATTERN.findall(code_line)
-
-            if user_values and len(user_values) == 1 and len(code_line) < 100:
-                # This looks like a user-replaceable value placeholder
-                # Format the value (ensure it has angle brackets)
-                user_value = user_values[0]
-                if not user_value.startswith('<'):
-                    user_value = f'<{user_value}>'
-                if not user_value.endswith('>'):
-                    user_value = f'{user_value}>'
-                term = f'`{user_value}`'
-            else:
-                # This is a code line - use it as-is in backticks
-                term = f'`{code_line}`'
-
-            # Collect all explanations for this group
-            all_explanation_lines = []
-            for idx, callout_num in enumerate(callout_nums):
-                explanation = explanations[callout_num]
-
-                # Add explanation lines, prepending "Optional. " to first line if needed
-                for line_idx, line in enumerate(explanation.lines):
-                    if line_idx == 0 and explanation.is_optional:
-                        all_explanation_lines.append(f'Optional. {line}')
-                    else:
-                        all_explanation_lines.append(line)
-
-                # If there are more callouts in this group, add a line break
-                if idx < len(callout_nums) - 1:
-                    all_explanation_lines.append('')
-
-            # Format as bullet point: * `term`: explanation
-            # First line uses the bullet marker
-            lines.append(f'*   {term}: {all_explanation_lines[0]}')
-
-            # Continuation lines (if any) are indented to align with first line
-            for continuation_line in all_explanation_lines[1:]:
-                if continuation_line:  # Skip empty lines for now
-                    lines.append(f'    {continuation_line}')
-                else:
-                    lines.append('')
-
-            # Add blank line after each bullet point
-            lines.append('')
-
-        return lines
-
     def convert_file(self, input_file: Path) -> Tuple[int, bool]:
         """
-        Convert callouts in a file to definition list format.
+        Convert callouts in a file to the specified output format.
         Returns tuple of (number of conversions, whether file was modified).
         """
         # Read input file
@@ -411,7 +73,7 @@ class CalloutConverter:
         self.log(f"Processing {input_file} ({len(lines)} lines)")
 
         # Find all code blocks
-        blocks = self.find_code_blocks(lines)
+        blocks = self.detector.find_code_blocks(lines)
         self.log(f"Found {len(blocks)} code blocks")
 
         if not blocks:
@@ -423,7 +85,7 @@ class CalloutConverter:
 
         for block in reversed(blocks):
             # Extract callouts from code (returns list of CalloutGroups)
-            callout_groups = self.extract_callouts_from_code(block.content)
+            callout_groups = self.detector.extract_callouts_from_code(block.content)
 
             if not callout_groups:
                 self.log(f"No callouts in block at line {block.start_line + 1}")
@@ -437,50 +99,96 @@ class CalloutConverter:
             self.log(f"Block at line {block.start_line + 1} has callouts: {all_callout_nums}")
 
             # Extract explanations
-            explanations, explanation_end = self.extract_callout_explanations(new_lines, block.end_line)
+            explanations, explanation_end = self.detector.extract_callout_explanations(new_lines, block.end_line)
 
             if not explanations:
                 self.log(f"No explanations found after block at line {block.start_line + 1}")
                 continue
 
             # Validate callouts match
-            if not self.validate_callouts(callout_groups, explanations, input_file, block.start_line, block.end_line):
+            is_valid, code_nums, explanation_nums = self.detector.validate_callouts(callout_groups, explanations)
+            if not is_valid:
+                # Format warning message with file and line numbers
+                line_range = f"{block.start_line + 1}-{block.end_line + 1}"
+                warning_msg = (
+                    f"WARNING: {input_file.name} lines {line_range}: Callout mismatch: "
+                    f"code has {sorted(code_nums)}, explanations have {sorted(explanation_nums)}"
+                )
+                print_colored(warning_msg, Colors.YELLOW)
+                self.warnings.append(warning_msg)
                 continue
 
             self.log(f"Converting block at line {block.start_line + 1}")
 
-            # Remove callouts from code
-            cleaned_content = self.remove_callouts_from_code(block.content)
+            # Convert based on format option
+            use_deflist_fallback = False
+            if self.output_format == 'comments':
+                # For comments format, replace callouts inline in the code
+                converted_content, long_warnings = CommentConverter.convert(
+                    block.content, callout_groups, explanations, block.language,
+                    max_length=self.max_comment_length, shorten_long=False
+                )
+
+                # If there are long comment warnings, fall back to definition list
+                if long_warnings:
+                    for lw in long_warnings:
+                        warning_msg = (
+                            f"WARNING: {input_file.name} lines {block.start_line + 1}-{block.end_line + 1}: "
+                            f"Callout <{lw.callout_num}> explanation too long ({lw.length} chars) "
+                            f"for inline comment (max: {self.max_comment_length}). Falling back to definition list format."
+                        )
+                        print_colored(warning_msg, Colors.YELLOW)
+                        self.warnings.append(warning_msg)
+                        self.long_comment_warnings.append((input_file.name, block.start_line + 1, lw))
+
+                    # 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)
+                    use_deflist_fallback = True
+                else:
+                    output_list = []  # No separate list after code block for comments
+            else:
+                # For deflist and bullets, remove callouts from code and create separate list
+                converted_content = self.detector.remove_callouts_from_code(block.content)
 
-            # Create output list (definition list or bulleted list based on format option)
-            if self.output_format == 'bullets':
-                output_list = self.create_bulleted_list(callout_groups, explanations)
-            else:  # default to 'deflist'
-                output_list = self.create_definition_list(callout_groups, explanations)
+                if self.output_format == 'bullets':
+                    output_list = BulletListConverter.convert(callout_groups, explanations)
+                else:  # default to 'deflist'
+                    output_list = DefListConverter.convert(callout_groups, explanations)
 
             # Replace in document
-            # 1. Update code block content
-            # Check if block has [source] prefix by checking if start_line contains [source]
-            has_source_prefix = self.CODE_BLOCK_START.match(new_lines[block.start_line])
+            # Check if block has [source] prefix
+            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
 
-            # 2. Remove old callout explanations
-            explanation_start = block.end_line + 1
-            while explanation_start < len(new_lines) and not new_lines[explanation_start].strip():
-                explanation_start += 1
-
-            # Build the new section
-            new_section = (
-                new_lines[:content_start] +
-                cleaned_content +
-                [new_lines[content_end]] +  # Keep closing delimiter
-                output_list +
-                new_lines[explanation_end + 1:]
-            )
+            # For comments format (without fallback), we keep the explanations section
+            # For deflist/bullets format, we remove old explanations and add new list
+            if self.output_format == 'comments' and not use_deflist_fallback:
+                # Keep everything as-is, just replace code content
+                new_section = (
+                    new_lines[:content_start] +
+                    converted_content +
+                    new_lines[content_end:]
+                )
+            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
+
+                # Build the new section
+                new_section = (
+                    new_lines[:content_start] +
+                    converted_content +
+                    [new_lines[content_end]] +  # Keep closing delimiter
+                    output_list +
+                    new_lines[explanation_end + 1:]
+                )
 
             new_lines = new_section
             conversions += 1
@@ -572,23 +280,29 @@ def load_exclusion_list(exclusion_file: Path) -> Tuple[List[str], List[str]]:
 def main():
     """Main entry point"""
     parser = argparse.ArgumentParser(
-        description='Convert AsciiDoc callouts to definition list format',
+        description='Convert AsciiDoc callouts to various formats',
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-Convert AsciiDoc callout-style documentation to definition list format.
+Convert AsciiDoc callout-style documentation to various formats.
 
 This script identifies code blocks with callout numbers (<1>, <2>, etc.) and their
-corresponding explanation lines, then converts them to a cleaner definition list format
-with "where:" prefix.
+corresponding explanation lines, then converts them to your chosen format.
+
+Formats:
+  deflist  - Definition list with "where:" prefix (default)
+  bullets  - Bulleted list format
+  comments - Inline comments within code (removes separate explanations)
 
 Examples:
   %(prog)s                                    # Process all .adoc files in current directory
   %(prog)s modules/                          # Process all .adoc files in modules/
   %(prog)s assemblies/my-guide.adoc          # Process single file
   %(prog)s --dry-run modules/               # Preview changes without modifying
+  %(prog)s --format bullets modules/        # Convert to bulleted list format
+  %(prog)s --format comments src/           # Convert to inline comments
   %(prog)s --exclude-dir .vale modules/     # Exclude .vale directory
 
-Example transformation:
+Example transformation (deflist format):
   FROM:
     [source,yaml]
     ----
@@ -633,9 +347,15 @@ Example transformation:
     )
     parser.add_argument(
         '-f', '--format',
-        choices=['deflist', 'bullets'],
+        choices=['deflist', 'bullets', 'comments'],
         default='deflist',
-        help='Output format: "deflist" for definition list with "where:" (default), "bullets" for bulleted list'
+        help='Output format: "deflist" for definition list (default), "bullets" for bulleted list, "comments" for inline comments'
+    )
+    parser.add_argument(
+        '--max-comment-length',
+        type=int,
+        default=120,
+        help='Maximum length for inline comments before falling back to definition list (default: 120 characters)'
     )
     parser.add_argument(
         '--exclude-dir',
@@ -694,7 +414,8 @@ Example transformation:
     print(f"Found {len(adoc_files)} AsciiDoc file(s) to process")
 
     # Create converter
-    converter = CalloutConverter(dry_run=args.dry_run, verbose=args.verbose, output_format=args.format)
+    converter = CalloutConverter(dry_run=args.dry_run, verbose=args.verbose, output_format=args.format,
+                                 max_comment_length=args.max_comment_length)
 
     # Process each file
     files_processed = 0

{rolfedh_doc_utils-0.1.24.dist-info → rolfedh_doc_utils-0.1.26.dist-info}/METADATA

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

{rolfedh_doc_utils-0.1.24.dist-info → rolfedh_doc_utils-0.1.26.dist-info}/RECORD

@@ -1,13 +1,20 @@
 archive_unused_files.py,sha256=OJZrkqn70hiOXED218jMYPFNFWnsDpjsCYOmBRxYnHU,2274
 archive_unused_images.py,sha256=fZeyEZtTd72Gbd3YBXTy5xoshAAM9qb4qFPMjhHL1Fg,1864
 check_scannability.py,sha256=O6ROr-e624jVPvPpASpsWo0gTfuCFpA2mTSX61BjAEI,5478
-convert_callouts_to_deflist.py,sha256=XBcQ5oUjpSsv9VM4ldh_2fFH33-ZQaIQ1Gj6SyEW5b0,28954
+convert_callouts_interactive.py,sha256=hoDKff3jqyJiGZ3IqjcWF7AXM4XUQE-vVg2NpJYECs4,21066
+convert_callouts_to_deflist.py,sha256=WRpHmD3DWs7G7qEcL6c9WLYpX4uaPzlMKrWXnPlHQ_s,17720
 doc_utils_cli.py,sha256=dsMYrkAriYdZUF0_cSPh5DAPrJMPiecuY26xN-p0UJ0,4911
 extract_link_attributes.py,sha256=wR2SmR2la-jR6DzDbas2PoNONgRZ4dZ6aqwzkwEv8Gs,3516
 find_unused_attributes.py,sha256=77CxFdm72wj6SO81w-auMdDjnvF83jWy_qaM7DsAtBw,4263
 format_asciidoc_spacing.py,sha256=nmWpw2dgwhd81LXyznq0rT8w6Z7cNRyGtPJGRyKFRdc,4212
 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=8P92QZ0PylrKRE7V-D3TVZCDH0ct3GRIonc7W5AK5uU,3898
+callout_lib/converter_comments.py,sha256=do0dH8uOyNFpn5CDEzR0jYYCMIPP3oPFM8cEB-Fp22c,9767
+callout_lib/converter_deflist.py,sha256=mQ17Y8gJLv0MzzJscpUL7ujuDRyEVcrb9lcPdUNkIX4,3117
+callout_lib/detector.py,sha256=qMFb8MZGYWhEXqV-Bn9BW0qXlYgJcVwKyPI-50oYl5U,10937
+callout_lib/table_parser.py,sha256=0sngxSXdVxc9vs6umeV6hgOIP2ETC7I_RbrEuSntB6k,15505
 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
@@ -22,9 +29,9 @@ doc_utils/unused_images.py,sha256=nqn36Bbrmon2KlGlcaruNjJJvTQ8_9H0WU9GvCW7rW8,14
 doc_utils/validate_links.py,sha256=iBGXnwdeLlgIT3fo3v01ApT5k0X2FtctsvkrE6E3VMk,19610
 doc_utils/version.py,sha256=5Uc0sAUOkXA6R_PvDGjw2MBYptEKdav5XmeRqukMTo0,203
 doc_utils/version_check.py,sha256=eHJnZmBTbdhhY2fJQW9KnnyD0rWEvCZpMg6oSr0fOmI,7090
-rolfedh_doc_utils-0.1.24.dist-info/licenses/LICENSE,sha256=vLxtwMVOJA_hEy8b77niTkdmQI9kNJskXHq0dBS36e0,1075
-rolfedh_doc_utils-0.1.24.dist-info/METADATA,sha256=1IJI_6eS9NzQnW6oJfzrevLrwDoOjurisURUMUNgyaQ,8325
-rolfedh_doc_utils-0.1.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rolfedh_doc_utils-0.1.24.dist-info/entry_points.txt,sha256=uoZFRyvDmJfz-0M6cKyB2WjxH0WCmeRrDq0Os1R1wd8,512
-rolfedh_doc_utils-0.1.24.dist-info/top_level.txt,sha256=O13H7Ibk6HKNC32hpcqK8Cq13jiIqRP6A_bB66Zib1Q,224
-rolfedh_doc_utils-0.1.24.dist-info/RECORD,,
+rolfedh_doc_utils-0.1.26.dist-info/licenses/LICENSE,sha256=vLxtwMVOJA_hEy8b77niTkdmQI9kNJskXHq0dBS36e0,1075
+rolfedh_doc_utils-0.1.26.dist-info/METADATA,sha256=ni6hzbVbd9CcWp73tFf688p7g5xaWXqsASphw0Bb4kA,8325
+rolfedh_doc_utils-0.1.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rolfedh_doc_utils-0.1.26.dist-info/entry_points.txt,sha256=vL_LlLKOiurRzchrq8iRUQG19Xi9lSAFVZGjO-xyErk,577
+rolfedh_doc_utils-0.1.26.dist-info/top_level.txt,sha256=J4xtr3zoyCip27b3GnticFVZoyz5HHtgGqHQ-SZONCA,265
+rolfedh_doc_utils-0.1.26.dist-info/RECORD,,

{rolfedh_doc_utils-0.1.24.dist-info → rolfedh_doc_utils-0.1.26.dist-info}/entry_points.txt

@@ -2,6 +2,7 @@
 archive-unused-files = archive_unused_files:main
 archive-unused-images = archive_unused_images:main
 check-scannability = check_scannability:main
+convert-callouts-interactive = convert_callouts_interactive:main
 convert-callouts-to-deflist = convert_callouts_to_deflist:main
 doc-utils = doc_utils_cli:main
 extract-link-attributes = extract_link_attributes:main