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

woolly/cache.py

@@ -14,6 +14,10 @@ CACHE_DIR = Path.home() / ".cache" / "woolly"
 DEFAULT_CACHE_TTL = 86400 * 7  # 7 days
 FEDORA_CACHE_TTL = 86400  # 1 day for Fedora repoquery data
 
+# Track which namespace directories have already been created so that
+# ``mkdir`` is only called once per namespace per process lifetime.
+_ensured_namespaces: set[str] = set()
+
 
 class CacheEntry(BaseModel):
     """A cached value with timestamp."""
@@ -23,17 +27,28 @@ class CacheEntry(BaseModel):
 
 
 def ensure_cache_dir() -> None:
-    """Create cache directory if it doesn't exist."""
+    """Create the top-level cache directory if it doesn't exist.
+
+    This is idempotent but cheap after the first call because the
+    directory will already exist.
+    """
     CACHE_DIR.mkdir(parents=True, exist_ok=True)
 
 
 def get_cache_path(namespace: str, key: str) -> Path:
-    """Get path for a cache entry."""
-    ensure_cache_dir()
-    ns_dir = CACHE_DIR / namespace
-    ns_dir.mkdir(exist_ok=True)
+    """Get path for a cache entry.
+
+    Namespace directories are only created once per process lifetime
+    to avoid repeated filesystem calls.
+    """
+    if namespace not in _ensured_namespaces:
+        ensure_cache_dir()
+        ns_dir = CACHE_DIR / namespace
+        ns_dir.mkdir(exist_ok=True)
+        _ensured_namespaces.add(namespace)
+
     safe_key = hashlib.md5(key.encode()).hexdigest()
-    return ns_dir / f"{safe_key}.json"
+    return CACHE_DIR / namespace / f"{safe_key}.json"
 
 
 def read_cache(namespace: str, key: str, ttl: int = DEFAULT_CACHE_TTL) -> Optional[Any]:

woolly/commands/check.py

@@ -2,21 +2,36 @@
 Check command - analyze package dependencies for Fedora availability.
 """
 
+import fnmatch
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
 from typing import Annotated, Optional
 
 import cyclopts
 from pydantic import BaseModel, Field
+from rich.panel import Panel
+from rich.text import Text
 from rich.tree import Tree
 
 from woolly.cache import CACHE_DIR
 from woolly.commands import app, console
 from woolly.debug import get_log_file, log, log_package_check, setup_logger
 from woolly.languages import get_available_languages, get_provider
-from woolly.languages.base import LanguageProvider
+from woolly.languages.base import Dependency, FeatureInfo, LanguageProvider
 from woolly.progress import ProgressTracker
 from woolly.reporters import ReportData, get_available_formats, get_reporter
 
 
+class DevBuildDepStatus(BaseModel):
+    """Status of a dev or build dependency."""
+
+    name: str
+    version_requirement: str
+    is_packaged: bool
+    fedora_versions: list[str] = Field(default_factory=list)
+    fedora_packages: list[str] = Field(default_factory=list)
+
+
 class TreeStats(BaseModel):
     """Statistics collected from dependency tree analysis."""
 
@@ -29,6 +44,39 @@ class TreeStats(BaseModel):
     optional_packaged: int = 0
     optional_missing: int = 0
     optional_missing_list: list[str] = Field(default_factory=list)
+    dev_total: int = 0
+    dev_packaged: int = 0
+    dev_missing: int = 0
+    build_total: int = 0
+    build_packaged: int = 0
+    build_missing: int = 0
+
+
+def _compute_stats_from_visited(visited: dict) -> TreeStats:
+    """Compute statistics directly from the *visited* dict built during tree traversal.
+
+    This replaces the old ``collect_stats`` approach that parsed Rich
+    markup strings, which was fragile and wasteful.  The *visited* dict
+    already contains all the structured information we need:
+    ``{package_name: (is_packaged, version, is_optional)}``.
+    """
+    stats = TreeStats()
+    for pkg_name, (is_packaged, _version, is_optional) in visited.items():
+        stats.total += 1
+        if is_optional:
+            stats.optional_total += 1
+        if is_packaged:
+            stats.packaged += 1
+            stats.packaged_list.append(pkg_name)
+            if is_optional:
+                stats.optional_packaged += 1
+        else:
+            stats.missing += 1
+            stats.missing_list.append(pkg_name)
+            if is_optional:
+                stats.optional_missing += 1
+                stats.optional_missing_list.append(pkg_name)
+    return stats
 
 
 def build_tree(
@@ -41,6 +89,7 @@ def build_tree(
     tracker: Optional[ProgressTracker] = None,
     include_optional: bool = False,
     is_optional_dep: bool = False,
+    exclude_patterns: Optional[list[str]] = None,
 ):
     """
     Recursively build a dependency tree for a package.
