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

woolly/cache.py

@@ -8,11 +8,20 @@ import time
 from pathlib import Path
 from typing import Any, Optional
 
+from pydantic import BaseModel, Field, ValidationError
+
 CACHE_DIR = Path.home() / ".cache" / "woolly"
 DEFAULT_CACHE_TTL = 86400 * 7  # 7 days
 FEDORA_CACHE_TTL = 86400  # 1 day for Fedora repoquery data
 
 
+class CacheEntry(BaseModel):
+    """A cached value with timestamp."""
+
+    timestamp: float = Field(default_factory=time.time)
+    value: Any
+
+
 def ensure_cache_dir() -> None:
     """Create cache directory if it doesn't exist."""
     CACHE_DIR.mkdir(parents=True, exist_ok=True)
@@ -35,18 +44,19 @@ def read_cache(namespace: str, key: str, ttl: int = DEFAULT_CACHE_TTL) -> Option
 
     try:
         data = json.loads(path.read_text())
-        if time.time() - data.get("timestamp", 0) > ttl:
+        entry = CacheEntry.model_validate(data)
+        if time.time() - entry.timestamp > ttl:
             return None  # Expired
-        return data.get("value")
-    except (json.JSONDecodeError, KeyError):
+        return entry.value
+    except (json.JSONDecodeError, KeyError, ValidationError):
         return None
 
 
 def write_cache(namespace: str, key: str, value: Any) -> None:
     """Write to disk cache."""
     path = get_cache_path(namespace, key)
-    data = {"timestamp": time.time(), "value": value}
-    path.write_text(json.dumps(data))
+    entry = CacheEntry(value=value)
+    path.write_text(entry.model_dump_json())
 
 
 def clear_cache(namespace: Optional[str] = None) -> list[str]:

woolly/commands/check.py

