rolfedh-doc-utils 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

archive_unused_files.py

@@ -11,6 +11,7 @@ import argparse
 from doc_utils.unused_adoc import find_unused_adoc
 from doc_utils.file_utils import parse_exclude_list_file
 
+from doc_utils.spinner import Spinner
 def main():
     parser = argparse.ArgumentParser(
         description='Archive unused AsciiDoc files.',

archive_unused_images.py

@@ -10,6 +10,7 @@ import argparse
 from doc_utils.unused_images import find_unused_images
 from doc_utils.file_utils import parse_exclude_list_file
 
+from doc_utils.spinner import Spinner
 def main():
     parser = argparse.ArgumentParser(description='Archive unused image files.')
     parser.add_argument('--archive', action='store_true', help='Move the files to a dated zip in the archive directory.')

check_scannability.py

@@ -19,6 +19,7 @@ from datetime import datetime
 from doc_utils.scannability import check_scannability
 from doc_utils.file_utils import collect_files, parse_exclude_list_file
 
+from doc_utils.spinner import Spinner
 BASE_SENTENCE_WORD_LIMIT = 22
 BASE_PARAGRAPH_SENTENCE_LIMIT = 3
 

doc_utils/extract_link_attributes.py

@@ -10,6 +10,9 @@ from typing import Dict, List, Set, Tuple, Optional
 from collections import defaultdict
 import unicodedata
 
+from .spinner import Spinner
+from .validate_links import LinkValidator
+
 
 def find_attribute_files(base_path: str = '.') -> List[str]:
     """Find potential attribute files in the repository."""
@@ -254,13 +257,14 @@ def collect_all_macros(scan_dirs: List[str] = None) -> List[Tuple[str, str, str,
 
 def create_attributes(url_groups: Dict[str, List[Tuple[str, str, str, int]]],
                      existing_attrs: Dict[str, str],
-                     interactive: bool = True) -> Dict[str, str]:
+                     interactive: bool = True) -> Tuple[Dict[str, str], Dict[str, str]]:
     """
-    Create new attributes for each unique URL.
+    Create new attributes for each unique URL and track existing ones.
 
-    Returns: Dict[attribute_name, attribute_value]
+    Returns: Tuple[new_attributes, existing_matching_attributes]
     """
     new_attributes = {}
+    existing_matching_attributes = {}
     existing_attr_names = set(existing_attrs.keys())
     counter = 1
 
@@ -270,6 +274,7 @@ def create_attributes(url_groups: Dict[str, List[Tuple[str, str, str, int]]],
         for attr_name, attr_value in existing_attrs.items():
             if url in attr_value:
                 existing_attr = attr_name
+                existing_matching_attributes[attr_name] = attr_value
                 break
 
         if existing_attr:
@@ -293,7 +298,7 @@ def create_attributes(url_groups: Dict[str, List[Tuple[str, str, str, int]]],
 
         print(f"Created attribute: :{attr_name}: {attr_value}")
 
-    return new_attributes
+    return new_attributes, existing_matching_attributes
 
 
 def update_attribute_file(file_path: str, new_attributes: Dict[str, str], dry_run: bool = False):
@@ -381,10 +386,73 @@ def prepare_file_updates(url_groups: Dict[str, List[Tuple[str, str, str, int]]],
     return dict(file_updates)
 
 
+def validate_link_attributes(attributes_file: str, fail_on_broken: bool = False) -> bool:
+    """
+    Validate URLs in link-* attributes.
+
+    Returns: True if validation passes (no broken links or fail_on_broken is False), False otherwise
+    """
+    if not os.path.exists(attributes_file):
+        return True  # No file to validate yet
+
+    print(f"\nValidating links in {attributes_file}...")
+    spinner = Spinner("Validating link attributes")
+    spinner.start()
+
+    # Extract link attributes from file
+    link_attributes = {}
+    with open(attributes_file, 'r', encoding='utf-8') as f:
+        for line_num, line in enumerate(f, 1):
+            # Match :link-*: URL patterns
+            match = re.match(r'^:(link-[a-zA-Z0-9_-]+):\s*(https?://[^\s]+)', line)
+            if match:
+                attr_name = match.group(1)
+                url = match.group(2).strip()
+                link_attributes[attr_name] = (url, line_num)
+
+    if not link_attributes:
+        spinner.stop("No link attributes to validate")
+        return True
+
+    # Validate each URL
+    validator = LinkValidator(timeout=10, retry=2, parallel=5)
+    broken_links = []
+
+    for attr_name, (url, line_num) in link_attributes.items():
+        try:
+            is_valid = validator.validate_url(url)
+            if not is_valid:
+                broken_links.append((attr_name, url, line_num))
+        except Exception as e:
+            broken_links.append((attr_name, url, line_num))
+
+    # Report results
+    total = len(link_attributes)
+    broken = len(broken_links)
+    valid = total - broken
+
+    spinner.stop(f"Validated {total} link attributes: {valid} valid, {broken} broken")
+
+    if broken_links:
+        print("\n⚠️  Broken link attributes found:")
+        for attr_name, url, line_num in broken_links:
+            print(f"  Line {line_num}: :{attr_name}: {url}")
+
+        if fail_on_broken:
+            print("\nStopping extraction due to broken links (--fail-on-broken)")
+            return False
+        else:
+            print("\nContinuing with extraction despite broken links...")
+
+    return True
+
+
 def extract_link_attributes(attributes_file: str = None,
                            scan_dirs: List[str] = None,
                            interactive: bool = True,
-                           dry_run: bool = False) -> bool:
+                           dry_run: bool = False,
+                           validate_links: bool = False,
+                           fail_on_broken: bool = False) -> bool:
     """
     Main function to extract link attributes.
 
@@ -410,13 +478,22 @@ def extract_link_attributes(attributes_file: str = None,
             if not attributes_file:
                 return False
 
+    # Validate existing link attributes if requested
+    if validate_links:
+        if not validate_link_attributes(attributes_file, fail_on_broken):
+            return False
+
     # Load existing attributes
+    spinner = Spinner("Loading existing attributes")
+    spinner.start()
     existing_attrs = load_existing_attributes(attributes_file)
-    print(f"Loaded {len(existing_attrs)} existing attributes")
+    spinner.stop(f"Loaded {len(existing_attrs)} existing attributes")
 
     # Collect all macros
-    print("\nScanning for link and xref macros with attributes...")
+    spinner = Spinner("Scanning for link and xref macros with attributes")
+    spinner.start()
     all_macros = collect_all_macros(scan_dirs)
+    spinner.stop()
 
     if not all_macros:
         print("No link or xref macros with attributes found.")
@@ -425,29 +502,75 @@ def extract_link_attributes(attributes_file: str = None,
     print(f"Found {len(all_macros)} link/xref macros with attributes")
 
     # Group by URL
+    spinner = Spinner("Grouping macros by URL")
+    spinner.start()
     url_groups = group_macros_by_url(all_macros)
-    print(f"Grouped into {len(url_groups)} unique URLs")
+    spinner.stop(f"Grouped into {len(url_groups)} unique URLs")
 
-    # Create new attributes
-    new_attributes = create_attributes(url_groups, existing_attrs, interactive)
+    # Create new attributes and track existing ones
+    new_attributes, existing_matching_attributes = create_attributes(url_groups, existing_attrs, interactive)
 
-    if not new_attributes:
-        print("No new attributes to create.")
+    if not new_attributes and not existing_matching_attributes:
+        print("No new attributes to create and no existing attributes match found URLs.")
         return True
 
-    # Update attribute file
-    update_attribute_file(attributes_file, new_attributes, dry_run)
+    # Validate new attributes before writing if requested
+    if validate_links and not dry_run and new_attributes:
+        print("\nValidating new link attributes...")
+        spinner = Spinner("Validating new URLs")
+        spinner.start()
+
+        validator = LinkValidator(timeout=10, retry=2, parallel=5)
+        broken_new = []
+
+        for attr_name, attr_value in new_attributes.items():
+            # Extract URL from attribute value (could be link: or xref:)
+            url_match = re.search(r'(https?://[^\[]+)', attr_value)
+            if url_match:
+                url = url_match.group(1).strip()
+                try:
+                    if not validator.validate_url(url):
+                        broken_new.append((attr_name, url))
+                except Exception:
+                    broken_new.append((attr_name, url))
+
+        spinner.stop(f"Validated {len(new_attributes)} new attributes")
+
+        if broken_new:
+            print("\n⚠️  Broken URLs in new attributes:")
+            for attr_name, url in broken_new:
+                print(f"  :{attr_name}: {url}")
+
+            if fail_on_broken:
+                print("\nStopping due to broken URLs in new attributes (--fail-on-broken)")
+                return False
+
+    # Update attribute file (only if there are new attributes)
+    if new_attributes:
+        update_attribute_file(attributes_file, new_attributes, dry_run)
 
-    # Prepare file updates
+    # Prepare file updates (include both new and existing matching attributes)
     all_attributes = {**existing_attrs, **new_attributes}
     file_updates = prepare_file_updates(url_groups, all_attributes)
 
     # Replace macros
-    replace_macros_with_attributes(file_updates, dry_run)
+    if file_updates:
+        spinner = Spinner(f"Updating {len(file_updates)} files")
+        spinner.start()
+        replace_macros_with_attributes(file_updates, dry_run)
+        spinner.stop(f"Updated {len(file_updates)} files")
 
     if dry_run:
         print("\n[DRY RUN] No files were modified. Run without --dry-run to apply changes.")
     else:
-        print(f"\nSuccessfully extracted {len(new_attributes)} link attributes")
+        total_processed = len(new_attributes) + len(existing_matching_attributes)
+        if new_attributes and existing_matching_attributes:
+            print(f"\nSuccessfully processed {total_processed} link attributes:")
+            print(f"  - Created {len(new_attributes)} new attributes")
+            print(f"  - Replaced macros using {len(existing_matching_attributes)} existing attributes")
+        elif new_attributes:
+            print(f"\nSuccessfully extracted {len(new_attributes)} link attributes")
+        elif existing_matching_attributes:
+            print(f"\nSuccessfully replaced macros using {len(existing_matching_attributes)} existing link attributes")
 
     return True

doc_utils/spinner.py

@@ -0,0 +1,119 @@
+"""
+Spinner utility for showing progress during long-running operations.
+
+This module provides a simple spinner that can be used by all doc-utils tools
+to indicate that processing is in progress.
+"""
+
+import sys
+import time
+import threading
+from typing import Optional
+
+
+class Spinner:
+    """A simple spinner to show progress during long operations."""
+
+    FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+    def __init__(self, message: str = "Processing"):
+        """
+        Initialize the spinner with a message.
+
+        Args:
+            message: The message to display alongside the spinner
+        """
+        self.message = message
+        self.spinning = False
+        self.thread: Optional[threading.Thread] = None
+        self.frame_index = 0
+
+    def _spin(self):
+        """Internal method that runs in a separate thread to animate the spinner."""
+        while self.spinning:
+            frame = self.FRAMES[self.frame_index % len(self.FRAMES)]
+            sys.stdout.write(f'\r{frame} {self.message}...')
+            sys.stdout.flush()
+            self.frame_index += 1
+            time.sleep(0.1)
+
+    def start(self):
+        """Start the spinner animation."""
+        if not self.spinning:
+            self.spinning = True
+            self.thread = threading.Thread(target=self._spin)
+            self.thread.daemon = True
+            self.thread.start()
+
+    def stop(self, final_message: Optional[str] = None, success: bool = True):
+        """
+        Stop the spinner animation.
+
+        Args:
+            final_message: Optional message to display after stopping
+            success: Whether the operation was successful (affects the symbol shown)
+        """
+        if self.spinning:
+            self.spinning = False
+            if self.thread:
+                self.thread.join()
+
+            # Clear the spinner line completely
+            sys.stdout.write('\r' + ' ' * 80 + '\r')
+
+            # Write final message if provided
+            if final_message:
+                symbol = '✓' if success else '✗'
+                sys.stdout.write(f'{symbol} {final_message}\n')
+
+            sys.stdout.flush()
+
+    def __enter__(self):
+        """Context manager entry - start the spinner."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - stop the spinner."""
+        success = exc_type is None
+        self.stop(success=success)
+        return False
+
+
+def with_spinner(message: str = "Processing"):
+    """
+    Decorator to add a spinner to a function.
+
+    Usage:
+        @with_spinner("Loading data")
+        def load_data():
+            # ... long running operation
+            return data
+    """
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            spinner = Spinner(message)
+            spinner.start()
+            try:
+                result = func(*args, **kwargs)
+                spinner.stop(success=True)
+                return result
+            except Exception as e:
+                spinner.stop(success=False)
+                raise e
+        return wrapper
+    return decorator
+
+
+# Convenience functions for common operations
+def show_progress(message: str = "Processing", total: Optional[int] = None):
+    """
+    Show progress with optional item count.
+
+    Args:
+        message: The base message to display
+        total: Optional total number of items being processed
+    """
+    if total:
+        return Spinner(f"{message} ({total} items)")
+    return Spinner(message)

extract_link_attributes.py

@@ -65,6 +65,18 @@ Examples:
         help='Enable verbose output'
     )
 
+    parser.add_argument(
+        '--validate-links',
+        action='store_true',
+        help='Validate URLs in link-* attributes before extraction'
+    )
+
+    parser.add_argument(
+        '--fail-on-broken',
+        action='store_true',
+        help='Exit extraction if broken links are found in attributes (requires --validate-links)'
+    )
+
     args = parser.parse_args()
 
     try:
@@ -72,7 +84,9 @@ Examples:
             attributes_file=args.attributes_file,
             scan_dirs=args.scan_dir,
             interactive=not args.non_interactive,
-            dry_run=args.dry_run
+            dry_run=args.dry_run,
+            validate_links=args.validate_links,
+            fail_on_broken=args.fail_on_broken
         )
 
         if not success:

find_unused_attributes.py

@@ -13,6 +13,7 @@ import os
 import sys
 from datetime import datetime
 from doc_utils.unused_attributes import find_unused_attributes, find_attributes_files, select_attributes_file
+from doc_utils.spinner import Spinner
 
 def main():
     parser = argparse.ArgumentParser(description='Find unused AsciiDoc attributes.')
@@ -30,8 +31,10 @@ def main():
         attr_file = args.attributes_file
     else:
         # Auto-discover attributes files
-        print("Searching for attributes files...")
+        spinner = Spinner("Searching for attributes files")
+        spinner.start()
         attributes_files = find_attributes_files('.')
+        spinner.stop()
 
         if not attributes_files:
             print("No attributes files found in the repository.")
@@ -44,7 +47,10 @@ def main():
             return 1
 
     try:
+        spinner = Spinner(f"Analyzing attributes in {os.path.basename(attr_file)}")
+        spinner.start()
         unused = find_unused_attributes(attr_file, '.')
+        spinner.stop(f"Found {len(unused)} unused attributes")
     except FileNotFoundError as e:
         print(f"Error: {e}")
         print(f"\nPlease ensure the file '{attr_file}' exists.")

format_asciidoc_spacing.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from doc_utils.format_asciidoc_spacing import process_file, find_adoc_files
 
 
+from doc_utils.spinner import Spinner
 # Colors for output
 class Colors:
     RED = '\033[0;31m'

replace_link_attributes.py

@@ -19,6 +19,7 @@ from doc_utils.replace_link_attributes import (
     replace_link_attributes_in_file,
     find_adoc_files
 )
+from doc_utils.spinner import Spinner
 
 
 def prompt_for_attributes_file(attributes_files: list[Path]) -> Optional[Path]:
@@ -120,30 +121,33 @@ def main():
             print(f"Error: Specified attributes file not found: {attributes_file}")
             sys.exit(1)
     else:
-        print("\nSearching for attributes.adoc files...")
+        spinner = Spinner("Searching for attributes.adoc files")
+        spinner.start()
         attributes_files = find_attributes_files(repo_root)
+        spinner.stop()
         attributes_file = prompt_for_attributes_file(attributes_files)
 
         if not attributes_file:
             print("Operation cancelled.")
             sys.exit(0)
 
-    print(f"\nLoading attributes from: {attributes_file}")
+    spinner = Spinner(f"Loading attributes from {attributes_file.name}")
+    spinner.start()
     attributes = load_attributes(attributes_file)
 
     if not attributes:
-        print("No attributes found in the file.")
+        spinner.stop("No attributes found in the file", success=False)
         sys.exit(1)
 
-    print(f"Found {len(attributes)} attributes")
-
     # Resolve nested references
-    print("Resolving nested attribute references...")
     attributes = resolve_nested_attributes(attributes)
+    spinner.stop(f"Loaded and resolved {len(attributes)} attributes")
 
     # Find all AsciiDoc files
-    print(f"\nSearching for *.adoc files in {repo_root}")
+    spinner = Spinner(f"Searching for .adoc files in {repo_root}")
+    spinner.start()
     adoc_files = find_adoc_files(repo_root)
+    spinner.stop()
 
     # Exclude the attributes file itself
     adoc_files = [f for f in adoc_files if f != attributes_file]
@@ -157,15 +161,18 @@ def main():
     total_replacements = 0
     files_modified = 0
 
+    spinner = Spinner(f"Processing {len(adoc_files)} files")
+    spinner.start()
+
     for file_path in adoc_files:
         replacements = replace_link_attributes_in_file(file_path, attributes, args.dry_run)
         if replacements > 0:
             rel_path = file_path.relative_to(repo_root)
-            prefix = "[DRY RUN] " if args.dry_run else ""
-            print(f"  {prefix}Modified {rel_path}: {replacements} replacements")
             total_replacements += replacements
             files_modified += 1
 
+    spinner.stop(f"Processed {len(adoc_files)} files")
+
     # Summary
     print(f"\nSummary:")
     if args.dry_run:

{rolfedh_doc_utils-0.1.11.dist-info → rolfedh_doc_utils-0.1.13.dist-info}/METADATA

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

rolfedh_doc_utils-0.1.13.dist-info/RECORD

@@ -0,0 +1,26 @@
+archive_unused_files.py,sha256=h7CRwSPBVCOQs0hn_ASD4EXz8QJFcAO2x3KX9FVhXNM,1974
+archive_unused_images.py,sha256=4GSVPYkxqFoY-isy47P_1AhD1ziXgmajFiBGCtZ3olg,1564
+check_scannability.py,sha256=MvGLW4UGGcx-jZLsVRYXpXNAIEQyJZZnsN99zJzbtyc,5178
+extract_link_attributes.py,sha256=rp1yRYIWOEvU3l6lpN4b5rCBae5Q7bdBxEDQ9BNuFH8,2976
+find_unused_attributes.py,sha256=IUJKJr_MzxBXqg9rafUs9Kwi8AbU0x-H0AVflc1dhCU,3288
+format_asciidoc_spacing.py,sha256=_XpHqxYWm1AnZLUK_cDpfAJtsDCDF0b66m3opfYnIuU,3912
+replace_link_attributes.py,sha256=ZkBqrrpIiYGccGMgRjDBrWQKgpfOzHIegURmcgTwaHg,6614
+validate_links.py,sha256=409fTAyBGTUrp6iSWuJ9AXExcdz8dC_4QeA_RvCIhus,5845
+doc_utils/__init__.py,sha256=qqZR3lohzkP63soymrEZPBGzzk6-nFzi4_tSffjmu_0,74
+doc_utils/extract_link_attributes.py,sha256=IIEq2bQmACwDszmaCMeMnYnPKwxSOHWbu_spYOJezlE,20700
+doc_utils/file_utils.py,sha256=fpTh3xx759sF8sNocdn_arsP3KAv8XA6cTQTAVIZiZg,4247
+doc_utils/format_asciidoc_spacing.py,sha256=XnVJekaj39aDzjV3xFKl58flM41AaJzejxNYJIIAMz0,10139
+doc_utils/replace_link_attributes.py,sha256=kBiePbxjQn3O2rzqmYY8Mqy_mJgZ6yw048vSZ5SSB5E,6587
+doc_utils/scannability.py,sha256=XwlmHqDs69p_V36X7DLjPTy0DUoLszSGqYjJ9wE-3hg,982
+doc_utils/spinner.py,sha256=lJg15qzODiKoR0G6uFIk2BdVNgn9jFexoTRUMrjiWvk,3554
+doc_utils/topic_map_parser.py,sha256=tKcIO1m9r2K6dvPRGue58zqMr0O2zKU1gnZMzEE3U6o,4571
+doc_utils/unused_adoc.py,sha256=2cbqcYr1os2EhETUU928BlPRlsZVSdI00qaMhqjSIqQ,5263
+doc_utils/unused_attributes.py,sha256=EjTtWIKW_aXsR1JOgw5RSDVAqitJ_NfRMVOXVGaiWTY,5282
+doc_utils/unused_images.py,sha256=nqn36Bbrmon2KlGlcaruNjJJvTQ8_9H0WU9GvCW7rW8,1456
+doc_utils/validate_links.py,sha256=iBGXnwdeLlgIT3fo3v01ApT5k0X2FtctsvkrE6E3VMk,19610
+rolfedh_doc_utils-0.1.13.dist-info/licenses/LICENSE,sha256=vLxtwMVOJA_hEy8b77niTkdmQI9kNJskXHq0dBS36e0,1075
+rolfedh_doc_utils-0.1.13.dist-info/METADATA,sha256=BijPKBcklacOn-2U2VTfcMEJBkyOMoI84Ce5ItNK-vc,7386
+rolfedh_doc_utils-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rolfedh_doc_utils-0.1.13.dist-info/entry_points.txt,sha256=2J4Ojc3kkuArpe2xcUOPc0LxSWCmnctvw8hy8zpnbO4,418
+rolfedh_doc_utils-0.1.13.dist-info/top_level.txt,sha256=1w0JWD7w7gnM5Sga2K4fJieNZ7CHPTAf0ozYk5iIlmo,182
+rolfedh_doc_utils-0.1.13.dist-info/RECORD,,

validate_links.py

@@ -12,6 +12,7 @@ import argparse
 import sys
 import json
 from doc_utils.validate_links import LinkValidator, parse_transpositions, format_results
+from doc_utils.spinner import Spinner
 
 
 def main():
@@ -155,11 +156,16 @@ Examples:
 
     try:
         # Run validation
+        spinner = Spinner("Validating links")
+        spinner.start()
         results = validator.validate_all(
             scan_dirs=args.scan_dir,
             attributes_file=args.attributes_file,
             exclude_domains=args.exclude_domains
         )
+        total = results['summary']['total']
+        valid = results['summary']['valid']
+        spinner.stop(f"Validated {total} links: {valid} valid")
 
         # Format output
         if args.format == 'json':

rolfedh_doc_utils-0.1.11.dist-info/RECORD

@@ -1,25 +0,0 @@
-archive_unused_files.py,sha256=KMC5a1WL3rZ5owoVnncvfpT1YeMKbVXq9giHvadDgbM,1936
-archive_unused_images.py,sha256=PG2o3haovYckgfhoPhl6KRG_a9czyZuqlLkzkupKTCY,1526
-check_scannability.py,sha256=gcM-vFXKHGP_yFBz7-V5xbXWhIMmtMzBYIGwP9CFbzI,5140
-extract_link_attributes.py,sha256=utDM1FE-VEr649HhIH5BreXvxDNLnnAJO9dB5rs5f9Q,2535
-find_unused_attributes.py,sha256=V8qI7O0u18ExbSho-hLfyBeRVqowLKGrFugY55JxZN0,3023
-format_asciidoc_spacing.py,sha256=ROp-cdMs2_hk8H4z5ljT0iDgGtsiECZ8TVjjcN_oOWE,3874
-replace_link_attributes.py,sha256=vg_aufw7dKXvh_epCKRNq_hEBMU_9crZ_JyJPpxSMNk,6454
-validate_links.py,sha256=DoSB0h3mmjzTY2f0oN6ybTP6jCNkzN7T3qM6oXc2AwE,5585
-doc_utils/__init__.py,sha256=qqZR3lohzkP63soymrEZPBGzzk6-nFzi4_tSffjmu_0,74
-doc_utils/extract_link_attributes.py,sha256=qBpJuTXNrhy15klpqC0iELZzcSLztEzMSmhEnKyQZT0,15574
-doc_utils/file_utils.py,sha256=fpTh3xx759sF8sNocdn_arsP3KAv8XA6cTQTAVIZiZg,4247
-doc_utils/format_asciidoc_spacing.py,sha256=XnVJekaj39aDzjV3xFKl58flM41AaJzejxNYJIIAMz0,10139
-doc_utils/replace_link_attributes.py,sha256=kBiePbxjQn3O2rzqmYY8Mqy_mJgZ6yw048vSZ5SSB5E,6587
-doc_utils/scannability.py,sha256=XwlmHqDs69p_V36X7DLjPTy0DUoLszSGqYjJ9wE-3hg,982
-doc_utils/topic_map_parser.py,sha256=tKcIO1m9r2K6dvPRGue58zqMr0O2zKU1gnZMzEE3U6o,4571
-doc_utils/unused_adoc.py,sha256=2cbqcYr1os2EhETUU928BlPRlsZVSdI00qaMhqjSIqQ,5263
-doc_utils/unused_attributes.py,sha256=EjTtWIKW_aXsR1JOgw5RSDVAqitJ_NfRMVOXVGaiWTY,5282
-doc_utils/unused_images.py,sha256=nqn36Bbrmon2KlGlcaruNjJJvTQ8_9H0WU9GvCW7rW8,1456
-doc_utils/validate_links.py,sha256=iBGXnwdeLlgIT3fo3v01ApT5k0X2FtctsvkrE6E3VMk,19610
-rolfedh_doc_utils-0.1.11.dist-info/licenses/LICENSE,sha256=vLxtwMVOJA_hEy8b77niTkdmQI9kNJskXHq0dBS36e0,1075
-rolfedh_doc_utils-0.1.11.dist-info/METADATA,sha256=22seO4nEGTjlibUZ8tPRxTFyYpmLRsfY7sZssteQl1g,7386
-rolfedh_doc_utils-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rolfedh_doc_utils-0.1.11.dist-info/entry_points.txt,sha256=2J4Ojc3kkuArpe2xcUOPc0LxSWCmnctvw8hy8zpnbO4,418
-rolfedh_doc_utils-0.1.11.dist-info/top_level.txt,sha256=1w0JWD7w7gnM5Sga2K4fJieNZ7CHPTAf0ozYk5iIlmo,182
-rolfedh_doc_utils-0.1.11.dist-info/RECORD,,