woolly 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

woolly/reporters/base.py

@@ -16,24 +16,29 @@ Example:
             ...
 """
 
+import re
 from abc import ABC, abstractmethod
 from datetime import datetime
+from functools import cached_property
 from pathlib import Path
 from typing import Any, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
 
-class PackageStatus(BaseModel):
-    """Status of a single package in the dependency tree."""
+def strip_markup(text: str) -> str:
+    """
+    Strip Rich markup from text.
 
-    name: str
-    version: Optional[str] = None
-    is_packaged: bool
-    fedora_versions: list[str] = Field(default_factory=list)
-    fedora_packages: list[str] = Field(default_factory=list)
-    is_visited: bool = False
-    not_found: bool = False
+    Removes Rich markup tags like [bold], [/bold], [green], etc.
+
+    Args:
+        text: Text containing Rich markup.
+
+    Returns:
+        Plain text without markup.
+    """
+    return re.sub(r"\[/?[^\]]+\]", "", text)
 
 
 class ReportData(BaseModel):
@@ -53,15 +58,36 @@ class ReportData(BaseModel):
     missing_packages: list[str] = Field(default_factory=list)
     packaged_packages: list[str] = Field(default_factory=list)
 
+    # Optional dependency statistics
+    include_optional: bool = False
+    optional_total: int = 0
+    optional_packaged: int = 0
+    optional_missing: int = 0
+    optional_missing_packages: list[str] = Field(default_factory=list)
+
     # Full tree for detailed reports
     tree: Any  # Rich Tree object - not JSON serializable
-    packages: list[PackageStatus] = Field(default_factory=list)
 
     # Metadata
     timestamp: datetime = Field(default_factory=datetime.now)
     max_depth: int = 50
     version: Optional[str] = None
 
+    @cached_property
+    def required_missing_packages(self) -> set[str]:
+        """Get the set of required (non-optional) missing packages."""
+        return set(self.missing_packages) - set(self.optional_missing_packages)
+
+    @cached_property
+    def optional_missing_set(self) -> set[str]:
+        """Get the set of optional missing packages."""
+        return set(self.optional_missing_packages)
+
+    @cached_property
+    def unique_packaged_packages(self) -> set[str]:
+        """Get the unique set of packaged packages."""
+        return set(self.packaged_packages)
+
 
 class Reporter(ABC):
     """
@@ -129,3 +155,59 @@ class Reporter(ABC):
         output_path = output_dir / self.get_output_filename(data)
         output_path.write_text(content)
         return output_path
+
+    # ----------------------------------------------------------------
+    # Shared tree traversal utilities for subclasses
+    # ----------------------------------------------------------------
+
+    def _get_label(self, node) -> str:
+        """
+        Extract the label text from a tree node, handling nested Trees.
+
+        Args:
+            node: A Rich Tree node or string.
+
+        Returns:
+            The label text as a string.
+        """
+        # If it's a string, return it directly
+        if isinstance(node, str):
+            return node
+
+        # Try to get label attribute (Rich Tree has this)
+        if hasattr(node, "label"):
+            label = node.label
+            # If label is None, return empty string
+            if label is None:
+                return ""
+            # If label is another Tree-like object (has its own label), recurse
+            if hasattr(label, "label"):
+                return self._get_label(label)
+            # Otherwise convert to string
+            return str(label)
+
+        # Fallback - shouldn't happen
+        return str(node)
+
+    def _get_children(self, node) -> list:
+        """
+        Get all children from a tree node, flattening nested Trees.
+
+        Args:
+            node: A Rich Tree node.
+
+        Returns:
+            List of child nodes.
+        """
+        children = []
+
+        if hasattr(node, "children"):
+            for child in node.children:
+                # If the child's label is itself a Tree, use that Tree's children
+                if hasattr(child, "label") and hasattr(child.label, "children"):
+                    # The child is a wrapper around another tree
+                    children.append(child.label)
+                else:
+                    children.append(child)
+
+        return children

woolly/reporters/json.py

