repodoctor-cli 1.0.0__py3-none-any.whl

repodoctor/report.py

@@ -0,0 +1,361 @@
+import json
+import sys
+import time
+from .models import ReportData
+
+from typing import Dict, Optional
+
+
+def print_project_tree(data, c_func):
+    print(c_func("PROJECT TREE", "1"))
+    print(c_func("────────────────────────────────────────────────────────────", "90"))
+    paths = [f.relative_path.replace("\\", "/") for f in data.files]
+    tree = {}
+    for p in paths:
+        parts = p.split("/")
+        curr = tree
+        for part in parts:
+            if part not in curr:
+                curr[part] = {}
+            curr = curr[part]
+    
+    lines = []
+    def traverse(node, prefix=""):
+        if len(lines) > 50: return
+        keys = sorted(list(node.keys()))
+        for i, key in enumerate(keys):
+            is_last = (i == len(keys) - 1)
+            lines.append(prefix + ("└── " if is_last else "├── ") + key)
+            traverse(node[key], prefix + ("    " if is_last else "│   "))
+            
+    traverse(tree)
+    if len(lines) > 50: lines.append("... (tree truncated)")
+    print("\n".join(lines))
+    print()
+
+def print_terminal_report(data: ReportData, use_color: bool = True, large_file_threshold: int = 500, deltas: Optional[Dict[str, int]] = None, exec_time: Optional[float] = None, show_tree: bool = False) -> None:
+    def c(text, code):
+        return f"\033[{code}m{text}\033[0m" if use_color else text
+    print()
+    print(f"Repository: {data.name}")
+    print(f"Path: {data.path}")
+    if deltas:
+        print(c("Baseline comparison activated.", "36"))
+    print()
+
+    if show_tree:
+        print_project_tree(data, c)
+
+    print(c("SUMMARY", "1"))
+    print("────────────────────────────────────────────────────────────")
+    
+    files_str = f"{len(data.files)}{fmt_delta(deltas['files']) if deltas else ''}"
+    print(f"Files scanned:          {files_str}")
+    
+    total_lines = sum(f.lines for f in data.files)
+    lines_str = f"{total_lines:,}{fmt_delta(deltas['lines']) if deltas else ''}"
+    print(f"Lines of code:          {lines_str}")
+    
+    languages = set(f.language for f in data.files if f.language != "Unknown")
+    lang_lines = {}
+    for f in data.files:
+        if f.language != "Unknown":
+            lang_lines[f.language] = lang_lines.get(f.language, 0) + f.lines
+            
+    total_lang_lines = sum(lang_lines.values())
+    if total_lang_lines > 0:
+        print(f"Languages detected:")
+        for lang, llines in sorted(lang_lines.items(), key=lambda x: x[1], reverse=True):
+            pct = (llines / total_lang_lines) * 100
+            bar_len = int(pct / 5)
+            bar = "█ " * bar_len
+            print(f"  {lang:<18} {bar}{pct:.1f}%\n")
+    else:
+        print(f"Languages detected:     None")
+    
+    if data.score:
+        score_str = f"{data.score.score}/100{fmt_delta(deltas['score']) if deltas else ''}"
+        print(f"Health score:           {score_str}")
+    print()
+
+    print(c("MAINTAINABILITY", "1"))
+    print("────────────────────────────────────────────────────────────")
+    large_files = sum(1 for f in data.files if f.lines > large_file_threshold)
+    print(f"Large files:            {large_files}")
+    long_functions = sum(f.metrics.num_functions for f in data.files if f.metrics)
+    print(f"Long functions:         {long_functions}")
+    high_nesting = sum(1 for f in data.files if f.metrics and f.metrics.max_nesting > 4)
+    print(f"High nesting:           {high_nesting}")
+    
+    total_smells = sum(len(f.code_smells) for f in data.files if f.code_smells)
+    print(f"Code smells (Linting):  {total_smells}")
+    
+    todos_str = f"{len(data.todos)}{fmt_delta(deltas['todos'], inverted=True) if deltas else ''}"
+    print(f"TODO/FIXME items:       {todos_str}")
+    
+    dups_str = f"{len(data.duplicates)}{fmt_delta(deltas['duplicates'], inverted=True) if deltas else ''}"
+    print(f"Duplicate blocks:       {dups_str}")
+    if data.top_words:
+        words_str = ", ".join([f"{w} ({c})" for w, c in data.top_words])
+        print(f"Top vocabulary:         {words_str}")
+
+    sorted_files = sorted(data.files, key=lambda f: f.lines, reverse=True)
+    if sorted_files and sorted_files[0].lines > 0:
+        print("\nHeaviest Files:")
+        for i, f in enumerate(sorted_files[:3], 1):
+            if f.lines > 0:
+                print(f"  {i}. {f.relative_path} ({f.lines:,} lines)")
+    print()
+
+    print(c("SECURITY", "1"))
+    print("────────────────────────────────────────────────────────────")
+    sec_str = f"{len(data.security)}{fmt_delta(deltas['secrets'], inverted=True) if deltas else ''}"
+    print(f"Potential secrets:      {sec_str}")
+    if data.security:
+        for sec in data.security:
+            print(f"  {sec.filepath}:{sec.line_number} - {sec.category} (Confidence: {sec.confidence})")
+            print(f"  Value: {sec.redacted_value}")
+    print()
+
+    print(c("PROJECT HEALTH", "1"))
+    print("────────────────────────────────────────────────────────────")
+    for key, val in data.structure.items():
+        icon = "✓" if val == "PASS" else ("✗" if val == "FAIL" else ("⚠" if val == "WARN" else "-"))
+        print(f"{key:<23} {icon}")
+    print()
+
+    if data.mood:
+        print(f"Project Mood:           {data.mood}")
+    if data.clone_exposer:
+        print(f"👯‍♂️ Clone Exposer:       {data.clone_exposer}")
+    print()
+
+    print(c("GIT", "1"))
+    print("────────────────────────────────────────────────────────────")
+    if data.git.available:
+        print(f"Branch:                 {data.git.branch}")
+        print(f"Uncommitted changes:    {data.git.uncommitted_changes}")
+        print(f"Commits:                {data.git.commits}")
+        if data.git.top_contributor:
+            print(f"Top Contributor:        {data.git.top_contributor}")
+        if data.git.hotspot:
+            print(f"🔥 Hotspot file:        {data.git.hotspot}")
+    else:
+        print("Git repository:         Not available")
+    print()
+
+    if data.score:
+        print("────────────────────────────────────────────────────────────")
+        print(c(f"Health Score: {data.score.score}/100", "92;1" if data.score.score > 80 else "91;1"))
+        print(c("Guide: 90+ (Excellent) | 70-89 (Good) | <70 (Needs Work)", "36"))
+        print("────────────────────────────────────────────────────────────")
+        for reason, change in data.score.breakdown:
+            sign = "+" if change > 0 else ""
+            print(f"{reason:<30} {sign}{change}")
+
+
+    if exec_time is not None:
+        print(c(f"\n⚡ Scan completed in {exec_time:.2f} seconds", "90"))
+        
+def get_json_report(data: ReportData, large_file_threshold: int = 500) -> str:
+    total_lines = sum(f.lines for f in data.files)
+    large_files = sum(1 for f in data.files if f.lines > large_file_threshold)
+    
+    out = {
+        "repository": {
+            "path": data.path,
+            "name": data.name
+        },
+        "summary": {
+            "files": len(data.files),
+            "lines": total_lines,
+            "health_score": data.score.score if data.score else None
+        },
+        "security": {
+            "potential_secrets": len(data.security),
+            "findings": [
+                {
+                    "file": s.filepath,
+                    "line": s.line_number,
+                    "category": s.category,
+                    "confidence": s.confidence,
+                    "explanation": s.explanation,
+                    # Deliberately omitting full secret, just showing redacted
+                    "redacted_value": s.redacted_value
+                } for s in data.security
+            ]
+        },
+        "maintainability": {
+            "large_files": large_files,
+            "todos": len(data.todos),
+            "duplicates": len(data.duplicates)
+        },
+        "git": {
+            "available": data.git.available,
+            "branch": data.git.branch,
+            "commits": data.git.commits,
+            "uncommitted_changes": data.git.uncommitted_changes
+        },
+        "structure": data.structure
+    }
+    return json.dumps(out, indent=2)
+
+def generate_html_report(data: ReportData, large_file_threshold: int = 500) -> str:
+    total_lines = sum(f.lines for f in data.files)
+    large_files = sum(1 for f in data.files if f.lines > large_file_threshold)
+    long_functions = sum(f.metrics.num_functions for f in data.files if f.metrics)
+    high_nesting = sum(1 for f in data.files if f.metrics and f.metrics.max_nesting > 4)
+    total_smells = sum(len(f.code_smells) for f in data.files if f.code_smells)
+
+    
+    # HTML additions
+    sorted_files = sorted(data.files, key=lambda x: x.lines, reverse=True)
+    heaviest_files = sorted_files[:3]
+    
+    heavy_html = "".join(f"<li><span>{f.path}</span> <strong>{f.lines:,} lines</strong></li>" for f in heaviest_files) if heaviest_files else "<li>None</li>"
+    
+    security_html = ""
+    if data.security:
+        security_html = "".join(f"<tr><td>{s.filepath}:{s.line_number}</td><td><span class='badge fail'>{s.category}</span></td><td>{s.redacted_value}</td></tr>" for s in data.security)
+    else:
+        security_html = "<tr><td colspan='3' style='text-align:center;'>No secrets detected! 🎉</td></tr>"
+
+    html = f'''<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>RepoDoctor Dashboard - {data.name}</title>
+<style>
+    :root {{
+        --bg-main: #121212;
+        --text-main: #e0e0e0;
+        --text-muted: #888888;
+        --border: #444444;
+        --bg-card: #1a1a1a;
+    }}
+    body {{
+        font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+        background-color: var(--bg-main);
+        color: var(--text-main);
+        margin: 0;
+        padding: 40px 20px;
+        line-height: 1.5;
+        font-size: 14px;
+    }}
+    .container {{ max-width: 900px; margin: 0 auto; }}
+    .header {{ margin-bottom: 40px; border-bottom: 2px dashed var(--border); padding-bottom: 20px; }}
+    .header h1 {{
+        font-size: 24px;
+        margin: 0 0 10px 0;
+        color: var(--text-main);
+        text-transform: uppercase;
+        letter-spacing: 2px;
+    }}
+    .target-path {{
+        color: var(--text-muted);
+        margin: 0;
+    }}
+    .grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-bottom: 40px; }}
+    .card {{
+        background: var(--bg-card); 
+        border: 1px solid var(--border); 
+        padding: 20px;
+    }}
+    .card h3 {{ margin: 0 0 10px 0; font-size: 12px; color: var(--text-muted); text-transform: uppercase; font-weight: normal; }}
+    .card .val {{ font-size: 24px; color: var(--text-main); }}
+    
+    .section-wrapper {{ display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-bottom: 20px; }}
+    @media (max-width: 768px) {{ .section-wrapper {{ grid-template-columns: 1fr; }} }}
+    
+    .section {{ background: var(--bg-card); padding: 20px; border: 1px solid var(--border); }}
+    .section.full {{ grid-column: 1 / -1; margin-bottom: 20px; }}
+    .section h2 {{ margin: 0 0 20px 0; font-size: 14px; text-transform: uppercase; color: var(--text-main); border-bottom: 1px dashed var(--border); padding-bottom: 10px; font-weight: normal; }}
+    
+    ul.feature-list {{ list-style: none; padding: 0; margin: 0; }}
+    ul.feature-list li {{ padding: 10px 0; border-bottom: 1px dashed var(--border); display: flex; justify-content: space-between; }}
+    ul.feature-list li:last-child {{ border-bottom: none; padding-bottom: 0; }}
+    
+    table {{ width: 100%; border-collapse: collapse; margin-top: 10px; }}
+    th, td {{ padding: 12px 10px; border-bottom: 1px dashed var(--border); text-align: left; font-weight: normal; }}
+    th {{ color: var(--text-muted); text-transform: uppercase; font-size: 12px; }}
+    
+    .badge {{ padding: 2px 6px; font-size: 12px; text-transform: uppercase; border: 1px solid var(--text-main); color: var(--text-main); }}
+</style>
+</head>
+<body>
+<div class="container">
+    <div class="header">
+        <h1>RepoDoctor</h1>
+        <p class="target-path">{data.path}</p>
+    </div>
+    
+    <div class="grid">
+        <div class="card">
+            <h3>Health Score</h3>
+            <div class="val">{data.score.score if data.score else 'N/A'}</div>
+        </div>
+        <div class="card">
+            <h3>Files Scanned</h3>
+            <div class="val">{len(data.files)}</div>
+        </div>
+        <div class="card">
+            <h3>Lines of Code</h3>
+            <div class="val">{total_lines:,}</div>
+        </div>
+        <div class="card">
+            <h3>Security Secrets</h3>
+            <div class="val">{len(data.security)}</div>
+        </div>
+    </div>
+    
+    <div class="section-wrapper">
+        <div class="section">
+            <h2>Maintainability</h2>
+            <ul class="feature-list">
+                <li><span>High Complexity</span> <strong>{high_nesting} funcs</strong></li>
+                <li><span>Duplicate Blocks</span> <strong>{len(data.duplicates)}</strong></li>
+                <li><span>Code Smells</span> <strong>{total_smells}</strong></li>
+                <li><span>TODO / FIXME</span> <strong>{len(data.todos)}</strong></li>
+            </ul>
+        </div>
+        
+        <div class="section">
+            <h2>AI & Git Analytics</h2>
+            <ul class="feature-list">
+                <li><span>Developer Mood</span> <strong>{data.mood if data.mood else 'N/A'}</strong></li>
+                <li><span>Clone Exposer</span> <strong>{data.clone_exposer if data.clone_exposer else 'N/A'}</strong></li>
+                <li><span>Top Contributor</span> <strong>{data.git.top_contributor if data.git.available and data.git.top_contributor else "N/A"}</strong></li>
+                <li><span>Git Hotspot</span> <strong>{data.git.hotspot if data.git.available and data.git.hotspot else "N/A"}</strong></li>
+            </ul>
+        </div>
+        
+        <div class="section full">
+            <h2>Project Structure Validation</h2>
+            <table>
+                <tr><th>Requirement</th><th>Status</th></tr>
+                {''.join(f"<tr><td>{k}</td><td><span class='badge'>{v}</span></td></tr>" for k, v in data.structure.items())}
+            </table>
+        </div>
+
+        <div class="section full">
+            <h2>Top 3 Heaviest Files</h2>
+            <ul class="feature-list">
+                {heavy_html}
+            </ul>
+        </div>
+        
+        <div class="section full" style="margin-bottom: 40px;">
+            <h2>Security Findings</h2>
+            <table>
+                <tr><th>Location</th><th>Category</th><th>Redacted Value</th></tr>
+                {security_html}
+            </table>
+        </div>
+    </div>
+
+</div>
+</body>
+</html>'''
+    return html
+

