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

woolly/languages/rust.py

@@ -7,8 +7,7 @@ Fedora repositories for Rust crate packages.
 
 from typing import Optional
 
-import httpx
-
+from woolly import http
 from woolly.cache import DEFAULT_CACHE_TTL, read_cache, write_cache
 from woolly.debug import (
     log_api_request,
@@ -19,7 +18,6 @@ from woolly.debug import (
 from woolly.languages.base import Dependency, LanguageProvider, PackageInfo
 
 CRATES_API = "https://crates.io/api/v1/crates"
-HEADERS = {"User-Agent": "woolly/0.1.0 (https://github.com/r0x0d/woolly)"}
 
 
 class RustProvider(LanguageProvider):
@@ -50,7 +48,7 @@ class RustProvider(LanguageProvider):
         log_cache_miss(self.cache_namespace, cache_key)
         url = f"{CRATES_API}/{package_name}"
         log_api_request("GET", url)
-        r = httpx.get(url, headers=HEADERS)
+        r = http.get(url)
         log_api_response(r.status_code, r.text[:500] if r.text else None)
 
         if r.status_code == 404:
@@ -91,7 +89,7 @@ class RustProvider(LanguageProvider):
         log_cache_miss(self.cache_namespace, cache_key)
         url = f"{CRATES_API}/{package_name}/{version}/dependencies"
         log_api_request("GET", url)
-        r = httpx.get(url, headers=HEADERS)
+        r = http.get(url)
         log_api_response(r.status_code, r.text[:500] if r.text else None)
 
         if r.status_code != 200:

woolly/reporters/__init__.py

@@ -6,12 +6,26 @@ To add a new format, create a module in this directory that defines a class
 inheriting from Reporter and add it to REPORTERS dict.
 """
 
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, Field
 from rich.console import Console
 
-from woolly.reporters.base import Reporter, ReportData, PackageStatus
-from woolly.reporters.stdout import StdoutReporter
-from woolly.reporters.markdown import MarkdownReporter
+from woolly.reporters.base import ReportData, Reporter, strip_markup
 from woolly.reporters.json import JsonReporter
+from woolly.reporters.markdown import MarkdownReporter
+from woolly.reporters.stdout import StdoutReporter
+from woolly.reporters.template import TemplateReporter
+
+
+class ReporterInfo(BaseModel):
+    """Information about an available reporter."""
+
+    format_id: str
+    description: str
+    aliases: list[str] = Field(default_factory=list)
+
 
 # Registry of available reporters
 # Key: format identifier (used in CLI)
@@ -20,6 +34,7 @@ REPORTERS: dict[str, type[Reporter]] = {
     "stdout": StdoutReporter,
     "markdown": MarkdownReporter,
     "json": JsonReporter,
+    "template": TemplateReporter,
 }
 
 # Aliases for convenience
@@ -27,16 +42,24 @@ ALIASES: dict[str, str] = {
     "md": "markdown",
     "console": "stdout",
     "terminal": "stdout",
+    "tpl": "template",
+    "jinja": "template",
+    "jinja2": "template",
 }
 
 
-def get_reporter(format_name: str, console: Console | None = None) -> Reporter | None:
+def get_reporter(
+    format_name: str,
+    console: Optional[Console] = None,
+    template_path: Optional[Path] = None,
+) -> Optional[Reporter]:
     """
     Get an instantiated reporter for the specified format.
 
     Args:
         format_name: Format identifier or alias (e.g., "json", "markdown", "md")
         console: Console instance for stdout reporter.
+        template_path: Path to template file for template reporter.
 
     Returns:
         Instantiated Reporter, or None if not found.
@@ -54,21 +77,31 @@ def get_reporter(format_name: str, console: Console | None = None) -> Reporter |
     if format_name == "stdout" and console:
         return StdoutReporter(console=console)
 
+    # TemplateReporter needs a template path
+    if format_name == "template":
+        return TemplateReporter(template_path=template_path)
+
     return reporter_class()
 
 
-def list_reporters() -> list[tuple[str, str, list[str]]]:
+def list_reporters() -> list[ReporterInfo]:
     """
     List all available reporters.
 
     Returns:
-        List of tuples: (format_id, description, aliases)
+        List of ReporterInfo objects with format details.
     """
     result = []
     for format_id, reporter_class in REPORTERS.items():
         # Find aliases for this format
         aliases = [alias for alias, target in ALIASES.items() if target == format_id]
-        result.append((format_id, reporter_class.description, aliases))
+        result.append(
+            ReporterInfo(
+                format_id=format_id,
+                description=reporter_class.description,
+                aliases=aliases,
+            )
+        )
     return result
 
 
@@ -80,11 +113,13 @@ def get_available_formats() -> list[str]:
 __all__ = [
     "Reporter",
     "ReportData",
-    "PackageStatus",
+    "ReporterInfo",
     "StdoutReporter",
     "MarkdownReporter",
     "JsonReporter",
+    "TemplateReporter",
     "get_reporter",
     "list_reporters",
     "get_available_formats",
+    "strip_markup",
 ]

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,39 @@ 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
 
+    # Display options
+    missing_only: bool = False
+
+    @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 +158,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,67 @@ 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
+    missing_only: bool = False
+
+
+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 +78,103 @@ 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,
+                missing_only=data.missing_only,
+            ),
+            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),
+            # Skip packaged packages list when missing_only mode is enabled
+            packaged_packages=[]
+            if data.missing_only
+            else 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