# Manual algorithm selection and interpretation
communities = nx.community.greedy_modularity_communities(G)
centrality = nx.pagerank(G)
# ... complex result analysis ...

# GraphQA automatically chooses based on your graph characteristics:
if graph_size == "small" and preference == "comprehensive":
    use_betweenness_centrality()  # O(V³) - thorough but slow
elif graph_size == "large" and preference == "fast":  
    use_degree_centrality()      # O(V) - fast approximation
else:
    use_pagerank()               # O(V+E) - balanced choice

from graphqa import GraphQA

# Initialize GraphQA
agent = GraphQA(dataset_name="amazon")
print("✅ GraphQA ready!")

from graphqa import GraphQA

# Load any graph dataset into memory as NetworkX graph
agent = GraphQA(dataset_name="amazon")
agent.load_dataset()  # Loads into NetworkX MultiDiGraph

# Ask questions in natural language  
response = agent.ask("What are the most connected nodes?")
print(response)

# Follow-up questions use conversation context
response = agent.ask("Show me their categories")
print(response)

agent.shutdown()

from graphqa import GraphQA

# Load dataset
agent = GraphQA(dataset_name="amazon")
agent.load_dataset()

# Access the underlying NetworkX graph directly
graph = agent.graph  # NetworkX MultiDiGraph object
print(f"Nodes: {graph.number_of_nodes()}")
print(f"Edges: {graph.number_of_edges()}")

# Use any NetworkX algorithms directly
import networkx as nx
centrality = nx.degree_centrality(graph)
communities = nx.community.greedy_modularity_communities(graph)

# Or let GraphQA's AI choose the right algorithms
response = agent.ask("Find the most central nodes and detect communities")
print(response)

import networkx as nx
from graphqa import GraphQA

# Create your own NetworkX graph
graph = nx.MultiDiGraph()
graph.add_node("A", type="server", region="us-west-2")
graph.add_node("B", type="database", region="us-east-1")  
graph.add_edge("A", "B", relationship="connects_to", weight=1.0)

# Load into GraphQA for natural language analysis
agent = GraphQA()
agent.graph = graph
agent._discover_and_setup_schema()  # Auto-discover schema

# Now ask questions about your custom graph
response = agent.ask("What nodes are in the us-west-2 region?")
print(response)

from graphqa.loaders import BaseGraphLoader
import networkx as nx

class MyCustomLoader(BaseGraphLoader):
    """Custom loader for your specific data format"""
    
    def __init__(self, config: Dict[str, Any] = None):
        super().__init__(config)
        self.data_source = self.config.get('data_source', 'my_data.json')
    
    def load_graph(self) -> nx.MultiDiGraph:
        """
        REQUIRED: Load your data and return a NetworkX MultiDiGraph
        This is the core method you must implement
        """
        graph = nx.MultiDiGraph()
        
        # Your custom data loading logic here
        # Example: loading from JSON, CSV, database, API, etc.
        
        return graph
    
    def get_dataset_description(self) -> str:
        """REQUIRED: Describe what this dataset contains"""
        return "My custom dataset containing..."
    
    def get_sample_queries(self) -> List[str]:
        """REQUIRED: Provide example questions for this dataset"""
        return [
            "What are the most connected entities?",
            "Find clusters in the data",
            "Show me the network structure"
        ]
    
    # Optional: Override these methods for custom behavior
    def get_dataset_name(self) -> str:
        return "MyCustomDataset"
    
    def get_data_sources(self) -> List[str]:
        return [self.data_source]

import json
import pandas as pd
import networkx as nx
from graphqa.loaders import BaseGraphLoader
from pathlib import Path