repodoctor/scanner.py

@@ -0,0 +1,177 @@
+"""
+scanner.py — Repository file walker with optional parallel scanning.
+
+Parallel mode (--parallel / -j):
+  Uses concurrent.futures.ThreadPoolExecutor with worker count =
+  min(32, os.cpu_count() + 4) — the same heuristic CPython uses internally
+  for I/O-bound thread pools.  No third-party libraries required.
+
+Animation:
+  When stdout is a TTY and --no-animation is not set, a live ProgressBar
+  is shown during scanning.  Automatically suppressed in CI / file-redirect
+  environments.
+"""
+
+import os
+import concurrent.futures
+from pathlib import Path
+from typing import List, Optional
+
+from .models import FileInfo
+from .spinner import ProgressBar
+
+DEFAULT_IGNORES = {
+    ".git", "node_modules", "__pycache__", ".venv", "venv",
+    "env", "dist", "build", "target", "coverage", ".cache"
+}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def is_binary_file(filepath: str, chunk_size: int = 1024) -> bool:
+    """Lightweight heuristic to detect if a file is binary."""
+    try:
+        with open(filepath, 'rb') as f:
+            chunk = f.read(chunk_size)
+            if b'\0' in chunk:
+                return True
+            # Also check if it cannot be decoded as utf-8
+            try:
+                chunk.decode('utf-8')
+            except UnicodeDecodeError:
+                return True
+    except Exception:
+        # If we can't read it, assume binary or unreadable to be safe
+        return True
+    return False
+
+
+def count_lines(filepath: str) -> int:
+    """Count lines in a text file efficiently."""
+    lines = 0
+    try:
+        with open(filepath, 'rb') as f:
+            for _ in f:
+                lines += 1
+    except Exception:
+        pass
+    return lines
+
+
+def _process_file(filepath: str, root_path: str) -> Optional[FileInfo]:
+    """
+    Worker function: stat + classify one file.
+    Runs inside a ThreadPoolExecutor worker when parallel=True,
+    or called directly in sequential mode.
+    Returns None on any unrecoverable error so callers can skip it.
+    """
+    # Avoid broken symlinks
+    if not os.path.exists(filepath):
+        return None
+
+    try:
+        stat_result = os.stat(filepath)
+        size = stat_result.st_size
+    except OSError:
+        return None
+
+    rel_path = os.path.relpath(filepath, root_path)
+    _, ext = os.path.splitext(os.path.basename(filepath))
+
+    is_binary = is_binary_file(filepath)
+    lines = 0 if is_binary else count_lines(filepath)
+
+    return FileInfo(
+        path=filepath,
+        filename=os.path.basename(filepath),
+        extension=ext.lower(),
+        size=size,
+        lines=lines,
+        is_binary=is_binary,
+        language="Unknown",   # populated later by detect_languages()
+        relative_path=rel_path,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+def scan_repository(
+    root_path: str,
+    custom_ignores: Optional[List[str]] = None,
+    parallel: bool = False,
+    show_animation: bool = True,
+) -> List[FileInfo]:
+    """
+    Walk *root_path* and return a list of FileInfo objects.
+
+    Parameters
+    ----------
+    root_path       : Absolute or relative path to the repository root.
+    custom_ignores  : Extra directory / file names to skip.
+    parallel        : If True, use ThreadPoolExecutor for I/O parallelism.
+    show_animation  : If True (and stdout is a TTY), render a progress bar.
+    """
+    ignores = set(DEFAULT_IGNORES)
+    if custom_ignores:
+        ignores.update(custom_ignores)
+
+    root_path = os.path.abspath(root_path)
+
+    # ------------------------------------------------------------------ #
+    # Phase 1: collect all file paths (fast, sequential walk)
+    # ------------------------------------------------------------------ #
+    all_paths: List[str] = []
+    for dirpath, dirnames, filenames in os.walk(root_path, followlinks=False):
+        dirnames[:] = [d for d in dirnames if d not in ignores]
+        for filename in filenames:
+            if filename in ignores:
+                continue
+            all_paths.append(os.path.join(dirpath, filename))
+
+    total = len(all_paths)
+    if total == 0:
+        return []
+
+    # ------------------------------------------------------------------ #
+    # Phase 2: stat + classify files (sequential or parallel)
+    # ------------------------------------------------------------------ #
+    bar = ProgressBar(
+        total=total,
+        label="Scanning files",
+        colour=show_animation,
+    ) if show_animation else None
+
+    files_info: List[FileInfo] = []
+
+    if parallel:
+        # Worker count: same heuristic as CPython's default I/O pool
+        max_workers = min(32, (os.cpu_count() or 1) + 4)
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_path = {
+                executor.submit(_process_file, p, root_path): p
+                for p in all_paths
+            }
+            for future in concurrent.futures.as_completed(future_to_path):
+                result = future.result()
+                if result is not None:
+                    files_info.append(result)
+                if bar:
+                    bar.advance()
+    else:
+        # Sequential path — unchanged behaviour for small repos / CI
+        for filepath in all_paths:
+            result = _process_file(filepath, root_path)
+            if result is not None:
+                files_info.append(result)
+            if bar:
+                bar.advance()
+
+    if bar:
+        bar.done()
+
+    return files_info

repodoctor/scoring.py

@@ -0,0 +1,49 @@
+from .models import ReportData, HealthScore
+
+def calculate_score(data: ReportData, large_file_threshold: int = 500) -> HealthScore:
+    base = 85
+    breakdown = []
+
+    if data.structure.get("README") == "PASS":
+        base += 5
+        breakdown.append(("README present", 5))
+    
+    if data.structure.get("Tests") == "PASS":
+        base += 5
+        breakdown.append(("Tests detected", 5))
+
+    if data.structure.get(".gitignore") == "PASS":
+        base += 5
+        breakdown.append((".gitignore present", 5))
+
+    # Penalties
+    large_files = sum(1 for f in data.files if f.lines > large_file_threshold)
+    if large_files > 0:
+        penalty = min(15, large_files * 3) # max -15
+        base -= penalty
+        breakdown.append(("Large files", -penalty))
+
+    if len(data.todos) > 0:
+        penalty = min(10, len(data.todos))
+        base -= penalty
+        breakdown.append(("TODO/FIXME count", -penalty))
+
+    if len(data.security) > 0:
+        penalty = min(30, len(data.security) * 15)
+        base -= penalty
+        breakdown.append(("Potential secrets", -penalty))
+
+    if len(data.duplicates) > 0:
+        penalty = min(20, len(data.duplicates) * 5)
+        base -= penalty
+        breakdown.append(("Duplicate blocks", -penalty))
+        
+    # High complexity (nesting > 4)
+    high_complexity = sum(1 for f in data.files if f.metrics and f.metrics.max_nesting > 4)
+    if high_complexity > 0:
+        penalty = min(10, high_complexity * 2)
+        base -= penalty
+        breakdown.append(("High complexity", -penalty))
+
+    base = max(0, min(100, base))
+    return HealthScore(score=base, breakdown=breakdown)

repodoctor/security.py

@@ -0,0 +1,56 @@
+import re
+from typing import List, Tuple
+from .models import FileInfo, SecurityFinding
+
+PATTERNS = [
+    # (Regex, Category, Confidence, Explanation)
+    (re.compile(r'(?i)(?:api_?key|secret|token|password)[\s:=]+[\'"]([A-Za-z0-9_\-]{16,})[\'"]'), "API Key or Token", "HIGH", "A variable name suggests an API key or token was hardcoded."),
+    (re.compile(r'-----BEGIN [A-Z]+ PRIVATE KEY-----'), "Private Key", "HIGH", "A private cryptographic key is present."),
+    (re.compile(r'https?://[a-zA-Z0-9_\-]+:[a-zA-Z0-9_\-]+@[a-zA-Z0-9_\-\.]+'), "Credential URL", "HIGH", "A URL contains embedded basic authentication credentials."),
+    (re.compile(r'(sk-[a-zA-Z0-9]{20,})'), "Potential API Key", "HIGH", "Pattern matches common cloud API keys (e.g., sk-...).")
+]
+
+def redact(value: str) -> str:
+    if len(value) <= 5:
+        return "***"
+    return value[:3] + "..." + value[-2:]
+
+def scan_security(files: List[FileInfo]) -> List[SecurityFinding]:
+    findings = []
+    
+    for f in files:
+        if f.is_binary:
+            continue
+            
+        # Check .env
+        if f.filename.startswith(".env"):
+            findings.append(SecurityFinding(
+                filepath=f.relative_path,
+                line_number=0,
+                category="Environment File",
+                confidence="HIGH",
+                explanation="An environment file (e.g., .env) is checked in. This often contains secrets.",
+                redacted_value="N/A"
+            ))
+
+        try:
+            with open(f.path, 'r', encoding='utf-8', errors='ignore') as file:
+                for line_idx, line in enumerate(file):
+                    for pattern, category, confidence, explanation in PATTERNS:
+                        match = pattern.search(line)
+                        if match:
+                            # For private key header, the match is the whole header
+                            val_to_redact = match.group(1) if len(match.groups()) > 0 else match.group(0)
+                            
+                            findings.append(SecurityFinding(
+                                filepath=f.relative_path,
+                                line_number=line_idx + 1,
+                                category=category,
+                                confidence=confidence,
+                                explanation=explanation,
+                                redacted_value=redact(val_to_redact)
+                            ))
+        except Exception:
+            pass
+            
+    return findings