Visualizations

from functor_sdk import FunctorClient

client = FunctorClient(api_key="your-api-key")

# List all available visualizations
viz_list = client.visualizations.list()

for kg_name, files in viz_list.items():
    print(f"{kg_name}: {', '.join(files)}")

# Get metadata for a specific knowledge graph
metadata = client.visualizations.get_metadata("KG_Universal")
print(f"Index URL: {metadata.index_url}")
print(f"Available: {metadata.available_visualizations}")

# List visualizations organized by knowledge graph
visualizations = client.visualizations.list()

# Example response
# {
#   "KG_Universal": ["dashboard.html", "network_visualization.html", "index.html"],
#   "KG_Healthcare": ["dashboard.html", "index.html"]
# }

for kg_name, viz_files in visualizations.items():
    print(f"\nKG: {kg_name}")
    print(f"  Files: {', '.join(viz_files)}")

# Get metadata for a specific knowledge graph
metadata = client.visualizations.get_metadata("KG_Universal")

# Access visualization URLs
print(f"Index URL: {metadata.index_url}")
print(f"Dashboard URL: {metadata.dashboard_url}")
print(f"Network URL: {metadata.network_url}")
print(f"Available types: {metadata.available_visualizations}")

# Get direct URL to dashboard
dashboard_url = client.visualizations.get_dashboard_url("KG_Universal")

# Get direct URL to network visualization  
network_url = client.visualizations.get_network_url("KG_Universal")

print(f"Dashboard: {dashboard_url}")
print(f"Network: {network_url}")

visualizations = client.visualizations.list()
# No parameters required

# Returns: Dict[str, List[str]]
# Dictionary mapping KG names to lists of visualization file names

metadata = client.visualizations.get_metadata(
    kg_name="KG_Universal"  # Required: Knowledge graph name
)

# Returns: VisualizationInfo object with fields:
#   - kg_name: str
#   - available_visualizations: List[str]
#   - index_url: Optional[str]
#   - dashboard_url: Optional[str]
#   - network_url: Optional[str]

dashboard_url = client.visualizations.get_dashboard_url(
    kg_name="KG_Universal"  # Required: Knowledge graph name
)

# Returns: str
# Full URL to the dashboard HTML file

network_url = client.visualizations.get_network_url(
    kg_name="KG_Universal"  # Required: Knowledge graph name
)

# Returns: str
# Full URL to the network visualization HTML file

{
  "KG_Universal": [
    "dashboard.html",
    "network_visualization.html",
    "index.html",
    "network_graph.png"
  ],
  "KG_Healthcare": [
    "dashboard.html",
    "index.html"
  ]
}

{
  "kg_name": "KG_Universal",
  "available_visualizations": [
    "dashboard.html",
    "network_visualization.html",
    "index.html"
  ],
  "index_url": "/api/visualizations/KG_Universal/index.html",
  "dashboard_url": "https://api.functor.ai/api/visualizations/KG_Universal/dashboard.html",
  "network_url": "https://api.functor.ai/api/visualizations/KG_Universal/network_visualization.html"
}

def generate_embed_code(kg_name):
    """Generate HTML iframe code for embedding visualizations."""
    client = FunctorClient()
    
    try:
        metadata = client.visualizations.get_metadata(kg_name)
        
        # Generate iframe code for dashboard
        dashboard_iframe = f'''
        <iframe
            src="{metadata.dashboard_url}"
            width="100%"
            height="600"
            frameborder="0">
        </iframe>
        '''
        
        # Generate iframe code for network visualization
        network_iframe = f'''
        <iframe
            src="{metadata.network_url}"
            width="100%"
            height="600"
            frameborder="0">
        </iframe>
        '''
        
        return {
            "dashboard": dashboard_iframe,
            "network": network_iframe
        }
        
    except Exception as e:
        return {"error": str(e)}

# Usage
embed_code = generate_embed_code("KG_Universal")
print(embed_code["dashboard"])

def check_visualizations_exist(kg_name):
    """Check if visualizations exist for a knowledge graph."""
    client = FunctorClient()
    
    try:
        # Try to get metadata
        metadata = client.visualizations.get_metadata(kg_name)
        
        return {
            "available": True,
            "kg_name": kg_name,
            "visualization_count": len(metadata.available_visualizations),
            "has_dashboard": "dashboard.html" in metadata.available_visualizations,
            "has_network": "network_visualization.html" in metadata.available_visualizations
        }
        
    except Exception as e:
        return {
            "available": False,
            "kg_name": kg_name,
            "error": str(e)
        }

# Usage
status = check_visualizations_exist("KG_Universal")
if status["available"]:
    print(f"Found {status['visualization_count']} visualizations")
else:
    print(f"No visualizations: {status['error']}")

import asyncio
from functor_sdk import FunctorClient

async def fetch_all_visualizations():
    """Fetch visualization metadata for multiple KGs concurrently."""
    async with FunctorClient() as client:
        # First, list all available visualizations
        viz_list = await client.visualizations.list_async()
        
        # Fetch metadata for each KG concurrently
        kg_names = list(viz_list.keys())
        metadata_tasks = [
            client.visualizations.get_metadata_async(kg_name)
            for kg_name in kg_names
        ]
        
        metadata_results = await asyncio.gather(*metadata_tasks, return_exceptions=True)
        
        # Combine results
        results = {}
        for kg_name, metadata in zip(kg_names, metadata_results):
            if isinstance(metadata, Exception):
                results[kg_name] = {"error": str(metadata)}
            else:
                results[kg_name] = {
                    "index_url": metadata.index_url,
                    "dashboard_url": metadata.dashboard_url,
                    "network_url": metadata.network_url,
                    "available_types": metadata.available_visualizations
                }
        
        return results

# Usage
results = asyncio.run(fetch_all_visualizations())
for kg_name, data in results.items():
    if "error" in data:
        print(f"{kg_name}: {data['error']}")
    else:
        print(f"{kg_name}: {len(data['available_types'])} visualizations")

from functor_sdk import (
    FunctorClient,
    FunctorAPIError,
    FunctorNotFoundError
)

client = FunctorClient()

try:
    metadata = client.visualizations.get_metadata("KG_Unknown")
    
except FunctorNotFoundError:
    print("No visualizations found for this knowledge graph")
    # List available KGs
    available = client.visualizations.list()
    print(f"Available KGs: {list(available.keys())}")
    
except FunctorAPIError as e:
    print(f"API error {e.status_code}: {e.message}")
    
except Exception as e:
    print(f"Unexpected error: {e}")