@@ -55,6 +104,7 @@ def build_tree(
         Specific version, or None for latest.
     visited
         Dict of already-visited packages mapping to their status.
+        Each value is a tuple ``(is_packaged, version, is_optional)``.
     depth
         Current recursion depth.
     max_depth
@@ -65,6 +115,8 @@ def build_tree(
         If True, include optional dependencies in the analysis.
     is_optional_dep
         If True, this package is an optional dependency.
+    exclude_patterns
+        List of glob patterns to exclude from the dependency tree.
 
     Returns
     -------
@@ -81,7 +133,7 @@ def build_tree(
         return f"[dim]{package_name}{optional_marker} (max depth reached)[/dim]"
 
     if package_name in visited:
-        is_packaged, cached_version = visited[package_name]
+        is_packaged, cached_version, _ = visited[package_name]
         log_package_check(
             package_name,
             "Skip (already visited)",
@@ -97,10 +149,12 @@ def build_tree(
 
     log_package_check(package_name, "Fetching version", source=provider.registry_name)
 
+    # Fetch full package info to get version and license
+    pkg_info = None
     if version is None:
-        version = provider.get_latest_version(package_name)
-        if version is None:
-            visited[package_name] = (False, None)
+        pkg_info = provider.fetch_package_info(package_name)
+        if pkg_info is None:
+            visited[package_name] = (False, None, is_optional_dep)
             log_package_check(
                 package_name, "Not found", source=provider.registry_name, result="error"
             )
@@ -108,12 +162,19 @@ def build_tree(
                 f"[bold red]{package_name}[/bold red]{optional_marker} • "
                 f"[red]not found on {provider.registry_name}[/red]"
             )
+        version = pkg_info.latest_version
+    else:
+        pkg_info = provider.fetch_package_info(package_name)
+
+    license_str = ""
+    if pkg_info and pkg_info.license:
+        license_str = f" [magenta]({pkg_info.license})[/magenta]"
 
     log_package_check(package_name, "Checking Fedora", source="dnf repoquery")
 
     # Check Fedora packaging status
     status = provider.check_fedora_packaging(package_name)
-    visited[package_name] = (status.is_packaged, version)
+    visited[package_name] = (status.is_packaged, version, is_optional_dep)
 
     if status.is_packaged:
         log_package_check(
@@ -128,14 +189,14 @@ def build_tree(
         ver_str = ", ".join(status.versions) if status.versions else "unknown"
         pkg_str = ", ".join(status.package_names) if status.package_names else ""
         label = (
-            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{optional_marker} • "
+            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{license_str}{optional_marker} • "
             f"[green]✓ packaged[/green] [dim]({ver_str})[/dim]"
         )
         if pkg_str:
             label += f" [dim cyan][{pkg_str}][/dim cyan]"
     else:
         label = (
-            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{optional_marker} • "
+            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{license_str}{optional_marker} • "
             f"[red]✗ not packaged[/red]"
         )
 
@@ -156,6 +217,12 @@ def build_tree(
         tracker.update(package_name, discovered=len(deps))
 
     for dep_name, _dep_req, dep_is_optional in deps:
+        # Skip dependencies matching exclude patterns
+        if exclude_patterns:
+            if any(fnmatch.fnmatch(dep_name, pattern) for pattern in exclude_patterns):
+                log(f"Filtered out dependency: {dep_name}", level="info", depth=depth)
+                continue
+
         child = build_tree(
             provider,
             dep_name,
@@ -166,6 +233,7 @@ def build_tree(
             tracker,
             include_optional=include_optional,
             is_optional_dep=dep_is_optional,
+            exclude_patterns=exclude_patterns,
         )
         if isinstance(child, str):
             node.add(child)
@@ -179,72 +247,22 @@ def build_tree(
     return node
 
 
-def collect_stats(tree, stats: Optional[TreeStats] = None) -> TreeStats:
-    """Walk the tree and collect statistics."""
-    if stats is None:
-        stats = TreeStats()
+def _check_fedora_for_dep(
+    provider: LanguageProvider, dep: Dependency
+) -> DevBuildDepStatus:
+    """Check Fedora packaging status for a single dev/build dependency.
 
-    def walk(t):
-        if isinstance(t, str):
-            stats.total += 1
-            is_optional = "(optional)" in t
-            if is_optional:
-                stats.optional_total += 1
-            if "not packaged" in t or "not found" in t:
-                stats.missing += 1
-                # Handle both [bold] and [bold red] formats
-                if "[/bold]" in t:
-                    name = t.split("[/bold]")[0].split("]")[-1]
-                elif "[/bold red]" in t:
-                    name = t.split("[/bold red]")[0].split("[bold red]")[-1]
-                else:
-                    name = t.split()[0]
-                stats.missing_list.append(name)
-                if is_optional:
-                    stats.optional_missing += 1
-                    stats.optional_missing_list.append(name)
-            elif "packaged" in t:
-                stats.packaged += 1
-                if is_optional:
-                    stats.optional_packaged += 1
-            return
-
-        if hasattr(t, "label"):
-            label = str(t.label)
-            stats.total += 1
-            is_optional = "(optional)" in label
-            if is_optional:
-                stats.optional_total += 1
-            if "not packaged" in label or "not found" in label:
-                stats.missing += 1
-                # Handle both [bold] and [bold red] formats
-                if "[bold]" in label and "[bold red]" not in label:
-                    name = label.split("[/bold]")[0].split("[bold]")[-1]
-                elif "[bold red]" in label:
-                    name = label.split("[/bold red]")[0].split("[bold red]")[-1]
-                else:
-                    name = "unknown"
-                stats.missing_list.append(name)
-                if is_optional:
-                    stats.optional_missing += 1
-                    stats.optional_missing_list.append(name)
-            elif "packaged" in label:
-                stats.packaged += 1
-                name = (
-                    label.split("[/bold]")[0].split("[bold]")[-1]
-                    if "[bold]" in label
-                    else "unknown"
-                )
-                stats.packaged_list.append(name)
-                if is_optional:
-                    stats.optional_packaged += 1
-
-        if hasattr(t, "children"):
-            for child in t.children:
-                walk(child)
-
-    walk(tree)
-    return stats
+    This is extracted as a standalone function so it can be submitted to
+    a :class:`~concurrent.futures.ThreadPoolExecutor`.
+    """
+    fedora_status = provider.check_fedora_packaging(dep.name)
+    return DevBuildDepStatus(
+        name=dep.name,
+        version_requirement=dep.version_requirement,
+        is_packaged=fedora_status.is_packaged,
+        fedora_versions=fedora_status.versions,
+        fedora_packages=fedora_status.package_names,
+    )
 
 
 @app.command(name="check")
@@ -306,6 +324,42 @@ def check(
             help="Report format: stdout, json, markdown. Use 'list-formats' for all options.",
         ),
     ] = "stdout",
+    missing_only: Annotated[
+        bool,
+        cyclopts.Parameter(
+            ("--missing-only", "-m"),
+            negative=(),
+            help="Only display packages that are missing from Fedora.",
+        ),
+    ] = False,
+    exclude: Annotated[
+        tuple[str, ...],
+        cyclopts.Parameter(
+            ("--exclude", "-e"),
+            help="Glob pattern(s) to exclude dependencies (e.g., '*-windows', 'win*'). Can be specified multiple times.",
+        ),
+    ] = (),
+    template: Annotated[
+        Optional[str],
+        cyclopts.Parameter(
+            ("--template", "-t"),
+            help="Path to a Jinja2 template file for custom report format. Only used with --report=template.",
+        ),
+    ] = None,
+    release: Annotated[
+        Optional[str],
+        cyclopts.Parameter(
+            ("--release", "-R"),
+            help="Fedora release version to check against (e.g., '41', '42', 'rawhide').",
+        ),
+    ] = None,
+    repos: Annotated[
+        tuple[str, ...],
+        cyclopts.Parameter(
+            ("--repos",),
+            help="Fedora repo(s) to query (e.g., 'fedora', 'updates', 'updates-testing'). Can be specified multiple times.",
+        ),
+    ] = (),
 ):
     """Check if a package's dependencies are available in Fedora.
 
@@ -327,6 +381,16 @@ def check(
         Enable verbose debug logging.
     report
         Output format for the report.
+    missing_only
+        Only display packages that are missing from Fedora.
+    exclude
+        Glob pattern(s) to exclude dependencies from the analysis.
+    template
+        Path to a Jinja2 template file for custom report format.
+    release
+        Fedora release version to check against (e.g., '41', 'rawhide').
+    repos
+        Fedora repo(s) to query (e.g., 'fedora', 'updates', 'updates-testing').
     """
     # Get the language provider
     provider = get_provider(lang)
@@ -336,12 +400,40 @@ def check(
         raise SystemExit(1)
 
     # Get the reporter
-    reporter = get_reporter(report, console=console)
+    template_path = Path(template) if template else None
+
+    # Validate template reporter requirements
+    if report.lower() in ("template", "tpl", "jinja", "jinja2"):
+        if template_path is None:
+            console.print("[red]Template reporter requires --template parameter.[/red]")
+            console.print(
+                "Example: woolly check mypackage --report=template --template=my_template.md"
+            )
+            raise SystemExit(1)
+        if not template_path.exists():
+            console.print(f"[red]Template file not found: {template_path}[/red]")
+            raise SystemExit(1)
+    elif template_path is not None:
+        console.print(
+            "[yellow]Warning: --template is only used with --report=template[/yellow]"
+        )
+
+    reporter = get_reporter(report, console=console, template_path=template_path)
     if reporter is None:
         console.print(f"[red]Unknown report format: {report}[/red]")
         console.print(f"Available formats: {', '.join(get_available_formats())}")
         raise SystemExit(1)
 
+    # Convert exclude tuple to list for consistency
+    exclude_patterns = list(exclude) if exclude else None
+
+    # Configure Fedora release / repo targeting on the provider
+    fedora_repos_list = list(repos) if repos else None
+    if release:
+        provider.fedora_release = release
+    if fedora_repos_list:
+        provider.fedora_repos = fedora_repos_list
+
     # Initialize logging
     setup_logger(debug=debug)
     log(
@@ -352,30 +444,66 @@ def check(
         include_optional=optional,
         debug=debug,
         report_format=report,
+        exclude_patterns=exclude_patterns,
+        fedora_release=release,
+        fedora_repos=fedora_repos_list,
     )
 
-    console.print(
-        f"\n[bold underline]Analyzing {provider.display_name} package:[/] {package}"
-    )
+    # ── Fetch root package info once (reused for license, version,
+    #    features, and dev/build deps – avoids redundant calls) ──
+    root_info = provider.fetch_package_info(package)
+    root_license = root_info.license if root_info else None
+    resolved_version = version or (root_info.latest_version if root_info else None)
+
+    header = Text()
+    header.append(package, style="bold cyan")
+    header.append(f" ({provider.display_name})\n", style="dim")
+    header.append(f"Registry:  {provider.registry_name}\n", style="dim")
+    header.append(f"Cache:     {CACHE_DIR}", style="dim")
+    if release:
+        header.append("\n")
+        header.append(f"Release:   {release}", style="dim")
+    if fedora_repos_list:
+        header.append("\n")
+        header.append(f"Repos:     {', '.join(fedora_repos_list)}", style="dim")
     if optional:
-        console.print("[yellow]Including optional dependencies[/yellow]")
-    console.print(f"[dim]Registry: {provider.registry_name}[/dim]")
-    console.print(f"[dim]Cache directory: {CACHE_DIR}[/dim]")
+        header.append("\n")
+        header.append("Including optional dependencies", style="yellow")
+    if exclude_patterns:
+        header.append("\n")
+        header.append(
+            f"Excluding dependencies matching: {', '.join(exclude_patterns)}",
+            style="yellow",
+        )
+
     console.print()
+    console.print(
+        Panel(
+            header,
+            title="[bold]Analyzing Dependencies[/bold]",
+            border_style="blue",
+            padding=(0, 1),
+        )
+    )
 
     tracker = None if no_progress else ProgressTracker(console)
 
     if tracker:
         tracker.start(f"Analyzing {provider.display_name} dependencies")
 
+    # Shared visited dict – build_tree populates it, then we derive stats.
+    visited: dict[str, tuple[bool, Optional[str], bool]] = {}
+
     try:
         tree = build_tree(
             provider,
             package,
             version,
+            visited=visited,
             max_depth=max_depth,
             tracker=tracker,
             include_optional=optional,
+            exclude_patterns=exclude_patterns,
         )
         if tracker:
             tracker.finish()
@@ -386,8 +514,49 @@ def check(
 
     console.print()
 
-    # Collect statistics
-    stats = collect_stats(tree)
+    # ── Collect statistics directly from the visited dict ──
+    stats = _compute_stats_from_visited(visited)
+
+    # Fetch features/extras for the root package
+    features: list[FeatureInfo] = []
+    if resolved_version:
+        features = provider.fetch_features(package, resolved_version)
+
+    # ── Fetch dev and build deps in one call, check Fedora in parallel ──
+    dev_deps_status: list[DevBuildDepStatus] = []
+    build_deps_status: list[DevBuildDepStatus] = []
+
+    if resolved_version:
+        # Single fetch_dependencies call partitioned by kind
+        _normal, dev_deps, build_deps = provider.get_all_dependencies(
+            package, resolved_version, include_optional=optional
+        )
+
+        all_devbuild: list[Dependency] = dev_deps + build_deps
+        if all_devbuild:
+            # Check Fedora status for dev/build deps in parallel
+            results: dict[str, DevBuildDepStatus] = {}
+            with ThreadPoolExecutor(max_workers=4) as executor:
+                future_to_dep = {
+                    executor.submit(_check_fedora_for_dep, provider, dep): dep
+                    for dep in all_devbuild
+                }
+                for future in as_completed(future_to_dep):
+                    dep = future_to_dep[future]
+                    results[dep.name] = future.result()
+
+            # Preserve original ordering
+            for dep in dev_deps:
+                dev_deps_status.append(results[dep.name])
+            for dep in build_deps:
+                build_deps_status.append(results[dep.name])
+
+    stats.dev_total = len(dev_deps_status)
+    stats.dev_packaged = sum(1 for d in dev_deps_status if d.is_packaged)
+    stats.dev_missing = sum(1 for d in dev_deps_status if not d.is_packaged)
+    stats.build_total = len(build_deps_status)
+    stats.build_packaged = sum(1 for d in build_deps_status if d.is_packaged)
+    stats.build_missing = sum(1 for d in build_deps_status if not d.is_packaged)
 
     # Create report data
     report_data = ReportData(
@@ -407,6 +576,19 @@ def check(
         optional_packaged=stats.optional_packaged,
         optional_missing=stats.optional_missing,
         optional_missing_packages=stats.optional_missing_list,
+        missing_only=missing_only,
+        root_license=root_license,
+        features=features,
+        dev_dependencies=[d.model_dump() for d in dev_deps_status],
+        build_dependencies=[d.model_dump() for d in build_deps_status],
+        dev_total=stats.dev_total,
+        dev_packaged=stats.dev_packaged,
+        dev_missing=stats.dev_missing,
+        build_total=stats.build_total,
+        build_packaged=stats.build_packaged,
+        build_missing=stats.build_missing,
+        fedora_release=release,
+        fedora_repos=fedora_repos_list,
     )
 
     # Generate report

woolly/http.py

@@ -3,6 +3,8 @@ Shared HTTP client configuration for API requests.
 
 This module provides centralized HTTP configuration including
 the User-Agent header and common request settings.
+Uses a lazily-initialized ``httpx.Client`` for connection pooling
+and keep-alive across repeated requests to the same host.
 """
 
 import httpx
@@ -17,18 +19,35 @@ DEFAULT_HEADERS = {
     "User-Agent": f"woolly/{VERSION} ({PROJECT_URL})",
 }
 
+# Lazily-initialized shared client for connection pooling
+_client: httpx.Client | None = None
+
+
+def _get_client() -> httpx.Client:
+    """Return the shared ``httpx.Client``, creating it on first use."""
+    global _client
+    if _client is None:
+        _client = httpx.Client(headers=DEFAULT_HEADERS)
+    return _client
+
 
 def get(url: str, **kwargs) -> httpx.Response:
     """
     Make a GET request with default headers.
 
+    Uses a shared ``httpx.Client`` so that TCP connections are
+    reused across requests to the same host.
+
     Args:
         url: The URL to request.
-        **kwargs: Additional arguments passed to httpx.get().
+        **kwargs: Additional arguments passed to ``client.get()``.
 
     Returns:
         httpx.Response object.
     """
     headers = kwargs.pop("headers", {})
-    merged_headers = {**DEFAULT_HEADERS, **headers}
-    return httpx.get(url, headers=merged_headers, **kwargs)
+    client = _get_client()
+    if headers:
+        merged_headers = {**DEFAULT_HEADERS, **headers}
+        return client.get(url, headers=merged_headers, **kwargs)
+    return client.get(url, **kwargs)