@@ -5,10 +5,66 @@ Generates a JSON file with structured data for machine consumption.
 """
 
 import re
-import json
-from typing import Any
+from typing import Optional
 
-from woolly.reporters.base import Reporter, ReportData
+from pydantic import BaseModel, Field
+
+from woolly.reporters.base import ReportData, Reporter, strip_markup
+
+
+class TreeNodeData(BaseModel):
+    """Structured data for a single node in the dependency tree."""
+
+    raw: str
+    name: Optional[str] = None
+    version: Optional[str] = None
+    optional: bool = False
+    status: Optional[str] = None
+    is_packaged: Optional[bool] = None
+    fedora_versions: list[str] = Field(default_factory=list)
+    fedora_packages: list[str] = Field(default_factory=list)
+    dependencies: list["TreeNodeData"] = Field(default_factory=list)
+
+
+class ReportMetadata(BaseModel):
+    """Metadata for the JSON report."""
+
+    generated_at: str
+    tool: str = "woolly"
+    root_package: str
+    language: str
+    registry: str
+    version: Optional[str] = None
+    max_depth: int
+    include_optional: bool
+
+
+class ReportSummary(BaseModel):
+    """Summary statistics for the JSON report."""
+
+    total_dependencies: int
+    packaged_count: int
+    missing_count: int
+    optional: "OptionalSummary"
+
+
+class OptionalSummary(BaseModel):
+    """Optional dependency statistics."""
+
+    total: int
+    packaged: int
+    missing: int
+
+
+class JsonReport(BaseModel):
+    """Complete JSON report structure."""
+
+    metadata: ReportMetadata
+    summary: ReportSummary
+    missing_packages: list[str]
+    missing_optional_packages: list[str]
+    packaged_packages: list[str]
+    dependency_tree: TreeNodeData
 
 
 class JsonReporter(Reporter):
@@ -21,125 +77,99 @@ class JsonReporter(Reporter):
 
     def generate(self, data: ReportData) -> str:
         """Generate JSON report content."""
-        report = {
-            "metadata": {
-                "generated_at": data.timestamp.isoformat(),
-                "tool": "woolly",
-                "root_package": data.root_package,
-                "language": data.language,
-                "registry": data.registry,
-                "version": data.version,
-                "max_depth": data.max_depth,
-            },
-            "summary": {
-                "total_dependencies": data.total_dependencies,
-                "packaged_count": data.packaged_count,
-                "missing_count": data.missing_count,
-            },
-            "missing_packages": sorted(set(data.missing_packages)),
-            "packaged_packages": sorted(set(data.packaged_packages)),
-            "dependency_tree": self._tree_to_dict(data.tree),
-        }
-
-        return json.dumps(report, indent=2)
-
-    def _get_label(self, node) -> str:
-        """Extract the label text from a tree node, handling nested Trees."""
-        # If it's a string, return it directly
-        if isinstance(node, str):
-            return node
-
-        # Try to get label attribute (Rich Tree has this)
-        if hasattr(node, "label"):
-            label = node.label
-            # If label is None, return empty string
-            if label is None:
-                return ""
-            # If label is another Tree-like object (has its own label), recurse
-            if hasattr(label, "label"):
-                return self._get_label(label)
-            # Otherwise convert to string
-            return str(label)
-
-        # Fallback - shouldn't happen
-        return str(node)
-
-    def _get_children(self, node) -> list:
-        """Get all children from a tree node, flattening nested Trees."""
-        children = []
-
-        if hasattr(node, "children"):
-            for child in node.children:
-                # If the child's label is itself a Tree, use that Tree's children
-                if hasattr(child, "label") and hasattr(child.label, "children"):
-                    # The child is a wrapper around another tree
-                    children.append(child.label)
-                else:
-                    children.append(child)
-
-        return children
-
-    def _tree_to_dict(self, tree) -> dict[str, Any]:
-        """Convert Rich Tree to dictionary representation."""
+        report = JsonReport(
+            metadata=ReportMetadata(
+                generated_at=data.timestamp.isoformat(),
+                root_package=data.root_package,
+                language=data.language,
+                registry=data.registry,
+                version=data.version,
+                max_depth=data.max_depth,
+                include_optional=data.include_optional,
+            ),
+            summary=ReportSummary(
+                total_dependencies=data.total_dependencies,
+                packaged_count=data.packaged_count,
+                missing_count=data.missing_count,
+                optional=OptionalSummary(
+                    total=data.optional_total,
+                    packaged=data.optional_packaged,
+                    missing=data.optional_missing,
+                ),
+            ),
+            missing_packages=sorted(data.required_missing_packages),
+            missing_optional_packages=sorted(data.optional_missing_set),
+            packaged_packages=sorted(data.unique_packaged_packages),
+            dependency_tree=self._tree_to_model(data.tree),
+        )
+
+        return report.model_dump_json(indent=2)
+
+    def _tree_to_model(self, tree) -> TreeNodeData:
+        """Convert Rich Tree to TreeNodeData model."""
         label = self._get_label(tree)
-        result = self._parse_label(label)
+        node_data = self._parse_label(label)
 
-        # Get children
+        # Get children using inherited method
         children = self._get_children(tree)
 
         if children:
-            result["dependencies"] = [self._tree_to_dict(child) for child in children]
+            node_data.dependencies = [self._tree_to_model(child) for child in children]
+
+        return node_data
 
-        return result
+    def _parse_label(self, label: str) -> TreeNodeData:
+        """Parse a tree label into structured TreeNodeData."""
+        # Strip Rich markup using shared utility
+        clean_label = strip_markup(label)
 
-    def _parse_label(self, label: str) -> dict[str, Any]:
-        """Parse a tree label into structured data."""
-        # Strip Rich markup
-        clean_label = re.sub(r"\[/?[^\]]+\]", "", label)
+        node = TreeNodeData(raw=clean_label.strip())
 
-        result: dict[str, Any] = {
-            "raw": clean_label.strip(),
-        }
+        # Check if this is an optional dependency
+        node.optional = "(optional)" in clean_label
 
         # Try to extract package name and version
-        # Pattern: "package_name vX.Y.Z • status"
-        match = re.match(r"^(\S+)\s*(?:v([\d.]+))?\s*•\s*(.+)$", clean_label.strip())
+        # Pattern: "package_name vX.Y.Z (optional) • status" or "package_name vX.Y.Z • status"
+        match = re.match(
+            r"^(\S+)\s*(?:v([\d.]+))?\s*(?:\(optional\))?\s*•\s*(.+)$",
+            clean_label.strip(),
+        )
         if match:
-            result["name"] = match.group(1)
+            node.name = match.group(1)
             if match.group(2):
-                result["version"] = match.group(2)
+                node.version = match.group(2)
 
             status_text = match.group(3).strip()
             if (
                 "packaged" in status_text.lower()
                 and "not packaged" not in status_text.lower()
             ):
-                result["status"] = "packaged"
+                node.status = "packaged"
                 # Try to extract Fedora versions
                 ver_match = re.search(r"\(([\d., ]+)\)", status_text)
                 if ver_match:
-                    result["fedora_versions"] = [
+                    node.fedora_versions = [
                         v.strip() for v in ver_match.group(1).split(",")
                     ]
                 # Try to extract package names
                 pkg_match = re.search(r"\[([^\]]+)\]", status_text)
                 if pkg_match:
-                    result["fedora_packages"] = [
+                    node.fedora_packages = [
                         p.strip() for p in pkg_match.group(1).split(",")
                     ]
             elif "not packaged" in status_text.lower():
-                result["status"] = "not_packaged"
+                node.status = "not_packaged"
             elif "not found" in status_text.lower():
-                result["status"] = "not_found"
+                node.status = "not_found"
             elif "already visited" in status_text.lower():
-                result["status"] = "visited"
-                result["is_packaged"] = "✓" in status_text
+                node.status = "visited"
+                node.is_packaged = "✓" in status_text
         else:
             # Simpler patterns
             if "already visited" in clean_label:
-                result["status"] = "visited"
-                result["is_packaged"] = "✓" in clean_label
+                node.status = "visited"
+                node.is_packaged = "✓" in clean_label
             elif "max depth" in clean_label:
-                result["status"] = "max_depth_reached"
+                node.status = "max_depth_reached"
 
-        return result
+        return node

woolly/reporters/markdown.py

@@ -4,9 +4,7 @@ Markdown report generator.
 Generates a markdown file with the full dependency analysis.
 """
 
