Add Apache Atlas export, graph interactivity, and polish

Features:
- Apache Atlas exporter for open-source data governance
- Enhanced graph visualization with click-to-zoom
- PNG/SVG download buttons for lineage graphs
- Updated README with HF username and Space URL
- 5 export formats now supported

Tests: 13 passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -23,7 +23,7 @@ tags:
 
 **AI-powered data lineage extraction and visualization for modern data platforms**
 
-[![HuggingFace Space](https://img.shields.io/badge/🤗%20Hugging%20Face-Space-blue)](https://huggingface.co/spaces/YOUR_SPACE)
+[![HuggingFace Space](https://img.shields.io/badge/🤗%20Hugging%20Face-Space-blue)](https://huggingface.co/spaces/aamanlamba/Lineage-graph-accelerator)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Gradio](https://img.shields.io/badge/Gradio-6.0.0-orange)](https://gradio.app)
 
@@ -264,14 +264,15 @@ python test_setup.py
 **Track**: Track 2 - MCP in Action (Productivity)
 
 **Team Members**:
-- [Your HuggingFace Username]
+
+- [aamanlamba](https://huggingface.co/aamanlamba)
 
 ### Judging Criteria Alignment
 
 | Criteria | Implementation |
 |----------|----------------|
 | **UI/UX Design** | Clean, professional interface with tabs, accordions, and color-coded visualizations |
-| **Functionality** | Full MCP integration, multiple input formats, 4 export formats |
+| **Functionality** | Full MCP integration, multiple input formats, 5 export formats |
 | **Creativity** | Novel approach to data lineage visualization with AI-powered parsing |
 | **Documentation** | Comprehensive README, USER_GUIDE.md, inline comments |
 | **Real-world Impact** | Solves critical enterprise need for data governance and compliance |
@@ -288,11 +289,11 @@ python test_setup.py
 
 ## 🔜 Roadmap
 
-- [ ] Gradio 6 upgrade for enhanced UI components
+- [x] Gradio 6 upgrade for enhanced UI components
 - [ ] Agentic chatbot for natural language queries
-- [ ] Apache Atlas export support
+- [x] Apache Atlas export support
 - [ ] File upload functionality
-- [ ] Graph export as PNG/SVG
+- [x] Graph export as PNG/SVG
 - [ ] Batch processing API
 - [ ] Column-level lineage
 

app.py

@@ -16,7 +16,7 @@ from datetime import datetime
 try:
     from exporters import (
         LineageGraph, LineageNode, LineageEdge,
-        OpenLineageExporter, CollibraExporter, PurviewExporter, AlationExporter
+        OpenLineageExporter, CollibraExporter, PurviewExporter, AlationExporter, AtlasExporter
     )
     EXPORTERS_AVAILABLE = True
 except ImportError:
@@ -38,7 +38,7 @@ SAMPLE_FILES = {
     "bigquery": "sample_bigquery.sql"
 }
 
-EXPORT_FORMATS = ["OpenLineage", "Collibra", "Purview", "Alation"]
+EXPORT_FORMATS = ["OpenLineage", "Collibra", "Purview", "Alation", "Atlas"]
 
 # Preset MCP Servers on HuggingFace that can provide metadata
 MCP_PRESETS = {
@@ -209,14 +209,28 @@ def render_mermaid(viz_code: str) -> str:
     # Create the mermaid.ink URL for SVG rendering
     img_url = f"https://mermaid.ink/svg/{encoded}"
 
+    # PNG version for download
+    png_url = f"https://mermaid.ink/img/{encoded}"
+
     # Also create a link to the live editor for users who want to modify
     editor_url = f"https://mermaid.live/edit#base64:{base64.b64encode(viz_code.encode('utf-8')).decode('utf-8')}"
 
     html = f'''
     <div style="background: white; padding: 20px; border-radius: 8px; min-height: 200px;">
-        <img src="{img_url}" alt="Lineage Graph" style="max-width: 100%; height: auto;" />
-        <div style="margin-top: 10px; font-size: 12px; color: #666;">
-            <a href="{editor_url}" target="_blank" style="color: #7c3aed;">Open in Mermaid Live Editor</a>
+        <div style="overflow: auto; max-height: 500px; border: 1px solid #e0e0e0; border-radius: 4px; padding: 10px;">
+            <img id="lineage-graph" src="{img_url}" alt="Lineage Graph" style="max-width: 100%; height: auto; cursor: zoom-in;" onclick="this.style.maxWidth = this.style.maxWidth === 'none' ? '100%' : 'none'; this.style.cursor = this.style.cursor === 'zoom-in' ? 'zoom-out' : 'zoom-in';" />
+        </div>
+        <div style="margin-top: 12px; display: flex; gap: 16px; flex-wrap: wrap; align-items: center;">
+            <a href="{editor_url}" target="_blank" style="color: #7c3aed; text-decoration: none; font-size: 13px;">
+                Edit in Mermaid Live
+            </a>
+            <a href="{png_url}" download="lineage_graph.png" style="color: #2563eb; text-decoration: none; font-size: 13px;">
+                Download PNG
+            </a>
+            <a href="{img_url}" download="lineage_graph.svg" style="color: #059669; text-decoration: none; font-size: 13px;">
+                Download SVG
+            </a>
+            <span style="color: #888; font-size: 12px; margin-left: auto;">Click graph to zoom</span>
         </div>
     </div>
     '''
@@ -647,6 +661,8 @@ def export_lineage(metadata_text: str, source_type: str, export_format: str) ->
             exporter = PurviewExporter(graph)
         elif export_format == "Alation":
             exporter = AlationExporter(graph)
+        elif export_format == "Atlas":
+            exporter = AtlasExporter(graph)
         else:
             return "", f"Unknown export format: {export_format}"
 
@@ -779,7 +795,7 @@ with gr.Blocks(
     |---------|-------------|
     | **Extract Lineage** | Parse metadata from dbt manifests, Airflow DAGs, SQL DDL, BigQuery, and custom JSON |
     | **Visualize** | Generate interactive Mermaid diagrams with color-coded nodes and relationship labels |
-    | **Export** | Export to enterprise data catalogs: OpenLineage, Collibra, Microsoft Purview, Alation |
+    | **Export** | Export to enterprise data catalogs: OpenLineage, Collibra, Purview, Alation, Atlas |
     | **MCP Integration** | Connect to MCP servers for AI-powered metadata extraction |
 
     ### Quick Start

exporters/__init__.py

@@ -14,6 +14,7 @@ from .openlineage import OpenLineageExporter
 from .collibra import CollibraExporter
 from .purview import PurviewExporter
 from .alation import AlationExporter
+from .atlas import AtlasExporter
 
 __all__ = [
     'LineageExporter',
@@ -24,4 +25,5 @@ __all__ = [
     'CollibraExporter',
     'PurviewExporter',
     'AlationExporter',
+    'AtlasExporter',
 ]

exporters/atlas.py

@@ -0,0 +1,264 @@
+"""
+Apache Atlas Exporter - Export to Apache Atlas format.
+
+Apache Atlas is an open-source metadata management and data governance framework.
+https://atlas.apache.org/
+"""
+
+from typing import Dict, Any, List
+from datetime import datetime
+import uuid
+from .base import LineageExporter, LineageGraph, LineageNode, LineageEdge
+
+
+class AtlasExporter(LineageExporter):
+    """Export lineage to Apache Atlas format."""
+
+    def __init__(self, graph: LineageGraph, cluster_name: str = "lineage_accelerator"):
+        super().__init__(graph)
+        self.cluster_name = cluster_name
+
+    @property
+    def format_name(self) -> str:
+        return "Apache Atlas"
+
+    @property
+    def file_extension(self) -> str:
+        return ".json"
+
+    def _node_type_to_atlas_type(self, node_type: str) -> str:
+        """Map internal node types to Atlas type names."""
+        type_mapping = {
+            "table": "hive_table",
+            "view": "hive_table",
+            "model": "hive_table",
+            "source": "hive_db",
+            "destination": "hive_table",
+            "column": "hive_column",
+            "database": "hive_db",
+            "schema": "hive_db",
+            "report": "Report",
+            "dimension": "hive_table",
+            "fact": "hive_table",
+            "feature_set": "hive_table",
+            "semantic_model": "DataSet",
+            "external_api": "api_endpoint",
+            "extract": "hive_table",
+            "task": "Process"
+        }
+        return type_mapping.get(node_type.lower(), "DataSet")
+
+    def _generate_guid(self, identifier: str) -> str:
+        """Generate a deterministic GUID for an entity."""
+        return str(uuid.uuid5(uuid.NAMESPACE_DNS, f"{self.cluster_name}.{identifier}"))
+
+    def _create_qualified_name(self, node: LineageNode) -> str:
+        """Create Atlas-style qualified name for a node."""
+        parts = []
+        if node.database:
+            parts.append(node.database)
+        if node.schema:
+            parts.append(node.schema)
+        parts.append(node.name)
+        parts.append(self.cluster_name)
+        return ".".join(parts) + f"@{self.cluster_name}"
+
+    def _create_entity(self, node: LineageNode) -> Dict[str, Any]:
+        """Create an Atlas entity from a node."""
+        qualified_name = self._create_qualified_name(node)
+        atlas_type = self._node_type_to_atlas_type(node.type)
+
+        entity = {
+            "typeName": atlas_type,
+            "guid": self._generate_guid(node.id),
+            "attributes": {
+                "qualifiedName": qualified_name,
+                "name": node.name,
+                "description": node.description or f"{node.type}: {node.name}",
+                "owner": node.owner or "lineage_accelerator",
+                "createTime": int(datetime.now().timestamp() * 1000),
+                "modifiedTime": int(datetime.now().timestamp() * 1000)
+            },
+            "status": "ACTIVE"
+        }
+
+        # Add type-specific attributes
+        if atlas_type == "hive_table":
+            entity["attributes"]["tableType"] = "MANAGED_TABLE"
+            if node.database:
+                entity["attributes"]["db"] = {
+                    "typeName": "hive_db",
+                    "uniqueAttributes": {
+                        "qualifiedName": f"{node.database}@{self.cluster_name}"
+                    }
+                }
+
+        # Add columns if present
+        if node.columns:
+            entity["attributes"]["columns"] = [
+                {
+                    "typeName": "hive_column",
+                    "uniqueAttributes": {
+                        "qualifiedName": f"{qualified_name}.{col.get('name')}@{self.cluster_name}"
+                    }
+                }
+                for col in node.columns
+            ]
+
+        # Add classification tags
+        if node.tags:
+            entity["classifications"] = [
+                {"typeName": tag} for tag in node.tags
+            ]
+
+        # Add custom attributes
+        if node.metadata:
+            entity["attributes"]["additionalProperties"] = node.metadata
+
+        if node.category:
+            entity["attributes"]["dataLayer"] = node.category
+
+        return entity
+
+    def _create_column_entities(self, node: LineageNode) -> List[Dict[str, Any]]:
+        """Create Atlas column entities from a node's columns."""
+        if not node.columns:
+            return []
+
+        table_qualified_name = self._create_qualified_name(node)
+        columns = []
+
+        for idx, col in enumerate(node.columns):
+            col_name = col.get("name", f"column_{idx}")
+            col_qualified_name = f"{table_qualified_name}.{col_name}"
+
+            column_entity = {
+                "typeName": "hive_column",
+                "guid": self._generate_guid(f"{node.id}.{col_name}"),
+                "attributes": {
+                    "qualifiedName": col_qualified_name,
+                    "name": col_name,
+                    "type": col.get("type") or col.get("data_type", "string"),
+                    "description": col.get("description", ""),
+                    "position": idx,
+                    "table": {
+                        "typeName": self._node_type_to_atlas_type(node.type),
+                        "uniqueAttributes": {
+                            "qualifiedName": table_qualified_name
+                        }
+                    }
+                },
+                "status": "ACTIVE"
+            }
+
+            columns.append(column_entity)
+
+        return columns
+
+    def _create_process_entity(self, edge: LineageEdge) -> Dict[str, Any]:
+        """Create an Atlas process entity from an edge (for lineage)."""
+        source_node = self.graph.get_node(edge.source)
+        target_node = self.graph.get_node(edge.target)
+
+        process_name = edge.job_name or f"process_{edge.source}_to_{edge.target}"
+        process_qualified_name = f"{process_name}@{self.cluster_name}"
+
+        # Build inputs and outputs
+        inputs = []
+        outputs = []
+
+        if source_node:
+            inputs.append({
+                "typeName": self._node_type_to_atlas_type(source_node.type),
+                "uniqueAttributes": {
+                    "qualifiedName": self._create_qualified_name(source_node)
+                }
+            })
+
+        if target_node:
+            outputs.append({
+                "typeName": self._node_type_to_atlas_type(target_node.type),
+                "uniqueAttributes": {
+                    "qualifiedName": self._create_qualified_name(target_node)
+                }
+            })
+
+        process = {
+            "typeName": "Process",
+            "guid": self._generate_guid(f"process.{edge.source}.{edge.target}"),
+            "attributes": {
+                "qualifiedName": process_qualified_name,
+                "name": process_name,
+                "description": edge.transformation or f"Data flow: {edge.type}",
+                "inputs": inputs,
+                "outputs": outputs,
+                "operationType": edge.type.upper() if edge.type else "ETL"
+            },
+            "status": "ACTIVE"
+        }
+
+        if edge.job_id:
+            process["attributes"]["jobId"] = edge.job_id
+
+        return process
+
+    def export(self) -> str:
+        """Export to Apache Atlas JSON format."""
+        return self.to_json(indent=2)
+
+    def _to_dict(self) -> Dict[str, Any]:
+        """Convert to Atlas bulk import dictionary."""
+        entities = []
+        referred_entities = {}
+
+        # Create database entities
+        databases = set()
+        for node in self.graph.nodes:
+            if node.database and node.database not in databases:
+                databases.add(node.database)
+                db_entity = {
+                    "typeName": "hive_db",
+                    "guid": self._generate_guid(f"db.{node.database}"),
+                    "attributes": {
+                        "qualifiedName": f"{node.database}@{self.cluster_name}",
+                        "name": node.database,
+                        "description": f"Database: {node.database}",
+                        "clusterName": self.cluster_name
+                    },
+                    "status": "ACTIVE"
+                }
+                entities.append(db_entity)
+
+        # Create table/dataset entities
+        for node in self.graph.nodes:
+            entity = self._create_entity(node)
+            entities.append(entity)
+
+            # Create column entities
+            for col_entity in self._create_column_entities(node):
+                entities.append(col_entity)
+
+        # Create process entities for lineage
+        for edge in self.graph.edges:
+            process = self._create_process_entity(edge)
+            entities.append(process)
+
+        return {
+            "exportInfo": {
+                "producer": "Lineage Graph Accelerator",
+                "exportedAt": self.graph.generated_at,
+                "sourceLineageName": self.graph.name,
+                "format": "Apache Atlas",
+                "version": "2.0"
+            },
+            "atlasVersion": "2.3.0",
+            "cluster": self.cluster_name,
+            "entities": entities,
+            "referredEntities": referred_entities,
+            "summary": {
+                "totalEntities": len(entities),
+                "databases": list(databases),
+                "entityTypes": list(set(e["typeName"] for e in entities)),
+                "processCount": len(self.graph.edges)
+            }
+        }

tests/test_app.py

@@ -96,6 +96,21 @@ class TestExporters(unittest.TestCase):
         self.assertIn("Alation", output)
         self.assertIn("Node A", output)
 
+    def test_atlas_export(self):
+        from exporters import LineageGraph, LineageNode, LineageEdge, AtlasExporter
+
+        graph = LineageGraph(name="test")
+        graph.add_node(LineageNode(id="a", name="Node A", type="table"))
+        graph.add_node(LineageNode(id="b", name="Node B", type="table"))
+        graph.add_edge(LineageEdge(source="a", target="b", type="transform"))
+
+        exporter = AtlasExporter(graph)
+        output = exporter.export()
+
+        self.assertIn("Atlas", output)
+        self.assertIn("Node A", output)
+        self.assertIn("entities", output)
+
 
 class TestSampleDataLoading(unittest.TestCase):
     def test_load_sample_simple(self):