class SocialNetworkLoader(BaseGraphLoader):
    """Example: Load social network data from CSV files"""
    
    def __init__(self, config: Dict[str, Any] = None):
        super().__init__(config)
        
        # Configure data sources
        self.users_file = self.config.get('users_file', 'users.csv')
        self.connections_file = self.config.get('connections_file', 'connections.csv')
        self.max_users = self.config.get('max_users', None)
        
        self.logger.info(f"Social network loader initialized")

    def load_graph(self) -> nx.MultiDiGraph:
        """Load social network data into NetworkX graph"""
        graph = nx.MultiDiGraph()
        
        try:
            # Load user data (nodes)
            users_df = pd.read_csv(self.users_file)
            if self.max_users:
                users_df = users_df.head(self.max_users)
            
            # Add nodes with attributes
            for _, user in users_df.iterrows():
                graph.add_node(
                    user['user_id'],
                    name=user.get('name', ''),
                    age=user.get('age', 0),
                    location=user.get('location', ''),
                    followers=user.get('followers', 0),
                    # Add any other attributes from your data
                )
            
            # Load connections (edges)
            connections_df = pd.read_csv(self.connections_file)
            
            for _, conn in connections_df.iterrows():
                source = conn['user_id']
                target = conn['friend_id']
                
                # Only add edge if both nodes exist
                if graph.has_node(source) and graph.has_node(target):
                    graph.add_edge(
                        source, target,
                        relationship_type='friendship',
                        weight=conn.get('strength', 1.0),
                        created_date=conn.get('date', '')
                    )
            
            self.logger.info(f"Loaded {graph.number_of_nodes()} users, {graph.number_of_edges()} connections")
            return graph
            
        except Exception as e:
            raise LoaderError(f"Failed to load social network data: {e}")

    def get_dataset_description(self) -> str:
        return (
            "Social Network dataset containing user profiles and friendship connections. "
            "Includes user demographics, follower counts, and relationship data for "
            "analyzing social influence and community structures."
        )
    
    def get_sample_queries(self) -> List[str]:
        return [
            "Who are the most popular users?",
            "Find friend groups and communities",
            "What's the average number of connections?",
            "Show me users in the same location",
            "Which users have the most influence?",
            "Find the shortest path between two users",
            "Analyze age distribution in the network",
            "Identify users with unusual connection patterns"
        ]
    
    def get_dataset_name(self) -> str:
        return "Social Network"

class MultiSourceLoader(BaseGraphLoader):
    """Example: Combine data from multiple sources"""
    
    def load_graph(self) -> nx.MultiDiGraph:
        graph = nx.MultiDiGraph()
        
        # Load from database
        graph = self._load_from_database(graph)
        
        # Enrich with API data
        graph = self._enrich_with_api(graph)
        
        # Add computed features
        graph = self._add_computed_features(graph)
        
        return graph
    
    def _load_from_database(self, graph):
        # Your database loading logic
        return graph
    
    def _enrich_with_api(self, graph):
        # API enrichment logic
        return graph
    
    def _add_computed_features(self, graph):
        # Add computed node/edge attributes
        for node in graph.nodes():
            graph.nodes[node]['degree'] = graph.degree(node)
        return graph

    def load_graph(self) -> nx.MultiDiGraph:
        graph = nx.MultiDiGraph()
        
        # Validate data sources exist
        for source in self.get_data_sources():
            if not Path(source).exists():
                raise LoaderError(f"Data source not found: {source}")
        
        try:
            # Load with progress tracking
            total_steps = 3
            
            self.logger.info("Step 1/3: Loading nodes...")
            self._load_nodes(graph)
            
            self.logger.info("Step 2/3: Loading edges...")
            self._load_edges(graph)
            
            self.logger.info("Step 3/3: Validating graph...")
            self._validate_graph(graph)
            
            return graph
            
        except Exception as e:
            self.logger.error(f"Data loading failed: {e}")
            raise LoaderError(f"Cannot load dataset: {e}")
    
    def _validate_graph(self, graph):
        """Custom validation logic"""
        if graph.number_of_nodes() == 0:
            raise LoaderError("No nodes loaded - check your data")
        
        # Add your specific validation rules
        isolated_nodes = [n for n in graph.nodes() if graph.degree(n) == 0]
        if len(isolated_nodes) > graph.number_of_nodes() * 0.5:
            self.logger.warning(f"Many isolated nodes: {len(isolated_nodes)}")

from graphqa import GraphQA
from my_loaders import SocialNetworkLoader

# Create custom config
config = {
    'users_file': 'my_social_data/users.csv',
    'connections_file': 'my_social_data/connections.csv',
    'max_users': 10000  # Limit for testing
}

# Initialize GraphQA with custom loader
loader = SocialNetworkLoader(config)
agent = GraphQA()
agent.loader = loader
agent.load_dataset()

# Now use natural language on your data!
response = agent.ask("Find the most influential users in the network")
print(response)

# Register your loader with GraphQA
from graphqa.loaders import register_loader

register_loader("social_network", SocialNetworkLoader)

# Now use it like built-in loaders
agent = GraphQA(dataset_name="social_network", config=config)
agent.load_dataset()

from graphqa import GraphQA

# Option 1: Use custom config file
agent = GraphQA(dataset_name="amazon", config_file="my_config.yaml")

# Option 2: Programmatic configuration
from graphqa.config import UniversalRetrieverConfig
config = UniversalRetrieverConfig()
config.datasets['amazon_products'].config['test_mode'] = False  # Full dataset
agent = GraphQA(dataset_name="amazon", config=config)

agent.load_dataset()