@@ -2,9 +2,12 @@
 Check command - analyze package dependencies for Fedora availability.
 """
 
+import fnmatch
+from pathlib import Path
 from typing import Annotated, Optional
 
 import cyclopts
+from pydantic import BaseModel, Field
 from rich.tree import Tree
 
 from woolly.cache import CACHE_DIR
@@ -16,6 +19,20 @@ from woolly.progress import ProgressTracker
 from woolly.reporters import ReportData, get_available_formats, get_reporter
 
 
+class TreeStats(BaseModel):
+    """Statistics collected from dependency tree analysis."""
+
+    total: int = 0
+    packaged: int = 0
+    missing: int = 0
+    missing_list: list[str] = Field(default_factory=list)
+    packaged_list: list[str] = Field(default_factory=list)
+    optional_total: int = 0
+    optional_packaged: int = 0
+    optional_missing: int = 0
+    optional_missing_list: list[str] = Field(default_factory=list)
+
+
 def build_tree(
     provider: LanguageProvider,
     package_name: str,
@@ -24,6 +41,9 @@ def build_tree(
     depth: int = 0,
     max_depth: int = 50,
     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.
@@ -44,6 +64,12 @@ def build_tree(
         Maximum recursion depth.
     tracker
         Optional progress tracker.
+    include_optional
+        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
     -------
@@ -53,9 +79,11 @@ def build_tree(
     if visited is None:
         visited = {}
 
+    optional_marker = " [yellow](optional)[/yellow]" if is_optional_dep else ""
+
     if depth > max_depth:
         log(f"Max depth reached for {package_name}", level="warning", depth=depth)
-        return f"[dim]{package_name} (max depth reached)[/dim]"
+        return f"[dim]{package_name}{optional_marker} (max depth reached)[/dim]"
 
     if package_name in visited:
         is_packaged, cached_version = visited[package_name]
@@ -65,11 +93,9 @@ def build_tree(
             result="packaged" if is_packaged else "not packaged",
         )
         if is_packaged:
-            return f"[dim]{package_name}[/dim] [dim]v{cached_version}[/dim] • [green]✓[/green] [dim](already visited)[/dim]"
+            return f"[dim]{package_name}[/dim] [dim]v{cached_version}[/dim]{optional_marker} • [green]✓[/green] [dim](already visited)[/dim]"
         else:
-            return (
-                f"[dim]{package_name}[/dim] • [red]✗[/red] [dim](already visited)[/dim]"
-            )
+            return f"[dim]{package_name}[/dim]{optional_marker} • [red]✗[/red] [dim](already visited)[/dim]"
 
     if tracker:
         tracker.update(package_name)
@@ -84,7 +110,7 @@ def build_tree(
                 package_name, "Not found", source=provider.registry_name, result="error"
             )
             return (
-                f"[bold red]{package_name}[/bold red] • "
+                f"[bold red]{package_name}[/bold red]{optional_marker} • "
                 f"[red]not found on {provider.registry_name}[/red]"
             )
 
@@ -107,14 +133,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] • "
+            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{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] • "
+            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{optional_marker} • "
             f"[red]✗ not packaged[/red]"
         )
 
@@ -125,16 +151,33 @@ def build_tree(
         package_name, "Fetching dependencies", source=provider.registry_name
     )
 
-    deps = provider.get_normal_dependencies(package_name, version)
+    deps = provider.get_normal_dependencies(
+        package_name, version, include_optional=include_optional
+    )
 
     log(f"Found {len(deps)} dependencies for {package_name}", deps=len(deps))
 
     if tracker and deps:
         tracker.update(package_name, discovered=len(deps))
 
-    for dep_name, _dep_req in 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, None, visited, depth + 1, max_depth, tracker
+            provider,
+            dep_name,
+            None,
+            visited,
+            depth + 1,
+            max_depth,
+            tracker,
+            include_optional=include_optional,
+            is_optional_dep=dep_is_optional,
+            exclude_patterns=exclude_patterns,
         )
         if isinstance(child, str):
             node.add(child)
@@ -148,51 +191,65 @@ def build_tree(
     return node
 
 
-def collect_stats(tree, stats=None):
+def collect_stats(tree, stats: Optional[TreeStats] = None) -> TreeStats:
     """Walk the tree and collect statistics."""
     if stats is None:
-        stats = {
-            "total": 0,
-            "packaged": 0,
-            "missing": 0,
-            "missing_list": [],
-            "packaged_list": [],
-        }
+        stats = TreeStats()
 
     def walk(t):
         if isinstance(t, str):
-            stats["total"] += 1
+            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
-                name = (
-                    t.split("[/bold]")[0].split("]")[-1]
-                    if "[/bold]" in t
-                    else t.split()[0]
-                )
-                stats["missing_list"].append(name)
+                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
+                stats.packaged += 1
+                if is_optional:
+                    stats.optional_packaged += 1
             return
 
         if hasattr(t, "label"):
             label = str(t.label)
-            stats["total"] += 1
+            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
-                name = (
-                    label.split("[/bold]")[0].split("[bold]")[-1]
-                    if "[bold]" in label
-                    else "unknown"
-                )
-                stats["missing_list"].append(name)
+                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
+                stats.packaged += 1
                 name = (
                     label.split("[/bold]")[0].split("[bold]")[-1]
                     if "[bold]" in label
                     else "unknown"
                 )
-                stats["packaged_list"].append(name)
+                stats.packaged_list.append(name)
+                if is_optional:
+                    stats.optional_packaged += 1
 
         if hasattr(t, "children"):
             for child in t.children:
@@ -232,6 +289,14 @@ def check(
             help="Maximum recursion depth.",
         ),
     ] = 50,
+    optional: Annotated[
+        bool,
+        cyclopts.Parameter(
+            ("--optional", "-o"),
+            negative=(),
+            help="Include optional dependencies in the analysis.",
+        ),
+    ] = False,
     no_progress: Annotated[
         bool,
         cyclopts.Parameter(
@@ -253,6 +318,28 @@ 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,
 ):
     """Check if a package's dependencies are available in Fedora.
 