-import re
-
-from woolly.reporters.base import Reporter, ReportData
+from woolly.reporters.base import ReportData, Reporter, strip_markup
 
 
 class MarkdownReporter(Reporter):
@@ -29,6 +27,8 @@ class MarkdownReporter(Reporter):
         lines.append(f"**Registry:** {data.registry}")
         if data.version:
             lines.append(f"**Version:** {data.version}")
+        if data.include_optional:
+            lines.append("**Include optional:** Yes")
         lines.append("")
 
         # Summary
@@ -39,25 +39,43 @@ class MarkdownReporter(Reporter):
         lines.append(f"| Total dependencies checked | {data.total_dependencies} |")
         lines.append(f"| Packaged in Fedora | {data.packaged_count} |")
         lines.append(f"| Missing from Fedora | {data.missing_count} |")
+
+        # Optional dependency stats
+        if data.optional_total > 0:
+            lines.append(f"| Optional dependencies | {data.optional_total} |")
+            lines.append(f"| Optional - Packaged | {data.optional_packaged} |")
+            lines.append(f"| Optional - Missing | {data.optional_missing} |")
         lines.append("")
 
-        # Missing packages
-        if data.missing_packages:
+        # Missing packages - use computed properties from ReportData
+        required_missing = data.required_missing_packages
+        optional_missing = data.optional_missing_set
+
+        if required_missing:
             lines.append("## Missing Packages")
             lines.append("")
             lines.append("The following packages need to be packaged for Fedora:")
             lines.append("")
-            for name in sorted(set(data.missing_packages)):
+            for name in sorted(required_missing):
                 lines.append(f"- `{name}`")
             lines.append("")
 
