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

woolly/commands/check.py

@@ -2,6 +2,8 @@
 Check command - analyze package dependencies for Fedora availability.
 """
 
+import fnmatch
+from pathlib import Path
 from typing import Annotated, Optional
 
 import cyclopts
@@ -41,6 +43,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.
@@ -65,6 +68,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
     -------
@@ -156,6 +161,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 +177,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)
@@ -306,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.
 
@@ -327,6 +361,12 @@ 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.
     """
     # Get the language provider
     provider = get_provider(lang)
@@ -336,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(
@@ -352,6 +413,7 @@ def check(
         include_optional=optional,
         debug=debug,
         report_format=report,
+        exclude_patterns=exclude_patterns,
     )
 
     console.print(
@@ -359,6 +421,10 @@ def check(
     )
     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()
@@ -376,6 +442,7 @@ def check(
             max_depth=max_depth,
             tracker=tracker,
             include_optional=optional,
+            exclude_patterns=exclude_patterns,
         )
         if tracker:
             tracker.finish()
@@ -407,6 +474,7 @@ def check(
         optional_packaged=stats.optional_packaged,
         optional_missing=stats.optional_missing,
         optional_missing_packages=stats.optional_missing_list,
+        missing_only=missing_only,
     )
 
     # Generate report

woolly/reporters/__init__.py

@@ -6,6 +6,7 @@ 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
@@ -15,6 +16,7 @@ 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):
@@ -32,6 +34,7 @@ REPORTERS: dict[str, type[Reporter]] = {
     "stdout": StdoutReporter,
     "markdown": MarkdownReporter,
     "json": JsonReporter,
+    "template": TemplateReporter,
 }
 
 # Aliases for convenience
@@ -39,11 +42,16 @@ ALIASES: dict[str, str] = {
     "md": "markdown",
     "console": "stdout",
     "terminal": "stdout",
+    "tpl": "template",
+    "jinja": "template",
+    "jinja2": "template",
 }
 
 
 def get_reporter(
-    format_name: str, console: Optional[Console] = None
+    format_name: str,
+    console: Optional[Console] = None,
+    template_path: Optional[Path] = None,
 ) -> Optional[Reporter]:
     """
     Get an instantiated reporter for the specified format.
@@ -51,6 +59,7 @@ def get_reporter(
     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.
@@ -68,6 +77,10 @@ def get_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()
 
 
@@ -104,6 +117,7 @@ __all__ = [
     "StdoutReporter",
     "MarkdownReporter",
     "JsonReporter",
+    "TemplateReporter",
     "get_reporter",
     "list_reporters",
     "get_available_formats",

woolly/reporters/base.py

@@ -73,6 +73,9 @@ class ReportData(BaseModel):
     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."""

woolly/reporters/json.py

@@ -37,6 +37,7 @@ class ReportMetadata(BaseModel):
     version: Optional[str] = None
     max_depth: int
     include_optional: bool
+    missing_only: bool = False
 
 
 class ReportSummary(BaseModel):
@@ -86,6 +87,7 @@ class JsonReporter(Reporter):
                 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,
@@ -99,7 +101,10 @@ class JsonReporter(Reporter):
             ),
             missing_packages=sorted(data.required_missing_packages),
             missing_optional_packages=sorted(data.optional_missing_set),
-            packaged_packages=sorted(data.unique_packaged_packages),
+            # 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),
         )
 

woolly/reporters/markdown.py

@@ -29,6 +29,8 @@ class MarkdownReporter(Reporter):
             lines.append(f"**Version:** {data.version}")
         if data.include_optional:
             lines.append("**Include optional:** Yes")
+        if data.missing_only:
+            lines.append("**Missing only:** Yes")
         lines.append("")
 
         # Summary
@@ -69,8 +71,8 @@ class MarkdownReporter(Reporter):
                 lines.append(f"- `{name}` *(optional)*")
             lines.append("")
 
-        # Packaged packages - use computed property
-        if data.unique_packaged_packages:
+        # Packaged packages - use computed property (skip if missing_only mode)
+        if data.unique_packaged_packages and not data.missing_only:
             lines.append("## Packaged Packages")
             lines.append("")
             lines.append("The following packages are already available in Fedora:")
@@ -79,13 +81,14 @@ class MarkdownReporter(Reporter):
                 lines.append(f"- `{name}`")
             lines.append("")
 