@@ -266,12 +353,20 @@ def check(
         Specific version to check (default: latest).
     max_depth
         Maximum recursion depth for dependency tree.
+    optional
+        Include optional dependencies in the analysis.
     no_progress
         Disable progress bar during analysis.
     debug
         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.
     """
     # Get the language provider
     provider = get_provider(lang)
@@ -281,12 +376,33 @@ 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
+
     # Initialize logging
     setup_logger(debug=debug)
     log(
@@ -294,13 +410,21 @@ def check(
         package=package,
         language=lang,
         max_depth=max_depth,
+        include_optional=optional,
         debug=debug,
         report_format=report,
+        exclude_patterns=exclude_patterns,
     )
 
     console.print(
         f"\n[bold underline]Analyzing {provider.display_name} package:[/] {package}"
     )
+    if optional:
+        console.print("[yellow]Including optional dependencies[/yellow]")
+    if exclude_patterns:
+        console.print(
+            f"[yellow]Excluding dependencies matching: {', '.join(exclude_patterns)}[/yellow]"
+        )
     console.print(f"[dim]Registry: {provider.registry_name}[/dim]")
     console.print(f"[dim]Cache directory: {CACHE_DIR}[/dim]")
     console.print()
@@ -317,6 +441,8 @@ def check(
             version,
             max_depth=max_depth,
             tracker=tracker,
+            include_optional=optional,
+            exclude_patterns=exclude_patterns,
         )
         if tracker:
             tracker.finish()
@@ -335,14 +461,20 @@ def check(
         root_package=package,
         language=provider.display_name,
         registry=provider.registry_name,
-        total_dependencies=stats["total"],
-        packaged_count=stats["packaged"],
-        missing_count=stats["missing"],
-        missing_packages=stats["missing_list"],
-        packaged_packages=stats["packaged_list"],
+        total_dependencies=stats.total,
+        packaged_count=stats.packaged,
+        missing_count=stats.missing,
+        missing_packages=stats.missing_list,
+        packaged_packages=stats.packaged_list,
         tree=tree,
         max_depth=max_depth,
         version=version,
+        include_optional=optional,
+        optional_total=stats.optional_total,
+        optional_packaged=stats.optional_packaged,
+        optional_missing=stats.optional_missing,
+        optional_missing_packages=stats.optional_missing_list,
+        missing_only=missing_only,
     )
 
     # Generate report

woolly/commands/list_formats.py

@@ -17,8 +17,8 @@ def list_formats_cmd():
     table.add_column("Description")
     table.add_column("Aliases", style="dim")
 
-    for format_id, description, aliases in list_reporters():
-        alias_str = ", ".join(aliases) if aliases else "-"
-        table.add_row(format_id, description, alias_str)
+    for info in list_reporters():
+        alias_str = ", ".join(info.aliases) if info.aliases else "-"
+        table.add_row(info.format_id, info.description, alias_str)
 
     console.print(table)

woolly/commands/list_languages.py

@@ -17,10 +17,10 @@ def list_languages_cmd():
     table.add_column("Registry")
     table.add_column("Aliases", style="dim")
 
-    for lang_id, display_name, aliases in list_providers():
-        provider = get_provider(lang_id)
+    for info in list_providers():
+        provider = get_provider(info.language_id)
         registry = provider.registry_name if provider else "Unknown"
-        alias_str = ", ".join(aliases) if aliases else "-"
-        table.add_row(f"{display_name} ({lang_id})", registry, alias_str)
+        alias_str = ", ".join(info.aliases) if info.aliases else "-"
+        table.add_row(f"{info.display_name} ({info.language_id})", registry, alias_str)
 
     console.print(table)

woolly/http.py

@@ -0,0 +1,34 @@
+"""
+Shared HTTP client configuration for API requests.
+
+This module provides centralized HTTP configuration including
+the User-Agent header and common request settings.
+"""
+
+import httpx
+from importlib.metadata import version
+
+# Version identifier for the User-Agent
+VERSION = version("woolly")
+PROJECT_URL = "https://github.com/r0x0d/woolly"
+
+# Shared headers for all API requests
+DEFAULT_HEADERS = {
+    "User-Agent": f"woolly/{VERSION} ({PROJECT_URL})",
+}
+
+
+def get(url: str, **kwargs) -> httpx.Response:
+    """
+    Make a GET request with default headers.
+
+    Args:
+        url: The URL to request.
+        **kwargs: Additional arguments passed to httpx.get().
+
+    Returns:
+        httpx.Response object.
+    """
+    headers = kwargs.pop("headers", {})
+    merged_headers = {**DEFAULT_HEADERS, **headers}
+    return httpx.get(url, headers=merged_headers, **kwargs)

woolly/languages/__init__.py

@@ -8,10 +8,21 @@ inheriting from LanguageProvider and add it to PROVIDERS dict.
 
 from typing import Optional
 
+from pydantic import BaseModel, Field
+
 from woolly.languages.base import LanguageProvider
 from woolly.languages.python import PythonProvider
 from woolly.languages.rust import RustProvider
 
+
+class ProviderInfo(BaseModel):
+    """Information about an available language provider."""
+
+    language_id: str
+    display_name: str
+    aliases: list[str] = Field(default_factory=list)
+
+
 # Registry of available language providers
 # Key: language identifier (used in CLI)
 # Value: Provider class
@@ -52,21 +63,40 @@ def get_provider(language: str) -> Optional[LanguageProvider]:
     return provider_class()
 
 
-def list_providers() -> list[tuple[str, str, list[str]]]:
+def list_providers() -> list[ProviderInfo]:
     """
     List all available providers.
 
     Returns:
-        List of tuples: (language_id, display_name, aliases)
+        List of ProviderInfo objects with language details.
     """
     result = []
     for lang_id, provider_class in PROVIDERS.items():
         # Find aliases for this language
         aliases = [alias for alias, target in ALIASES.items() if target == lang_id]
-        result.append((lang_id, provider_class.display_name, aliases))
+        result.append(
+            ProviderInfo(
+                language_id=lang_id,
+                display_name=provider_class.display_name,
+                aliases=aliases,
+            )
+        )
     return result
 
 
 def get_available_languages() -> list[str]:
     """Get list of available language identifiers."""
     return list(PROVIDERS.keys())
+
+
+__all__ = [
+    "LanguageProvider",
+    "ProviderInfo",
+    "PythonProvider",
+    "RustProvider",
+    "get_provider",
+    "list_providers",
+    "get_available_languages",
+    "PROVIDERS",
+    "ALIASES",
+]

woolly/languages/base.py

@@ -133,20 +133,24 @@ class LanguageProvider(ABC):
         return info.latest_version
 
     def get_normal_dependencies(
-        self, package_name: str, version: Optional[str] = None
-    ) -> list[tuple[str, str]]:
+        self,
+        package_name: str,
+        version: Optional[str] = None,
+        include_optional: bool = False,
+    ) -> list[tuple[str, str, bool]]:
         """
-        Get non-optional, runtime dependencies for a package.
+        Get runtime dependencies for a package.
 
         This method filters dependencies to only include normal (runtime)
-        dependencies that are not optional.
+        dependencies. By default, optional dependencies are excluded.
 
         Args:
             package_name: The name of the package.
             version: Specific version, or None for latest.
+            include_optional: If True, include optional dependencies.
 
         Returns:
-            List of tuples: (dependency_name, version_requirement)
+            List of tuples: (dependency_name, version_requirement, is_optional)
         """
         if version is None:
             version = self.get_latest_version(package_name)
@@ -155,9 +159,9 @@ class LanguageProvider(ABC):
 
         deps = self.fetch_dependencies(package_name, version)
         return [
-            (d.name, d.version_requirement)
+            (d.name, d.version_requirement, d.optional)
             for d in deps
-            if d.kind == "normal" and not d.optional
+            if d.kind == "normal" and (include_optional or not d.optional)
         ]
 
     def get_fedora_provides_pattern(self, package_name: str) -> str:

woolly/languages/python.py

@@ -8,8 +8,7 @@ Fedora repositories for Python packages.
 import re
 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,
@@ -20,7 +19,6 @@ from woolly.debug import (
 from woolly.languages.base import Dependency, LanguageProvider, PackageInfo
 
 PYPI_API = "https://pypi.org/pypi"
-HEADERS = {"User-Agent": "woolly/0.1.0 (https://github.com/r0x0d/woolly)"}
 
 
 class PythonProvider(LanguageProvider):
@@ -51,7 +49,7 @@ class PythonProvider(LanguageProvider):
         log_cache_miss(self.cache_namespace, cache_key)
         url = f"{PYPI_API}/{package_name}/json"
         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:
@@ -96,7 +94,7 @@ class PythonProvider(LanguageProvider):
         log_cache_miss(self.cache_namespace, cache_key)
         url = f"{PYPI_API}/{package_name}/{version}/json"
         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:
@@ -141,7 +139,8 @@ class PythonProvider(LanguageProvider):
 
         if "extra ==" in req_string or "extra==" in req_string:
             is_optional = True
-            kind = "dev"  # Treat extras as dev dependencies
+            # Keep kind as "normal" so optional dependencies can be included
+            # when --optional flag is used
 
         # Extract the package name and version requirement
         # Handle environment markers (everything after ';')