-        # Packaged packages
-        if data.packaged_packages:
+        if optional_missing:
+            lines.append("## Missing Optional Packages")
+            lines.append("")
+            lines.append("The following optional packages are not available in Fedora:")
+            lines.append("")
+            for name in sorted(optional_missing):
+                lines.append(f"- `{name}` *(optional)*")
+            lines.append("")
+
+        # Packaged packages - use computed property
+        if data.unique_packaged_packages:
             lines.append("## Packaged Packages")
             lines.append("")
             lines.append("The following packages are already available in Fedora:")
             lines.append("")
-            for name in sorted(set(data.packaged_packages)):
+            for name in sorted(data.unique_packaged_packages):
                 lines.append(f"- `{name}`")
             lines.append("")
 
@@ -71,53 +89,17 @@ class MarkdownReporter(Reporter):
 
         return "\n".join(lines)
 
-    def _get_label(self, node) -> str:
-        """Extract the label text from a tree node, handling nested Trees."""
-        # If it's a string, return it directly
-        if isinstance(node, str):
-            return node
-
-        # Try to get label attribute (Rich Tree has this)
-        if hasattr(node, "label"):
-            label = node.label
-            # If label is None, return empty string
-            if label is None:
-                return ""
-            # If label is another Tree-like object (has its own label), recurse
-            if hasattr(label, "label"):
-                return self._get_label(label)
-            # Otherwise convert to string
-            return str(label)
-
-        # Fallback - shouldn't happen
-        return str(node)
-
-    def _get_children(self, node) -> list:
-        """Get all children from a tree node, flattening nested Trees."""
-        children = []
-
-        if hasattr(node, "children"):
-            for child in node.children:
-                # If the child's label is itself a Tree, use that Tree's children
-                if hasattr(child, "label") and hasattr(child.label, "children"):
-                    # The child is a wrapper around another tree
-                    children.append(child.label)
-                else:
-                    children.append(child)
-
-        return children
-
     def _tree_to_text(self, tree, prefix: str = "") -> str:
         """Convert Rich Tree to plain text representation."""
         lines = []
 
-        # Get label text (strip Rich markup)
+        # Get label text (strip Rich markup) using inherited method and shared utility
         label = self._get_label(tree)
-        label = self._strip_markup(label)
+        label = strip_markup(label)
 
         lines.append(label)
 
-        # Get children
+        # Get children using inherited method
         children = self._get_children(tree)
 
         for i, child in enumerate(children):
@@ -133,8 +115,3 @@ class MarkdownReporter(Reporter):
                     lines.append(line)
 
         return "\n".join(lines)
-
-    def _strip_markup(self, text: str) -> str:
-        """Strip Rich markup from text."""
-        # Remove Rich markup tags like [bold], [/bold], [green], etc.
-        return re.sub(r"\[/?[^\]]+\]", "", text)

woolly/reporters/stdout.py

@@ -8,7 +8,7 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
-from woolly.reporters.base import Reporter, ReportData
+from woolly.reporters.base import ReportData, Reporter
 
 
 class StdoutReporter(Reporter):
@@ -36,15 +36,36 @@ class StdoutReporter(Reporter):
         table.add_row("[green]Packaged in Fedora[/green]", str(data.packaged_count))
         table.add_row("[red]Missing from Fedora[/red]", str(data.missing_count))
 
+        # Show optional dependency stats if any were found
+        if data.optional_total > 0:
+            table.add_row("", "")  # Empty row as separator
+            table.add_row(
+                "[yellow]Optional dependencies[/yellow]", str(data.optional_total)
+            )
+            table.add_row("[yellow]  ├─ Packaged[/yellow]", str(data.optional_packaged))
+            table.add_row("[yellow]  └─ Missing[/yellow]", str(data.optional_missing))
+
         self.console.print(table)
         self.console.print()
 
-        # Print missing packages list
+        # Print missing packages list using computed properties
         if data.missing_packages:
-            self.console.print("[bold]Missing packages that need packaging:[/bold]")
-            for name in sorted(set(data.missing_packages)):
-                self.console.print(f"  • {name}")
-            self.console.print()
+            required_missing = data.required_missing_packages
+            optional_missing = data.optional_missing_set
+
+            if required_missing:
+                self.console.print("[bold]Missing packages that need packaging:[/bold]")
+                for name in sorted(required_missing):
+                    self.console.print(f"  • {name}")
+                self.console.print()
+
+            if optional_missing:
+                self.console.print(
+                    "[bold yellow]Missing optional packages:[/bold yellow]"
+                )
+                for name in sorted(optional_missing):
+                    self.console.print(f"  • {name} [dim](optional)[/dim]")
+                self.console.print()
 
         # Print dependency tree
         self.console.print("[bold]Dependency Tree:[/bold]")