codegraph-cli-ai 0.1.7__tar.gz → 0.1.9__tar.gz

{codegraph_cli_ai-0.1.7 → codegraph_cli_ai-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraph-cli-ai
-Version: 0.1.7
+Version: 0.1.9
 Summary: CLI tool to analyze codebases and visualize knowledge graphs using AST
 Author: Aditya Jogdand
 License: MIT
@@ -15,6 +15,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: typer>=0.9.0
 Requires-Dist: networkx>=3.0
 Requires-Dist: pyvis>=0.3.2
+Requires-Dist: pypdf>=3.0.0
+Requires-Dist: pytesseract>=0.3.10
+Requires-Dist: Pillow>=9.0.0
 
 # CodeGraph AI
 

codegraph_cli_ai-0.1.9/codegraph/cli.py

@@ -0,0 +1,279 @@
+"""
+CodeGraph AI - CLI Entry Point
+"""
+
+import json
+import typer
+import webbrowser
+import networkx as nx
+import os
+from pathlib import Path
+from typing import Optional, List, Set, Dict
+from collections import deque
+from codegraph.parsers.python_parser import PythonParser
+from codegraph.parsers.multimodal_parser import MultiModalParser
+from codegraph.graph.builder import GraphBuilder
+
+app = typer.Typer()
+
+
+@app.callback()
+def main():
+    """CodeGraph AI - Understand your codebase using graphs and AI."""
+    pass
+
+
+# Dynamic Ignore Defaults
+IGNORE_FILES = {"graph.json", ".DS_Store"}
+IGNORE_EXTENSIONS = {".pyc", ".log", ".pyo", ".pyd"}
+
+
+def is_virtualenv(path: Path) -> bool:
+    """Detect if a directory is a virtual environment based on its structure."""
+    if not path.is_dir():
+        return False
+    return (
+        (path / "pyvenv.cfg").exists()
+        or (path / "bin" / "python").exists()
+        or (path / "Scripts" / "python.exe").exists()
+        or (path / "bin" / "pip").exists()
+    )
+
+
+def should_ignore_dir(name: str, path: Path, root: Path) -> bool:
+    """Heuristic-based dynamic directory ignoring."""
+    if name.startswith(".") and path != root:
+        return True
+    if name.startswith("__"):
+        return True
+    if is_virtualenv(path):
+        return True
+    if name in {"node_modules", "bin", "Scripts", "lib", "obj", "target", "build", "dist"}:
+        return True
+    return False
+
+
+@app.command()
+def index(
+    path: str = typer.Argument(".", help="Path to the repo or folder to index")
+):
+    """Scan a directory, parse all Python files, and save the knowledge graph."""
+    root = Path(path).resolve()
+
+    if not root.exists():
+        typer.echo(f"[error] Path does not exist: {root}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Indexing: {root}\n")
+    
+    all_files = []
+    
+    for dirpath, dirnames, filenames in os.walk(root):
+        dpath = Path(dirpath)
+        dirnames[:] = [d for d in dirnames if not should_ignore_dir(d, dpath / d, root)]
+        
+        for f in filenames:
+            if f in IGNORE_FILES:
+                continue
+            p = dpath / f
+            if p.suffix.lower() in IGNORE_EXTENSIONS:
+                continue
+            all_files.append(p)
+
+    py_files = [f for f in all_files if f.suffix == ".py"]
+    asset_exts = {".csv", ".json", ".db", ".sqlite", ".pdf", ".png", ".jpg", ".jpeg"}
+    asset_files = [f for f in all_files if f.suffix.lower() in asset_exts]
+
+    if not py_files and not asset_files:
+        typer.echo("No supported files found (everything might be ignored).")
+        raise typer.Exit()
+
+    typer.echo(f"Found {len(py_files)} Python file(s) and {len(asset_files)} asset(s)\n")
+
+    py_parser = PythonParser()
+    mm_parser = MultiModalParser()
+    parsed_files = []
+    parsed_assets = []
+    failed_files = []
+
+    for filepath in py_files:
+        result = py_parser.parse_file(str(filepath))
+        if result.errors:
+            failed_files.append((str(filepath), result.errors))
+        else:
+            typer.echo(f"  ✔ [code]  {filepath.relative_to(root)}")
+            parsed_files.append(result)
+
+    for filepath in asset_files:
+        try:
+            asset = mm_parser.parse(str(filepath))
+            typer.echo(f"  ✔ [asset] {filepath.relative_to(root)}")
+            parsed_assets.append(asset)
+        except Exception as e:
+            failed_files.append((str(filepath), [str(e)]))
+
+    typer.echo("\nBuilding graph...")
+    builder = GraphBuilder()
+    builder.build(parsed_files, parsed_assets)
+    summary = builder.summary()
+
+    output_dir = root / ".codegraph"
+    output_dir.mkdir(exist_ok=True)
+    output_file = output_dir / "graph.json"
+    with output_file.open("w", encoding="utf-8") as fp:
+        json.dump(builder.to_dict(), fp, indent=2)
+
+    typer.echo("\n" + "=" * 50)
+    typer.echo("Index complete")
+    typer.echo(f"  Graph saved   : {output_file}")
+    typer.echo(f"  Graph nodes   : {summary['total_nodes']}")
+    typer.echo(f"  Graph edges   : {summary['total_edges']}")
+
+
+@app.command()
+def plot(
+    hide_external: bool = typer.Option(False, "--hide-external", help="Hide external/stdlib nodes"),
+    level: Optional[str] = typer.Option(None, "--level", help="Show only: file, function, class, method"),
+    focus: Optional[str] = typer.Option(None, "--focus", help="Focus on a specific file"),
+    edge_type: Optional[str] = typer.Option(None, "--edge-type", help="Filter edges"),
+):
+    """Visualize the knowledge graph as a premium interactive HTML file."""
+    root = Path(".").resolve()
+    graph_file = root / ".codegraph" / "graph.json"
+
+    if not graph_file.exists():
+        typer.echo("[error] No graph found. Run 'codegraph index' first.", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Loading graph from {graph_file}...")
+    with graph_file.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    G_orig = nx.DiGraph()
+    for node in data.get("nodes", []):
+        G_orig.add_node(node["id"], **{k: v for k, v in node.items() if k != "id"})
+    for edge in data.get("edges", []):
+        G_orig.add_edge(edge["source"], edge["target"], **{k: v for k, v in edge.items() if k not in ["source", "target"]})
+
+    G = G_orig.copy()
+
+    if hide_external:
+        remove = [n for n, d in G.nodes(data=True) if d.get("external", False)]
+        G.remove_nodes_from(remove)
+
+    if level:
+        level_map = {
+            "file": {"file", "dataset", "database", "document", "image"},
+            "function": {"function", "method"},
+            "class": {"class"}
+        }
+        requested_levels = level.split(",")
+        allowed_kinds = set()
+        for r in requested_levels:
+            if r in level_map:
+                allowed_kinds.update(level_map[r])
+            else:
+                allowed_kinds.add(r)
+        
+        if ("file" in requested_levels or "document" in allowed_kinds) and len(requested_levels) < 3:
+            G = _collapse_to_level(G, allowed_kinds)
+        else:
+            remove = [n for n, d in G.nodes(data=True) if d.get("kind") not in allowed_kinds]
+            G.remove_nodes_from(remove)
+
+    if focus:
+        focus_id = f"file:{focus}"
+        if focus_id in G:
+            keep = {focus_id} | set(G.successors(focus_id)) | set(G.predecessors(focus_id))
+            remove = [n for n in G.nodes if n not in keep]
+            G.remove_nodes_from(remove)
+
+    if edge_type and edge_type != "all":
+        allowed_edges = set(edge_type.split(","))
+        remove_edges = [(s, t) for s, t, d in G.edges(data=True) if d.get("relation") not in allowed_edges]
+        G.remove_edges_from(remove_edges)
+        G.remove_nodes_from(list(nx.isolates(G)))
+
+    typer.echo(f"Rendering {G.number_of_nodes()} nodes, {G.number_of_edges()} edges...")
+
+    html = _build_premium_html(G)
+    output_path = root / "graph.html"
+    output_path.write_text(html, encoding="utf-8")
+    typer.echo(f"Saved to: {output_path}")
+    webbrowser.open(f"file://{output_path.resolve()}")
+
+
+def _collapse_to_level(G: nx.DiGraph, allowed_kinds: set) -> nx.DiGraph:
+    """Contract the graph using depth-limited BFS for high-performance connectivity."""
+    new_G = nx.DiGraph()
+    keep_nodes = [n for n, d in G.nodes(data=True) if d.get("kind") in allowed_kinds]
+    
+    # Pre-populate all nodes
+    for n in keep_nodes:
+        new_G.add_node(n, **G.nodes[n])
+
+    # For each source node, find reachable target nodes within 5 steps
+    for start_node in keep_nodes:
+        # Standard BFS with depth tracking
+        queue = deque([(start_node, 0)])
+        visited = {start_node}
+        
+        while queue:
+            current, depth = queue.popleft()
+            if depth >= 5: continue
+            
+            for neighbor in G.successors(current):
+                if neighbor in visited: continue
+                visited.add(neighbor)
+                
+                if neighbor in new_G:
+                    # Found a connection to another keep_node!
+                    # Extract relation: if it's a multi-hop, use a representative one
+                    edge_data = G.get_edge_data(current, neighbor)
+                    # For simplicity, we just use the first edge's relation or a default
+                    rel = edge_data.get("relation", "calls")
+                    new_G.add_edge(start_node, neighbor, relation=rel)
+                    # Stop searching down this branch once we hit a keep_node
+                    continue
+                else:
+                    # Keep searching through non-keep nodes
+                    queue.append((neighbor, depth + 1))
+    
+    return new_G
+
+
+def _build_premium_html(G: nx.DiGraph) -> str:
+    """Generate a self-contained premium HTML visualization."""
+    nodes_js = []
+    for n, d in G.nodes(data=True):
+        nodes_js.append(f"{{id: {json.dumps(n)}, label: {json.dumps(d.get('label', n))}}}")
+    edges_js = []
+    for s, t, d in G.edges(data=True):
+        edges_js.append(f"{{from: {json.dumps(s)}, to: {json.dumps(t)}, label: {json.dumps(d.get('relation', ''))}, arrows: 'to'}}")
+
+    nodes_str = ','.join(nodes_js)
+    edges_str = ','.join(edges_js)
+
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+  <script src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+  <style>body{{background:#0F1117;color:#fff;margin:0;overflow:hidden;}}#graph{{height:100vh;}}</style>
+</head>
+<body>
+  <div id="graph"></div>
+  <script>
+    const nodes = new vis.DataSet([{nodes_str}]);
+    const edges = new vis.DataSet([{edges_str}]);
+    new vis.Network(document.getElementById('graph'), {{nodes, edges}}, {{physics:{{solver:'forceAtlas2Based'}} }});
+  </script>
+</body>
+</html>"""
+
+@app.command()
+def ask(query: str = typer.Argument(..., help="Question about your codebase")):
+    typer.echo("ask: coming soon")
+
+
+if __name__ == "__main__":
+    app()

codegraph_cli_ai-0.1.9/codegraph/graph/builder.py

@@ -0,0 +1,190 @@
+"""
+Graph Builder for CodeGraph AI
+
+Node types:
+  - file       : a .py file
+  - function   : top-level function
+  - class      : a class
+  - method     : a method belonging to a class
+  - module     : an imported module/package
+
+Edge types:
+  - contains   : file → function, file → class, class → method
+  - calls      : function/method → function/method
+  - imports    : file → module
+  - defined_in : function/method → file
+"""
+
+import builtins
+import networkx as nx
+from pathlib import Path
+from codegraph.parsers.python_parser import ParsedFile
+from codegraph.parsers.multimodal_parser import ParsedAsset
+
+
+BUILTIN_FUNCTIONS = set(dir(builtins))
+
+
+class GraphBuilder:
+    def __init__(self):
+        self.graph = nx.DiGraph()
+        self._function_to_file: dict[str, str] = {}
+        self._assets: list[ParsedAsset] = []
+        self._parsed_files: list[ParsedFile] = []
+
+    def add_file(self, parsed: ParsedFile) -> None:
+        self._parsed_files.append(parsed)
+        file_id = self._file_node_id(parsed.filepath)
+        filename = Path(parsed.filepath).name
+
+        self._add_node(file_id, kind="file", label=filename, external=False)
+
+        for cls in parsed.classes:
+            cls_id = f"class:{file_id}:{cls}"
+            self._add_node(cls_id, kind="class", label=cls, external=False, file=file_id)
+            self._add_edge(file_id, cls_id, relation="contains")
+
+        for func in parsed.functions:
+            func_id = f"func:{file_id}:{func}"
+            self._add_node(func_id, kind="function", label=func, external=False, file=file_id)
+            self._add_edge(file_id, func_id, relation="contains")
+            self._add_edge(func_id, file_id, relation="defined_in")
+            self._function_to_file[func] = file_id
+
+        for cls_name, method_name in parsed.methods:
+            cls_id = f"class:{file_id}:{cls_name}"
+            method_id = f"func:{file_id}:{method_name}"
+            self._add_node(method_id, kind="method", label=method_name, external=False, file=file_id, cls=cls_name)
+            self._add_edge(cls_id, method_id, relation="contains")
+            self._add_edge(method_id, file_id, relation="defined_in")
+            self._function_to_file[method_name] = file_id
+
+        for imp in parsed.imports:
+            mod_id = f"module:{imp}"
+            self._add_node(mod_id, kind="module", label=imp, external=True)
+            self._add_edge(file_id, mod_id, relation="imports")
+
+        for caller, callee in parsed.calls:
+            if callee in BUILTIN_FUNCTIONS:
+                continue
+            
+            # Use file context for caller
+            caller_id = f"func:{file_id}:{caller}"
+            
+            # Resolve callee ID using global map or default to external
+            target_file_id = self._function_to_file.get(callee)
+            if target_file_id:
+                callee_id = f"func:{target_file_id}:{callee}"
+            else:
+                callee_id = f"func:external:{callee}"
+                if not self.graph.has_node(callee_id):
+                    self._add_node(callee_id, kind="function", label=callee, external=True)
+            
+            self._add_edge(caller_id, callee_id, relation="calls")
+
+    def add_asset(self, asset: ParsedAsset) -> None:
+        self._assets.append(asset)
+        filename = Path(asset.filepath).name
+        node_id = f"{asset.kind}:{filename}"
+        
+        self._add_node(
+            node_id, 
+            kind=asset.kind, 
+            label=filename, 
+            filename=filename, # keep raw filename for linking
+            external=False, 
+            metadata=asset.metadata
+        )
+
+    def link_code_to_assets(self) -> None:
+        """
+        Connect code nodes to assets if the filename appears in:
+        - function name
+        - call list
+        - string usage
+        """
+        for node_id, data in list(self.graph.nodes(data=True)):
+            if data.get("kind") not in ("function", "method"):
+                continue
+            
+            # Get function metadata from parsed files
+            func_name = data.get("label")
+            file_id = data.get("file")
+            
+            # Find the parsed file this function belongs to
+            parsed = next((p for p in self._parsed_files if self._file_node_id(p.filepath) == file_id), None)
+            if not parsed:
+                continue
+
+            # Check each asset
+            for asset in self._assets:
+                asset_filename = Path(asset.filepath).name
+                asset_id = f"{asset.kind}:{asset_filename}"
+                relation = "uses" if asset.kind in ("dataset", "database") else "references"
+                
+                # Check 1: function name
+                if asset_filename in func_name:
+                    self._add_edge(node_id, asset_id, relation=relation)
+                    continue
+                
+                # Check 2: call list for this function
+                calls = [c[1] for c in parsed.calls if c[0] == func_name]
+                if any(asset_filename in callee for callee in calls):
+                    self._add_edge(node_id, asset_id, relation=relation)
+                    continue
+                
+                # Check 3: string usage
+                strings = parsed.strings.get(func_name, [])
+                if any(asset_filename in s for s in strings):
+                    self._add_edge(node_id, asset_id, relation=relation)
+                    continue
+
+    def build(self, parsed_files: list[ParsedFile], assets: list[ParsedAsset] = None) -> nx.DiGraph:
+        # First pass: add all files to populate function-to-file map
+        for parsed in parsed_files:
+            if not parsed.errors:
+                self.add_file(parsed)
+        
+        # Second pass: add assets
+        if assets:
+            for asset in assets:
+                self.add_asset(asset)
+        
+        # Third pass: link code to assets
+        self.link_code_to_assets()
+        
+        return self.graph
+
+    def summary(self) -> dict:
+        nodes_by_kind = {}
+        for _, data in self.graph.nodes(data=True):
+            kind = data.get("kind", "unknown")
+            nodes_by_kind[kind] = nodes_by_kind.get(kind, 0) + 1
+
+        edges_by_relation = {}
+        for _, _, data in self.graph.edges(data=True):
+            rel = data.get("relation", "unknown")
+            edges_by_relation[rel] = edges_by_relation.get(rel, 0) + 1
+
+        return {
+            "total_nodes": self.graph.number_of_nodes(),
+            "total_edges": self.graph.number_of_edges(),
+            "nodes_by_kind": nodes_by_kind,
+            "edges_by_relation": edges_by_relation,
+        }
+
+    def to_dict(self) -> dict:
+        return {
+            "nodes": [{"id": node, **data} for node, data in self.graph.nodes(data=True)],
+            "edges": [{"source": src, "target": dst, **data} for src, dst, data in self.graph.edges(data=True)],
+        }
+
+    def _file_node_id(self, filepath: str) -> str:
+        return f"file:{Path(filepath).name}"
+
+    def _add_node(self, node_id: str, **attrs) -> None:
+        if not self.graph.has_node(node_id):
+            self.graph.add_node(node_id, **attrs)
+
+    def _add_edge(self, src: str, dst: str, **attrs) -> None:
+        self.graph.add_edge(src, dst, **attrs)

codegraph_cli_ai-0.1.9/codegraph/parsers/database_parser.py

@@ -0,0 +1,25 @@
+"""
+Database Parser for CodeGraph AI
+Extracts metadata from SQLite databases.
+"""
+import sqlite3
+from pathlib import Path
+
+class DatabaseParser:
+    """
+    Parses SQLite files to extract table names.
+    """
+    
+    def parse(self, filepath: str) -> dict:
+        metadata = {"tables": []}
+        try:
+            conn = sqlite3.connect(filepath)
+            cursor = conn.cursor()
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            tables = [row[0] for row in cursor.fetchall()]
+            metadata["tables"] = tables
+            conn.close()
+        except Exception as e:
+            metadata["error"] = str(e)
+            
+        return metadata

codegraph_cli_ai-0.1.9/codegraph/parsers/image_parser.py

@@ -0,0 +1,39 @@
+"""
+Image Parser for CodeGraph AI
+Extracts text from images using pytesseract (OCR).
+"""
+import pytesseract
+from PIL import Image
+from pathlib import Path
+
+class ImageParser:
+    """
+    Parses Image files to extract text via OCR.
+    """
+    
+    def parse(self, filepath: str) -> dict:
+        """
+        Attempts OCR on the image. Falls back gracefully if OCR is unavailable.
+        """
+        metadata = {
+            "text": ""
+        }
+        
+        try:
+            # Check if tesseract is installed
+            # (In a real system we'd handle TesseractNotFoundError specifically)
+            img = Image.open(filepath)
+            ocr_text = pytesseract.image_to_string(img)
+            
+            # Limit the text length
+            if len(ocr_text) > 500:
+                ocr_text = ocr_text[:500] + "..."
+            
+            metadata["text"] = ocr_text.strip()
+            
+        except Exception as e:
+            # If tesseract is not found or fails, we still return success with empty text
+            # as requested in the requirements (handle failure gracefully)
+            metadata["error"] = f"OCR failed or not available: {str(e)}"
+            
+        return metadata

codegraph_cli_ai-0.1.9/codegraph/parsers/multimodal_parser.py

@@ -0,0 +1,86 @@
+"""
+MultiModal Parser for CodeGraph AI
+Extracts metadata from non-code assets like CSV, JSON, SQLite, PDF, and Images.
+"""
+import json
+import csv
+import sqlite3
+from pathlib import Path
+from dataclasses import dataclass, field
+
+from codegraph.parsers.pdf_parser import PDFParser
+from codegraph.parsers.image_parser import ImageParser
+from codegraph.parsers.database_parser import DatabaseParser
+
+
+@dataclass
+class ParsedAsset:
+    filepath: str
+    kind: str  # "dataset" | "database" | "document" | "image"
+    metadata: dict = field(default_factory=dict)
+
+
+class MultiModalParser:
+    """
+    Parses non-Python files (CSV, JSON, SQLite, PDF, Image) to extract metadata.
+    """
+
+    def __init__(self):
+        self.pdf_parser = PDFParser()
+        self.image_parser = ImageParser()
+        self.database_parser = DatabaseParser()
+
+    def parse(self, filepath: str) -> ParsedAsset:
+        path = Path(filepath)
+        suffix = path.suffix.lower()
+
+        if suffix == ".csv":
+            return self._parse_csv(path)
+        elif suffix == ".json":
+            return self._parse_json(path)
+        elif suffix in (".db", ".sqlite"):
+            return self._parse_sqlite(path)
+        elif suffix == ".pdf":
+            return self._parse_pdf(path)
+        elif suffix in (".png", ".jpg", ".jpeg"):
+            return self._parse_image(path)
+        else:
+            return ParsedAsset(filepath=str(path), kind="unknown")
+
+    def _parse_csv(self, path: Path) -> ParsedAsset:
+        metadata = {"columns": []}
+        try:
+            with path.open("r", encoding="utf-8") as f:
+                reader = csv.reader(f)
+                header = next(reader, [])
+                metadata["columns"] = header
+        except Exception as e:
+            metadata["error"] = str(e)
+        
+        return ParsedAsset(filepath=str(path), kind="dataset", metadata=metadata)
+
+    def _parse_json(self, path: Path) -> ParsedAsset:
+        metadata = {"keys": []}
+        try:
+            with path.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, dict):
+                    metadata["keys"] = list(data.keys())
+                elif isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict):
+                    metadata["keys"] = list(data[0].keys())
+        except Exception as e:
+            metadata["error"] = str(e)
+            
+        return ParsedAsset(filepath=str(path), kind="dataset", metadata=metadata)
+
+    def _parse_sqlite(self, path: Path) -> ParsedAsset:
+        metadata = self.database_parser.parse(str(path))
+        return ParsedAsset(filepath=str(path), kind="database", metadata=metadata)
+
+    def _parse_pdf(self, path: Path) -> ParsedAsset:
+        metadata = self.pdf_parser.parse(str(path))
+        return ParsedAsset(filepath=str(path), kind="document", metadata=metadata)
+
+    def _parse_image(self, path: Path) -> ParsedAsset:
+        metadata = self.image_parser.parse(str(path))
+        return ParsedAsset(filepath=str(path), kind="image", metadata=metadata)

codegraph_cli_ai-0.1.9/codegraph/parsers/pdf_parser.py

@@ -0,0 +1,43 @@
+"""
+PDF Parser for CodeGraph AI
+Extracts text and metadata from PDF files using pypdf.
+"""
+from pathlib import Path
+from pypdf import PdfReader
+
+class PDFParser:
+    """
+    Parses PDF files to extract basic text preview and page count.
+    """
+    
+    def parse(self, filepath: str) -> dict:
+        """
+        Extracts metadata from the first few pages of a PDF.
+        """
+        metadata = {
+            "num_pages": 0,
+            "text_preview": ""
+        }
+        
+        try:
+            reader = PdfReader(filepath)
+            metadata["num_pages"] = len(reader.pages)
+            
+            # Extract text from first 2 pages as a preview
+            preview_text = []
+            for i in range(min(2, len(reader.pages))):
+                text = reader.pages[i].extract_text()
+                if text:
+                    preview_text.append(text.strip())
+            
+            # Limit the preview length to avoid huge tooltips
+            full_preview = "\n---\n".join(preview_text)
+            if len(full_preview) > 500:
+                full_preview = full_preview[:500] + "..."
+            
+            metadata["text_preview"] = full_preview
+            
+        except Exception as e:
+            metadata["error"] = str(e)
+            
+        return metadata