tree-sitter-analyzer 1.8.4__py3-none-any.whl → 1.9.1__py3-none-any.whl

tree_sitter_analyzer/formatters/markdown_formatter.py

@@ -6,7 +6,8 @@ Provides specialized formatting for Markdown files, focusing on document structu
 rather than programming constructs like classes and methods.
 """
 
-from typing import Dict, List, Any, Optional
+from typing import Any
+
 from .base_formatter import BaseFormatter
 
 
@@ -17,18 +18,22 @@ class MarkdownFormatter(BaseFormatter):
         super().__init__()
         self.language = "markdown"
 
-    def format_summary(self, analysis_result: Dict[str, Any]) -> str:
+    def format_summary(self, analysis_result: dict[str, Any]) -> str:
         """Format summary for Markdown files"""
         file_path = analysis_result.get("file_path", "")
         elements = analysis_result.get("elements", [])
-        
+
         # Count different types of Markdown elements
         headers = [e for e in elements if e.get("type") == "heading"]
-        links = [e for e in elements if e.get("type") in ["link", "autolink", "reference_link"]]
+        links = [
+            e
+            for e in elements
+            if e.get("type") in ["link", "autolink", "reference_link"]
+        ]
         images = self._collect_images(elements)
         code_blocks = [e for e in elements if e.get("type") == "code_block"]
         lists = [e for e in elements if e.get("type") in ["list", "task_list"]]
-        
+
         # Robust adjust for link/image counts to match other commands
         robust_counts = self._compute_robust_counts_from_file(file_path)
         if len(links) < robust_counts.get("link_count", len(links)):
@@ -37,7 +42,9 @@ class MarkdownFormatter(BaseFormatter):
             missing = robust_counts.get("link_count", 0) - len(links)
             if missing > 0:
                 # Add placeholder autolink entries to align with expected count
-                links = links + [{"text": "autolink", "url": "autolink"} for _ in range(missing)]
+                links = links + [
+                    {"text": "autolink", "url": "autolink"} for _ in range(missing)
+                ]
 
         # Some environments under-detect reference images in elements; align summary with
         # robust image count used elsewhere (structure/advanced) by adding placeholders
@@ -48,35 +55,49 @@ class MarkdownFormatter(BaseFormatter):
             images = images + ([{"alt": "", "url": ""}] * missing)
 
         summary = {
-            "headers": [{"name": h.get("text", "").strip(), "level": h.get("level", 1)} for h in headers],
-            "links": [{"text": l.get("text", ""), "url": l.get("url", "")} for l in links],
-            "images": [{"alt": i.get("alt", ""), "url": i.get("url", "")} for i in images],
-            "code_blocks": [{"language": cb.get("language", ""), "lines": cb.get("line_count", 0)} for cb in code_blocks],
-            "lists": [{"type": l.get("list_type", ""), "items": l.get("item_count", 0)} for l in lists]
-        }
-        
-        result = {
-            "file_path": file_path,
-            "language": "markdown",
-            "summary": summary
+            "headers": [
+                {"name": h.get("text", "").strip(), "level": h.get("level", 1)}
+                for h in headers
+            ],
+            "links": [
+                {"text": link.get("text", ""), "url": link.get("url", "")}
+                for link in links
+            ],
+            "images": [
+                {"alt": i.get("alt", ""), "url": i.get("url", "")} for i in images
+            ],
+            "code_blocks": [
+                {"language": cb.get("language", ""), "lines": cb.get("line_count", 0)}
+                for cb in code_blocks
+            ],
+            "lists": [
+                {"type": lst.get("list_type", ""), "items": lst.get("item_count", 0)}
+                for lst in lists
+            ],
         }
-        
+
+        result = {"file_path": file_path, "language": "markdown", "summary": summary}
+
         return self._format_json_output("Summary Results", result)
 
-    def format_structure(self, analysis_result: Dict[str, Any]) -> str:
+    def format_structure(self, analysis_result: dict[str, Any]) -> str:
         """Format structure analysis for Markdown files"""
         file_path = analysis_result.get("file_path", "")
         elements = analysis_result.get("elements", [])
         line_count = analysis_result.get("line_count", 0)
-        
+
         # Organize elements by type
         headers = [e for e in elements if e.get("type") == "heading"]
-        links = [e for e in elements if e.get("type") in ["link", "autolink", "reference_link"]]
+        links = [
+            e
+            for e in elements
+            if e.get("type") in ["link", "autolink", "reference_link"]
+        ]
         images = self._collect_images(elements)
         code_blocks = [e for e in elements if e.get("type") == "code_block"]
         lists = [e for e in elements if e.get("type") in ["list", "task_list"]]
         tables = [e for e in elements if e.get("type") == "table"]
-        
+
         # Robust counts to avoid undercount due to parser variance
         robust_counts = self._compute_robust_counts_from_file(file_path)
 
@@ -91,43 +112,49 @@ class MarkdownFormatter(BaseFormatter):
                 {
                     "text": h.get("text", "").strip(),
                     "level": h.get("level", 1),
-                    "line_range": h.get("line_range", {})
-                } for h in headers
+                    "line_range": h.get("line_range", {}),
+                }
+                for h in headers
             ],
             "links": [
                 {
-                    "text": l.get("text", ""),
-                    "url": l.get("url", ""),
-                    "line_range": l.get("line_range", {})
-                } for l in links
+                    "text": link.get("text", ""),
+                    "url": link.get("url", ""),
+                    "line_range": link.get("line_range", {}),
+                }
+                for link in links
             ],
             "images": [
                 {
                     "alt": i.get("alt", ""),
                     "url": i.get("url", ""),
-                    "line_range": i.get("line_range", {})
-                } for i in images
+                    "line_range": i.get("line_range", {}),
+                }
+                for i in images
             ],
             "code_blocks": [
                 {
                     "language": cb.get("language", ""),
                     "line_count": cb.get("line_count", 0),
-                    "line_range": cb.get("line_range", {})
-                } for cb in code_blocks
+                    "line_range": cb.get("line_range", {}),
+                }
+                for cb in code_blocks
             ],
             "lists": [
                 {
-                    "type": l.get("list_type", ""),
-                    "item_count": l.get("item_count", 0),
-                    "line_range": l.get("line_range", {})
-                } for l in lists
+                    "type": lst.get("list_type", ""),
+                    "item_count": lst.get("item_count", 0),
+                    "line_range": lst.get("line_range", {}),
+                }
+                for lst in lists
             ],
             "tables": [
                 {
                     "columns": t.get("column_count", 0),
                     "rows": t.get("row_count", 0),
-                    "line_range": t.get("line_range", {})
-                } for t in tables
+                    "line_range": t.get("line_range", {}),
+                }
+                for t in tables
             ],
             "statistics": {
                 "header_count": len(headers),
@@ -137,41 +164,61 @@ class MarkdownFormatter(BaseFormatter):
                 "code_block_count": len(code_blocks),
                 "list_count": len(lists),
                 "table_count": len(tables),
-                "total_lines": line_count
+                "total_lines": line_count,
             },
-            "analysis_metadata": analysis_result.get("analysis_metadata", {})
+            "analysis_metadata": analysis_result.get("analysis_metadata", {}),
         }
-        
+
         return self._format_json_output("Structure Analysis Results", structure)
 
-    def format_advanced(self, analysis_result: Dict[str, Any], output_format: str = "json") -> str:
+    def format_advanced(
+        self, analysis_result: dict[str, Any], output_format: str = "json"
+    ) -> str:
         """Format advanced analysis for Markdown files"""
         file_path = analysis_result.get("file_path", "")
         elements = analysis_result.get("elements", [])
         line_count = analysis_result.get("line_count", 0)
         element_count = len(elements)
-        
+
         # Calculate Markdown-specific metrics
         headers = [e for e in elements if e.get("type") == "heading"]
-        links = [e for e in elements if e.get("type") in ["link", "autolink", "reference_link"]]
+        links = [
+            e
+            for e in elements
+            if e.get("type") in ["link", "autolink", "reference_link"]
+        ]
         images = self._collect_images(elements)
         code_blocks = [e for e in elements if e.get("type") == "code_block"]
         lists = [e for e in elements if e.get("type") in ["list", "task_list"]]
         tables = [e for e in elements if e.get("type") == "table"]
-        
+
         # Calculate document structure metrics
         header_levels = [h.get("level", 1) for h in headers]
         max_header_level = max(header_levels) if header_levels else 0
-        avg_header_level = sum(header_levels) / len(header_levels) if header_levels else 0
-        
+        avg_header_level = (
+            sum(header_levels) / len(header_levels) if header_levels else 0
+        )
+
         # Calculate content metrics
         total_code_lines = sum(cb.get("line_count", 0) for cb in code_blocks)
-        total_list_items = sum(l.get("item_count", 0) for l in lists)
-        
+        total_list_items = sum(lst.get("item_count", 0) for lst in lists)
+
         # External vs internal links
-        external_links = [l for l in links if l.get("url") and l.get("url", "").startswith(("http://", "https://"))]
-        internal_links = [l for l in links if not (l.get("url") and l.get("url", "").startswith(("http://", "https://")))]
-        
+        external_links = [
+            link
+            for link in links
+            if link.get("url")
+            and link.get("url", "").startswith(("http://", "https://"))
+        ]
+        internal_links = [
+            link
+            for link in links
+            if not (
+                link.get("url")
+                and link.get("url", "").startswith(("http://", "https://"))
+            )
+        ]
+
         # Robust counts to avoid undercount due to parser variance
         robust_counts = self._compute_robust_counts_from_file(file_path)
 
@@ -199,43 +246,51 @@ class MarkdownFormatter(BaseFormatter):
                 "total_code_lines": total_code_lines,
                 "list_count": len(lists),
                 "total_list_items": total_list_items,
-                "table_count": len(tables)
+                "table_count": len(tables),
             },
             "content_analysis": {
-                "has_toc": any("table of contents" in h.get("text", "").lower() for h in headers),
+                "has_toc": any(
+                    "table of contents" in h.get("text", "").lower() for h in headers
+                ),
                 "has_code_examples": len(code_blocks) > 0,
                 "has_images": len(images) > 0,
                 "has_external_links": len(external_links) > 0,
-                "document_complexity": self._calculate_document_complexity(headers, links, code_blocks, tables)
-            }
+                "document_complexity": self._calculate_document_complexity(
+                    headers, links, code_blocks, tables
+                ),
+            },
         }
-        
+
         if output_format == "text":
             return self._format_advanced_text(advanced_data)
         else:
             return self._format_json_output("Advanced Analysis Results", advanced_data)
 
-    def format_table(self, analysis_result: Dict[str, Any], table_type: str = "full") -> str:
+    def format_table(
+        self, analysis_result: dict[str, Any], table_type: str = "full"
+    ) -> str:
         """Format table output for Markdown files"""
         file_path = analysis_result.get("file_path", "")
         elements = analysis_result.get("elements", [])
-        
+
         # Get document title from first header
         headers = [e for e in elements if e.get("type") == "heading"]
-        title = headers[0].get("text", "").strip() if headers else file_path.split("/")[-1]
-        
+        title = (
+            headers[0].get("text", "").strip() if headers else file_path.split("/")[-1]
+        )
+
         output = [f"# {title}\n"]
-        
+
         # Document Overview
         output.append("## Document Overview\n")
-        output.append(f"| Property | Value |")
-        output.append(f"|----------|-------|")
+        output.append("| Property | Value |")
+        output.append("|----------|-------|")
         output.append(f"| File | {file_path} |")
-        output.append(f"| Language | markdown |")
+        output.append("| Language | markdown |")
         output.append(f"| Total Lines | {analysis_result.get('line_count', 0)} |")
         output.append(f"| Total Elements | {len(elements)} |")
         output.append("")
-        
+
         # Headers Section
         if headers:
             output.append("## Document Structure\n")
@@ -247,9 +302,13 @@ class MarkdownFormatter(BaseFormatter):
                 line = header.get("line_range", {}).get("start", "")
                 output.append(f"| {level} | {text} | {line} |")
             output.append("")
-        
+
         # Links Section
-        links = [e for e in elements if e.get("type") in ["link", "autolink", "reference_link"]]
+        links = [
+            e
+            for e in elements
+            if e.get("type") in ["link", "autolink", "reference_link"]
+        ]
         if links:
             output.append("## Links\n")
             output.append("| Text | URL | Type | Line |")
@@ -257,11 +316,15 @@ class MarkdownFormatter(BaseFormatter):
             for link in links:
                 text = link.get("text", "")
                 url = link.get("url", "") or ""
-                link_type = "External" if url and url.startswith(("http://", "https://")) else "Internal"
+                link_type = (
+                    "External"
+                    if url and url.startswith(("http://", "https://"))
+                    else "Internal"
+                )
                 line = link.get("line_range", {}).get("start", "")
                 output.append(f"| {text} | {url} | {link_type} | {line} |")
             output.append("")
-        
+
         # Images Section
         images = self._collect_images(elements)
         if images:
@@ -274,7 +337,7 @@ class MarkdownFormatter(BaseFormatter):
                 line = image.get("line_range", {}).get("start", "")
                 output.append(f"| {alt} | {url} | {line} |")
             output.append("")
-        
+
         # Code Blocks Section
         code_blocks = [e for e in elements if e.get("type") == "code_block"]
         if code_blocks:
@@ -290,7 +353,7 @@ class MarkdownFormatter(BaseFormatter):
                 range_str = f"{start}-{end}" if start and end else str(start)
                 output.append(f"| {language} | {lines} | {range_str} |")
             output.append("")
-        
+
         # Lists Section
         lists = [e for e in elements if e.get("type") in ["list", "task_list"]]
         if lists:
@@ -303,7 +366,7 @@ class MarkdownFormatter(BaseFormatter):
                 line = lst.get("line_range", {}).get("start", "")
                 output.append(f"| {list_type} | {items} | {line} |")
             output.append("")
-        
+
         # Tables Section
         tables = [e for e in elements if e.get("type") == "table"]
         if tables:
@@ -316,7 +379,7 @@ class MarkdownFormatter(BaseFormatter):
                 line = table.get("line_range", {}).get("start", "")
                 output.append(f"| {columns} | {rows} | {line} |")
             output.append("")
-        
+
         # Blockquotes Section
         blockquotes = [e for e in elements if e.get("type") == "blockquote"]
         if blockquotes:
@@ -324,11 +387,15 @@ class MarkdownFormatter(BaseFormatter):
             output.append("| Content | Line |")
             output.append("|---------|------|")
             for bq in blockquotes:
-                content = bq.get("text", "")[:50] + "..." if len(bq.get("text", "")) > 50 else bq.get("text", "")
+                content = (
+                    bq.get("text", "")[:50] + "..."
+                    if len(bq.get("text", "")) > 50
+                    else bq.get("text", "")
+                )
                 line = bq.get("line_range", {}).get("start", "")
                 output.append(f"| {content} | {line} |")
             output.append("")
-        
+
         # Horizontal Rules Section
         horizontal_rules = [e for e in elements if e.get("type") == "horizontal_rule"]
         if horizontal_rules:
@@ -339,46 +406,69 @@ class MarkdownFormatter(BaseFormatter):
                 line = hr.get("line_range", {}).get("start", "")
                 output.append(f"| Horizontal Rule | {line} |")
             output.append("")
-        
+
         # HTML Elements Section
-        html_elements = [e for e in elements if e.get("type") in ["html_block", "html_inline"]]
+        html_elements = [
+            e for e in elements if e.get("type") in ["html_block", "html_inline"]
+        ]
         if html_elements:
             output.append("## HTML Elements\n")
             output.append("| Type | Content | Line |")
             output.append("|------|---------|------|")
             for html in html_elements:
                 element_type = html.get("type", "")
-                content = html.get("name", "")[:30] + "..." if len(html.get("name", "")) > 30 else html.get("name", "")
+                content = (
+                    html.get("name", "")[:30] + "..."
+                    if len(html.get("name", "")) > 30
+                    else html.get("name", "")
+                )
                 line = html.get("line_range", {}).get("start", "")
                 output.append(f"| {element_type} | {content} | {line} |")
             output.append("")
-        
+
         # Text Formatting Section
-        formatting_elements = [e for e in elements if e.get("type") in ["strong_emphasis", "emphasis", "inline_code", "strikethrough"]]
+        formatting_elements = [
+            e
+            for e in elements
+            if e.get("type")
+            in ["strong_emphasis", "emphasis", "inline_code", "strikethrough"]
+        ]
         if formatting_elements:
             output.append("## Text Formatting\n")
             output.append("| Type | Content | Line |")
             output.append("|------|---------|------|")
             for fmt in formatting_elements:
                 format_type = fmt.get("type", "")
-                content = fmt.get("text", "")[:30] + "..." if len(fmt.get("text", "")) > 30 else fmt.get("text", "")
+                content = (
+                    fmt.get("text", "")[:30] + "..."
+                    if len(fmt.get("text", "")) > 30
+                    else fmt.get("text", "")
+                )
                 line = fmt.get("line_range", {}).get("start", "")
                 output.append(f"| {format_type} | {content} | {line} |")
             output.append("")
-        
+
         # Footnotes Section
-        footnotes = [e for e in elements if e.get("type") in ["footnote_reference", "footnote_definition"]]
+        footnotes = [
+            e
+            for e in elements
+            if e.get("type") in ["footnote_reference", "footnote_definition"]
+        ]
         if footnotes:
             output.append("## Footnotes\n")
             output.append("| Type | Content | Line |")
             output.append("|------|---------|------|")
             for fn in footnotes:
                 footnote_type = fn.get("type", "")
-                content = fn.get("text", "")[:30] + "..." if len(fn.get("text", "")) > 30 else fn.get("text", "")
+                content = (
+                    fn.get("text", "")[:30] + "..."
+                    if len(fn.get("text", "")) > 30
+                    else fn.get("text", "")
+                )
                 line = fn.get("line_range", {}).get("start", "")
                 output.append(f"| {footnote_type} | {content} | {line} |")
             output.append("")
-        
+
         # Reference Definitions Section
         references = [e for e in elements if e.get("type") == "reference_definition"]
         if references:
@@ -386,33 +476,42 @@ class MarkdownFormatter(BaseFormatter):
             output.append("| Content | Line |")
             output.append("|---------|------|")
             for ref in references:
-                content = ref.get("name", "")[:50] + "..." if len(ref.get("name", "")) > 50 else ref.get("name", "")
+                content = (
+                    ref.get("name", "")[:50] + "..."
+                    if len(ref.get("name", "")) > 50
+                    else ref.get("name", "")
+                )
                 line = ref.get("line_range", {}).get("start", "")
                 output.append(f"| {content} | {line} |")
             output.append("")
-        
+
         return "\n".join(output)
 
-    def _collect_images(self, elements: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _collect_images(self, elements: list[dict[str, Any]]) -> list[dict[str, Any]]:
         """Collect images including reference definitions that point to images.
 
         Fallback: if no explicit image reference definitions are present, also
         treat reference definitions with image-like URLs as images to keep
         counts consistent across environments.
         """
-        images: List[Dict[str, Any]] = [
-            e for e in elements
-            if e.get("type") in ["image", "reference_image", "image_reference_definition"]
+        images: list[dict[str, Any]] = [
+            e
+            for e in elements
+            if e.get("type")
+            in ["image", "reference_image", "image_reference_definition"]
         ]
 
         # Avoid duplicates if image reference definitions already exist
-        has_image_ref_defs = any(e.get("type") == "image_reference_definition" for e in elements)
+        has_image_ref_defs = any(
+            e.get("type") == "image_reference_definition" for e in elements
+        )
         if has_image_ref_defs:
             return images
 
         # Fallback: promote reference_definition with image-like URL
         try:
             import re
+
             image_exts = (".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".bmp")
             for e in elements:
                 if e.get("type") == "reference_definition":
@@ -421,33 +520,35 @@ class MarkdownFormatter(BaseFormatter):
                     if not url:
                         # Parse from raw content stored in name
                         name_field = (e.get("name") or "").strip()
-                        m = re.match(r'^\[([^\]]+)\]:\s*([^\s]+)', name_field)
+                        m = re.match(r"^\[([^\]]+)\]:\s*([^\s]+)", name_field)
                         if m:
                             alt = alt or m.group(1)
                             url = m.group(2)
                     if url and any(url.lower().endswith(ext) for ext in image_exts):
-                        images.append({
-                            **e,
-                            "type": "image_reference_definition",
-                            "url": url,
-                            "alt": alt,
-                        })
+                        images.append(
+                            {
+                                **e,
+                                "type": "image_reference_definition",
+                                "url": url,
+                                "alt": alt,
+                            }
+                        )
         except Exception:
             # Be conservative on any error
             return images
 
         return images
 
-    def _format_advanced_text(self, data: Dict[str, Any]) -> str:
+    def _format_advanced_text(self, data: dict[str, Any]) -> str:
         """Format advanced analysis in text format"""
         output = ["--- Advanced Analysis Results ---"]
-        
+
         # Basic info - format with quotes to match expected output
         output.append(f'"File: {data["file_path"]}"')
         output.append(f'"Language: {data["language"]}"')
         output.append(f'"Lines: {data["line_count"]}"')
         output.append(f'"Elements: {data["element_count"]}"')
-        
+
         # Document metrics
         metrics = data["document_metrics"]
         output.append(f'"Headers: {metrics["header_count"]}"')
@@ -459,7 +560,7 @@ class MarkdownFormatter(BaseFormatter):
         output.append(f'"Code Lines: {metrics["total_code_lines"]}"')
         output.append(f'"Lists: {metrics["list_count"]}"')
         output.append(f'"Tables: {metrics["table_count"]}"')
-        
+
         # Content analysis
         content = data["content_analysis"]
         output.append(f'"Has TOC: {content["has_toc"]}"')
@@ -467,26 +568,31 @@ class MarkdownFormatter(BaseFormatter):
         output.append(f'"Has Images: {content["has_images"]}"')
         output.append(f'"Has External Links: {content["has_external_links"]}"')
         output.append(f'"Document Complexity: {content["document_complexity"]}"')
-        
+
         return "\n".join(output)
 
-    def _calculate_document_complexity(self, headers: List[Dict], links: List[Dict], 
-                                     code_blocks: List[Dict], tables: List[Dict]) -> str:
+    def _calculate_document_complexity(
+        self,
+        headers: list[dict],
+        links: list[dict],
+        code_blocks: list[dict],
+        tables: list[dict],
+    ) -> str:
         """Calculate document complexity based on structure and content"""
         score = 0
-        
+
         # Header complexity
         if headers:
             header_levels = [h.get("level", 1) for h in headers]
             max_level = max(header_levels)
             score += len(headers) * 2  # Base score for headers
-            score += max_level * 3     # Deeper nesting increases complexity
-        
+            score += max_level * 3  # Deeper nesting increases complexity
+
         # Content complexity
-        score += len(links) * 1        # Links add moderate complexity
+        score += len(links) * 1  # Links add moderate complexity
         score += len(code_blocks) * 5  # Code blocks add significant complexity
-        score += len(tables) * 3       # Tables add moderate complexity
-        
+        score += len(tables) * 3  # Tables add moderate complexity
+
         # Classify complexity
         if score < 20:
             return "Simple"
@@ -497,36 +603,44 @@ class MarkdownFormatter(BaseFormatter):
         else:
             return "Very Complex"
 
-    def _format_json_output(self, title: str, data: Dict[str, Any]) -> str:
+    def _format_json_output(self, title: str, data: dict[str, Any]) -> str:
         """Format JSON output with title"""
         import json
+
         output = [f"--- {title} ---"]
         output.append(json.dumps(data, indent=2, ensure_ascii=False))
         return "\n".join(output)
 
-    def _compute_robust_counts_from_file(self, file_path: str) -> Dict[str, int]:
+    def _compute_robust_counts_from_file(self, file_path: str) -> dict[str, int]:
         """Compute robust counts for links and images directly from file content.
 
         This mitigates occasional undercount from AST element extraction by
         scanning the raw Markdown text with regex patterns.
         """
         import re
+
         counts = {"link_count": 0, "image_count": 0}
         if not file_path:
             return counts
 
         try:
-            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            with open(file_path, encoding="utf-8", errors="replace") as f:
                 content = f.read()
         except Exception:
             return counts
 
         # Autolinks (URLs, mailto, and bare emails), exclude HTML tags by pattern
-        autolink_pattern = re.compile(r"<(?:https?://[^>]+|mailto:[^>]+|[^@\s]+@[^@\s]+\.[^@\s]+)>")
+        autolink_pattern = re.compile(
+            r"<(?:https?://[^>]+|mailto:[^>]+|[^@\s]+@[^@\s]+\.[^@\s]+)>"
+        )
 
         # Count inline links (subtract image inlines later)
-        inline_links_all = re.findall(r"\[[^\]]*\]\(([^)\s]+)(?:\s+\"[^\"]*\")?\)", content)
-        inline_images = re.findall(r"!\[[^\]]*\]\(([^)\s]+)(?:\s+\"[^\"]*\")?\)", content)
+        inline_links_all = re.findall(
+            r"\[[^\]]*\]\(([^)\s]+)(?:\s+\"[^\"]*\")?\)", content
+        )
+        inline_images = re.findall(
+            r"!\[[^\]]*\]\(([^)\s]+)(?:\s+\"[^\"]*\")?\)", content
+        )
         inline_links = max(0, len(inline_links_all) - len(inline_images))
 
         # Count reference links (subtract image references later)
@@ -544,14 +658,23 @@ class MarkdownFormatter(BaseFormatter):
         # Reference images occurrences
         ref_images_count = len(ref_images)
         # Image reference definitions used by images
-        used_labels = set(m.group(1).lower() for m in re.finditer(r"!\[[^\]]*\]\[([^\]]*)\]", content))
-        def_pattern = re.compile(r"^\[([^\]]+)\]:\s*([^\s]+)(?:\s+\"([^\"]*)\")?", re.MULTILINE)
+        used_labels = {
+            m.group(1).lower() for m in re.finditer(r"!\[[^\]]*\]\[([^\]]*)\]", content)
+        }
+        def_pattern = re.compile(
+            r"^\[([^\]]+)\]:\s*([^\s]+)(?:\s+\"([^\"]*)\")?", re.MULTILINE
+        )
         image_ref_defs_used = 0
         for m in def_pattern.finditer(content):
             label = (m.group(1) or "").lower()
             url = (m.group(2) or "").lower()
-            if label in used_labels or any(url.endswith(ext) for ext in [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".bmp"]):
+            if label in used_labels or any(
+                url.endswith(ext)
+                for ext in [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".bmp"]
+            ):
                 image_ref_defs_used += 1
 
-        counts["image_count"] = inline_images_count + ref_images_count + image_ref_defs_used
-        return counts
+        counts["image_count"] = (
+            inline_images_count + ref_images_count + image_ref_defs_used
+        )
+        return counts