-        # Dependency tree
-        lines.append("## Dependency Tree")
-        lines.append("")
-        lines.append("```")
-        lines.append(self._tree_to_text(data.tree))
-        lines.append("```")
-        lines.append("")
+        # Dependency tree (skip if missing_only mode)
+        if not data.missing_only:
+            lines.append("## Dependency Tree")
+            lines.append("")
+            lines.append("```")
+            lines.append(self._tree_to_text(data.tree))
+            lines.append("```")
+            lines.append("")
 
         return "\n".join(lines)
 

woolly/reporters/stdout.py

@@ -67,9 +67,10 @@ class StdoutReporter(Reporter):
                     self.console.print(f"  • {name} [dim](optional)[/dim]")
                 self.console.print()
 
-        # Print dependency tree
-        self.console.print("[bold]Dependency Tree:[/bold]")
-        self.console.print(data.tree)
-        self.console.print()
+        # Print dependency tree (skip if missing_only mode is enabled)
+        if not data.missing_only:
+            self.console.print("[bold]Dependency Tree:[/bold]")
+            self.console.print(data.tree)
+            self.console.print()
 
         return ""  # Output is printed directly

woolly/reporters/template.py

@@ -0,0 +1,215 @@
+"""
+Template-based report generator using Jinja2.
+
+Allows users to provide a custom markdown template file for report generation.
+Only a limited set of variables are exposed for security and simplicity.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from woolly.reporters.base import ReportData, Reporter, strip_markup
+
+
+class TemplateReporter(Reporter):
+    """Reporter that generates reports from user-provided Jinja2 templates.
+
+    This reporter allows users to customize the output format by providing
+    a markdown template file. Only a limited, safe set of variables are
+    exposed to the template.
+
+    Available template variables:
+        Metadata:
+            - root_package: Name of the analyzed package
+            - language: Language/ecosystem name (e.g., "Rust", "Python")
+            - registry: Registry name (e.g., "crates.io", "PyPI")
+            - version: Package version (if specified)
+            - timestamp: Formatted timestamp string (YYYY-MM-DD HH:MM:SS)
+            - max_depth: Maximum recursion depth used
+
+        Statistics:
+            - total_dependencies: Total number of dependencies analyzed
+            - packaged_count: Number of packages available in Fedora
+            - missing_count: Number of packages missing from Fedora
+
+        Optional dependency statistics:
+            - include_optional: Whether optional deps were included
+            - optional_total: Total optional dependencies
+            - optional_packaged: Optional deps available in Fedora
+            - optional_missing: Optional deps missing from Fedora
+
+        Package lists (sorted):
+            - missing_packages: List of missing required package names
+            - packaged_packages: List of packaged package names
+            - optional_missing_packages: List of missing optional package names
+
+        Flags:
+            - missing_only: Whether missing-only mode was enabled
+
+    Example template:
+        # Report for {{ root_package }}
+
+        Generated: {{ timestamp }}
+        Language: {{ language }}
+
+        ## Summary
+        - Total: {{ total_dependencies }}
+        - Packaged: {{ packaged_count }}
+        - Missing: {{ missing_count }}
+
+        {% if missing_packages %}
+        ## Missing Packages
+        {% for pkg in missing_packages %}
+        - {{ pkg }}
+        {% endfor %}
+        {% endif %}
+    """
+
+    name = "template"
+    description = "Custom template-based report (requires --template)"
+    file_extension = "md"
+    writes_to_file = True
+
+    def __init__(self, template_path: Optional[Path] = None):
+        """Initialize the template reporter.
+
+        Args:
+            template_path: Path to the Jinja2 template file.
+        """
+        self._template_path = template_path
+        self._jinja2_available: Optional[bool] = None
+
+    @property
+    def template_path(self) -> Optional[Path]:
+        """Get the template path."""
+        return self._template_path
+
+    @template_path.setter
+    def template_path(self, value: Optional[Path]) -> None:
+        """Set the template path."""
+        self._template_path = value
+
+    def _check_jinja2(self) -> bool:
+        """Check if Jinja2 is available.
+
+        Returns:
+            True if Jinja2 is available, False otherwise.
+        """
+        if self._jinja2_available is None:
+            try:
+                import jinja2  # type: ignore[import-not-found]  # noqa: F401
+
+                self._jinja2_available = True
+            except ImportError:
+                self._jinja2_available = False
+        return self._jinja2_available
+
+    def _get_template_context(self, data: ReportData) -> dict:
+        """Build the template context with allowed variables only.
+
+        This method creates a safe, limited context for template rendering.
+        Only specific variables from ReportData are exposed.
+
+        Args:
+            data: Report data containing all information.
+
+        Returns:
+            Dictionary of template variables.
+        """
+        return {
+            # Metadata
+            "root_package": data.root_package,
+            "language": data.language,
+            "registry": data.registry,
+            "version": data.version,
+            "timestamp": data.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
+            "max_depth": data.max_depth,
+            # Statistics
+            "total_dependencies": data.total_dependencies,
+            "packaged_count": data.packaged_count,
+            "missing_count": data.missing_count,
+            # Optional dependency statistics
+            "include_optional": data.include_optional,
+            "optional_total": data.optional_total,
+            "optional_packaged": data.optional_packaged,
+            "optional_missing": data.optional_missing,
+            # Package lists (sorted for consistent output)
+            "missing_packages": sorted(data.required_missing_packages),
+            "packaged_packages": sorted(data.unique_packaged_packages),
+            "optional_missing_packages": sorted(data.optional_missing_set),
+            # Flags
+            "missing_only": data.missing_only,
+        }
+
+    def generate(self, data: ReportData) -> str:
+        """Generate report content from the template.
+
+        Args:
+            data: Report data containing all information.
+
+        Returns:
+            Rendered template content as a string.
+
+        Raises:
+            RuntimeError: If Jinja2 is not installed or template is not set.
+            FileNotFoundError: If the template file doesn't exist.
+            jinja2.TemplateError: If there's a template syntax error.
+        """
+        if not self._check_jinja2():
+            raise RuntimeError(
+                "Jinja2 is required for template reports. "
+                "Install it with: pip install jinja2"
+            )
+
+        if self._template_path is None:
+            raise RuntimeError(
+                "No template path specified. Use --template to provide a template file."
+            )
+
+        if not self._template_path.exists():
+            raise FileNotFoundError(f"Template file not found: {self._template_path}")
+
+        # Import Jinja2 here (we've already checked it's available)
+        from jinja2 import (  # type: ignore[import-not-found]
+            Environment,
+            FileSystemLoader,
+            StrictUndefined,
+            select_autoescape,
+        )
+
+        # Create Jinja2 environment with security settings
+        env = Environment(
+            loader=FileSystemLoader(self._template_path.parent),
+            autoescape=select_autoescape(default=False),
+            undefined=StrictUndefined,  # Raise error on undefined variables
+            # Disable dangerous features
+            extensions=[],
+        )
+
+        # Add custom filter to strip Rich markup
+        env.filters["strip_markup"] = strip_markup
+
+        # Load and render template
+        template = env.get_template(self._template_path.name)
+        context = self._get_template_context(data)
+
+        return template.render(**context)
+
+    def get_output_filename(self, data: ReportData) -> str:
+        """Get the output filename for the template report.
+
+        Uses the template filename as a base if available, otherwise
+        falls back to the default naming convention.
+
+        Args:
+            data: Report data.
+
+        Returns:
+            Filename string.
+        """
+        timestamp = data.timestamp.strftime("%Y%m%d_%H%M%S")
+        if self._template_path:
+            # Use template name as base (without extension)
+            base_name = self._template_path.stem
+            return f"woolly_{data.root_package}_{base_name}_{timestamp}.md"
+        return f"woolly_{data.root_package}_template_{timestamp}.md"

{woolly-0.3.0.dist-info → woolly-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: woolly
-Version: 0.3.0
+Version: 0.4.0
 Summary: Check if package dependencies are available in Fedora. Supports Rust, Python, and more.
 Author-email: Rodolfo Olivieri <rodolfo.olivieri3@gmail.com>
 License-File: LICENSE
@@ -26,6 +26,8 @@ Requires-Dist: cyclopts>=4.3.0
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: pydantic>=2.10.0
 Requires-Dist: rich>=14.2.0
+Provides-Extra: template
+Requires-Dist: jinja2>=3.1.0; extra == 'template'
 Description-Content-Type: text/markdown
 
 # 🐑 Woolly

{woolly-0.3.0.dist-info → woolly-0.4.0.dist-info}/RECORD

@@ -5,7 +5,7 @@ woolly/debug.py,sha256=85_0_lsqccT8TAkyWFinOIqkPVPpcmrKuNfIYQOEqZ4,5294
 woolly/http.py,sha256=xPFbHPWEWTN4mjEONyJ9hERmb62mMWun0jRjTAaaNE8,872
 woolly/progress.py,sha256=Ij-K3-6-qeVLFKD_WdSfuclZh6uiso9XSSVRlpbB4jA,2040
 woolly/commands/__init__.py,sha256=3xzeIPYD0dmVWwRXHkdPmsF2IIRU6KyvDwgemKdyghI,840
-woolly/commands/check.py,sha256=kCFQClTOiBAP-DRpAQFbDGgIKiPv8SlMYKoQzx6Fq4E,13312
+woolly/commands/check.py,sha256=6E61LJnVzkMbJDdk90eH9mFD34qemve4h15SButcthU,15975
 woolly/commands/clear_cache.py,sha256=nCS52v_hNvKTwj62CKrQRfjX53fGpZnWpfB0GMmi8e4,1039
 woolly/commands/list_formats.py,sha256=f4UAWjoBbDu8YhobQyccErwpmOqElrCxBg0xcnJVDUQ,695
 woolly/commands/list_languages.py,sha256=VFjvMgXnvaW3O-MBEpzf5nd89yQ9TqLqcULPDCDUthg,857
@@ -13,13 +13,14 @@ woolly/languages/__init__.py,sha256=CwcPDIMvFpCK1tFbx5rew_5mLrrMy6s4HT6C-ZZz_7M,
 woolly/languages/base.py,sha256=Sjm9wXWeM36w6eYx_YyHm0jM6TqAUshlCiSPczW1_IA,12365
 woolly/languages/python.py,sha256=aA1fmHO0VWV_sHjZF92G30frv916Veh6cqjIj354UgM,6723
 woolly/languages/rust.py,sha256=DdhflO0PDvpgGy41lst9vUW9vF1Xrf94RJIMAsWSRDc,4508
-woolly/reporters/__init__.py,sha256=dS1XZGPTjvCkDetiWikkmBn7OnpvnmMXGZDYz2LVQr4,2833
-woolly/reporters/base.py,sha256=xXwrNb2NVVktQHjYCBT4nCzdqpvQsVCVsSs5-hB0D8I,6264
-woolly/reporters/json.py,sha256=mJb3tZDxvzEZ2zeOKELKJaU1E3b4TG86_DtsEJ8JHGE,5707
-woolly/reporters/markdown.py,sha256=fh--BH1rQP46qhTXiWcTHX3X9kjQJsAAXFFiToqK-RA,4300
-woolly/reporters/stdout.py,sha256=Xzku45BElUFyHh_pCWqAW4efb2mhC54CEja0xN6Xoe0,2784
-woolly-0.3.0.dist-info/METADATA,sha256=SMLGfdfa3_Rk6S36nGkJfiagX2bvmYMpb4llzvE6NCc,10402
-woolly-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-woolly-0.3.0.dist-info/entry_points.txt,sha256=tMSCR0PXsaIWiiY5fwQ5eowwNqPSrH0j9QriPDoE75k,48
-woolly-0.3.0.dist-info/licenses/LICENSE,sha256=TnfrdmTYydTTenujKk2LdAuDuLSMwjpXhW7EU2VR0e8,1064
-woolly-0.3.0.dist-info/RECORD,,
+woolly/reporters/__init__.py,sha256=-85BHuDAQwyrgWtJqME76FT4jyrvS4cuas7CxaWDODU,3301
+woolly/reporters/base.py,sha256=3j_tHH-epyYg-KGNW_ApsOCp_p_hJwAG_Azx1jUoDjs,6318
+woolly/reporters/json.py,sha256=Zh0OpOIEKlJiUHTr_FZF_Ys-hJN0drLi1mZg5zZL6LM,5915
+woolly/reporters/markdown.py,sha256=_lXzoFDkQXzBgpg7EX0Fl4U_Oj3NUtAMUOw8u6GuPec,4520
+woolly/reporters/stdout.py,sha256=IOE8gk3U85gpDsZXRWCHBxxCYRieR6PqUhVhZplYGcM,2869
+woolly/reporters/template.py,sha256=U48rP9DMwk4p-fk26jldfU_uXllHBT5N1LHTVomFTFI,7702
+woolly-0.4.0.dist-info/METADATA,sha256=nVgVJAKQA1fsWXmfmyYUzDMY3f1zrVGs-3081Lo85a8,10477
+woolly-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+woolly-0.4.0.dist-info/entry_points.txt,sha256=tMSCR0PXsaIWiiY5fwQ5eowwNqPSrH0j9QriPDoE75k,48
+woolly-0.4.0.dist-info/licenses/LICENSE,sha256=TnfrdmTYydTTenujKk2LdAuDuLSMwjpXhW7EU2VR0e8,1064
+woolly-0.4.0.dist-info/RECORD,,