from semantica.kg import (
    GraphAnalyzer, 
    CentralityCalculator,
    CommunityDetector,
    ConnectivityAnalyzer,
    analyze_graph,
    calculate_centrality,
    detect_communities,
    analyze_connectivity
)

# Method 1: Using convenience functions
analysis = analyze_graph(kg, method="default")
centrality_scores = calculate_centrality(kg, method="degree")
communities = detect_communities(kg, method="louvain")
connectivity = analyze_connectivity(kg, method="default")

# Method 2: Using classes for more control
analyzer = GraphAnalyzer()
centrality_calc = CentralityCalculator()
community_detector = CommunityDetector()
connectivity_analyzer = ConnectivityAnalyzer()

# Run comprehensive analysis
analysis = analyzer.analyze(kg)
print(f"Graph density: {analysis['density']:.3f}")
print(f"Average degree: {analysis['avg_degree']:.2f}")

# Calculate centrality measures
degree_centrality = centrality_calc.calculate(kg, method="degree")
betweenness = centrality_calc.calculate(kg, method="betweenness")
print(f"Top entities by degree: {list(degree_centrality.items())[:3]}")

# Detect communities
communities = community_detector.detect(kg, method="louvain")
print(f"Found {len(communities)} communities")

# Analyze connectivity
conn = connectivity_analyzer.analyze(kg)
print(f"Connected components: {conn['num_components']}")
print(f"Largest component: {conn['largest_component_size']} nodes")

# Example: "Tim Cook works for Apple Inc."
# Extracted: (Tim Cook) --[works_for]--> (Apple Inc.)

# Example: "WWDC 2023 happened before WWDC 2024"
# Extracted: (WWDC 2023) --[happened_before]--> (WWDC 2024)

# Example: "High inflation causes economic instability"
# Extracted: (High inflation) --[causes]--> (Economic instability)

from semantica.embeddings import EmbeddingGenerator, embed_text

# Using EmbeddingGenerator class
texts = [
    "Machine learning is transforming industries",
    "Artificial intelligence powers modern applications", 
    "Deep learning enables image recognition",
    "Cooking recipes are delicious"  # Different topic
]

generator = EmbeddingGenerator()

# Generate embeddings for multiple texts
embeddings = []
for text in texts:
    emb = generator.generate_embeddings(text, data_type="text")
    embeddings.append(emb)

print(f"Generated {len(embeddings)} embeddings")
print(f"Dimensions: {embeddings[0].shape}")

# Or use the convenience function for single text
embedding = embed_text("Hello, world!", method="sentence_transformers")
print(f"Single embedding shape: {embedding.shape}")

from semantica.embeddings import (
    EmbeddingGenerator,
    calculate_similarity
)
import numpy as np

generator = EmbeddingGenerator()

# Generate embeddings
query = "How does photosynthesis work?"
documents = [
    "Plants convert sunlight into energy through photosynthesis",
    "The process of photosynthesis occurs in chloroplasts",
    "Dogs are popular household pets",
    "Solar panels convert sunlight to electricity",
    "Chlorophyll absorbs light for photosynthesis"
]

query_emb = generator.generate_embeddings(query, data_type="text")
doc_embs = [generator.generate_embeddings(d, data_type="text") for d in documents]

print("Semantic Similarity Search:")
print(f"Query: \"{query}\"")

similarities = []
for i, doc_emb in enumerate(doc_embs):
    sim = calculate_similarity(query_emb, doc_emb, method="cosine")
    similarities.append((sim, documents[i]))

for sim, doc in sorted(similarities, reverse=True):
    relevance = "HIGH" if sim > 0.6 else "MED" if sim > 0.3 else "LOW"
    print(f"  [{relevance}] {sim:.3f}: {doc[:50]}...")

from semantica.embeddings import (
    TextEmbedder,
    ImageEmbedder,
    AudioEmbedder,
    MultimodalEmbedder
)

text_embedder = TextEmbedder(model="all-MiniLM-L6-v2")
text_emb = text_embedder.embed("A beautiful sunset over the ocean")
print(f"Text embedding: {text_emb.shape}")

image_embedder = ImageEmbedder(model="clip")
image_emb = image_embedder.embed("sunset_photo.jpg")
print(f"Image embedding: {image_emb.shape}")

audio_embedder = AudioEmbedder()
audio_emb = audio_embedder.embed("ocean_waves.mp3")
print(f"Audio embedding: {audio_emb.shape}")

multimodal = MultimodalEmbedder()
combined = multimodal.embed(
    text="sunset over ocean",
    image="sunset_photo.jpg",
    strategy="concatenate"
)
print(f"Combined embedding: {combined.shape}")

from semantica.embeddings import calculate_similarity
text_query = text_embedder.embed("beach at sunset")
images = ["beach.jpg", "mountain.jpg", "city.jpg"]

for img in images:
    img_emb = image_embedder.embed(img)
    sim = calculate_similarity(text_query, img_emb, method="cosine")
    print(f"  {img}: {sim:.3f}")

from semantica.embeddings import EmbeddingOptimizer
import numpy as np

optimizer = EmbeddingOptimizer()

# Generate some embeddings
embeddings = np.random.randn(1000, 768).astype(np.float32)
print(f"Original size: {embeddings.nbytes / 1024:.1f} KB")

# Dimension reduction with PCA
reduced = optimizer.reduce_dimensions(
    embeddings,
    method="pca",
    target_dims=256
)
print(f"After PCA (256d): {reduced.nbytes / 1024:.1f} KB")

# Quantization for storage efficiency
quantized = optimizer.quantize(
    embeddings,
    bits=8  # 8-bit quantization
)
print(f"After 8-bit quantization: {quantized.nbytes / 1024:.1f} KB")

# Normalize for cosine similarity
normalized = optimizer.normalize(embeddings, method="l2")
print(f"Normalized: unit vectors ready for dot product")

from semantica.embeddings import (
    MeanPooling,
    MaxPooling,
    AttentionPooling,
    HierarchicalPooling
)
import numpy as np

# Simulate token-level embeddings (e.g., from a transformer)
# Shape: (sequence_length, embedding_dim)
token_embeddings = np.random.randn(128, 768)

# Mean pooling - average all tokens
mean_pool = MeanPooling()
mean_result = mean_pool.pool(token_embeddings)
print(f"Mean pooling: {mean_result.shape}")  # (768,)

# Max pooling - take max across tokens
max_pool = MaxPooling()
max_result = max_pool.pool(token_embeddings)
print(f"Max pooling: {max_result.shape}")  # (768,)

# Attention-based pooling - learned weights
attn_pool = AttentionPooling(hidden_dim=768)
attn_result = attn_pool.pool(token_embeddings)
print(f"Attention pooling: {attn_result.shape}")  # (768,)

# Hierarchical pooling for long documents
hier_pool = HierarchicalPooling(chunk_size=32)
document_embeddings = np.random.randn(10, 128, 768)  # 10 paragraphs
hier_result = hier_pool.pool(document_embeddings)
print(f"Hierarchical pooling: {hier_result.shape}")  # (768,)

from semantica.embeddings import ContextManager, EmbeddingGenerator

# Long document that exceeds model context
long_document = "..." * 10000  # Very long text

# Manage context windows
context_manager = ContextManager(
    max_window_size=512,  # Tokens per window
    overlap=50,           # Overlap between windows
    preserve_sentences=True
)

windows = context_manager.split(long_document)
print(f"Split into {len(windows)} windows")

# Generate embeddings for each window
generator = EmbeddingGenerator()
window_embeddings = []

for i, window in enumerate(windows):
    emb = generator.generate_embeddings(window.text, data_type="text")
    window_embeddings.append({
        'embedding': emb,
        'start_char': window.start_char,
        'end_char': window.end_char
    })

# Merge windows for document-level embedding
from semantica.embeddings import pool_embeddings
import numpy as np

all_embs = np.array([w['embedding'] for w in window_embeddings])
doc_embedding = pool_embeddings(all_embs, method="mean")
print(f"Document embedding shape: {doc_embedding.shape}")

from semantica.kg import GraphBuilder
from datetime import datetime, timedelta

# Build a temporal knowledge graph
builder = GraphBuilder(
    enable_temporal=True,
    temporal_granularity="day",  # day, hour, minute, second
    track_history=True,
    version_snapshots=True
)

# Add time-stamped data
sources = [{
    "entities": [
        {
            "id": "e1", 
            "text": "Satya Nadella", 
            "type": "Person",
            "valid_from": "2014-02-04"  # Became CEO
        },
        {
            "id": "e2", 
            "text": "Microsoft", 
            "type": "Organization"
        },
        {
            "id": "e3", 
            "text": "Steve Ballmer", 
            "type": "Person",
            "valid_from": "2000-01-13",
            "valid_until": "2014-02-04"  # Was CEO until
        }
    ],
    "relationships": [
        {
            "source": "e1",
            "target": "e2",
            "type": "CEO_OF",
            "valid_from": "2014-02-04",
            "valid_until": None  # Still active
        },
        {
            "source": "e3",
            "target": "e2",
            "type": "CEO_OF",
            "valid_from": "2000-01-13",
            "valid_until": "2014-02-04"
        }
    ]
}]

kg = builder.build(sources)
print(f"Built temporal graph with {kg['metadata']['num_entities']} entities")

from semantica.kg import TemporalGraphQuery
from datetime import datetime

# Initialize temporal query engine
temporal_query = TemporalGraphQuery(kg)

# Query 1: Who was CEO in 2010?
state_2010 = temporal_query.query_at_time(
    datetime(2010, 6, 1),
    query_type="relationships",
    relationship_type="CEO_OF"
)
print(f"CEO in 2010: {state_2010['results']}")

state_2020 = temporal_query.query_at_time(
    datetime(2020, 6, 1),
    query_type="relationships", 
    relationship_type="CEO_OF"
)
print(f"CEO in 2020: {state_2020['results']}")

ceo_history = temporal_query.query_time_range(
    start_time=datetime(2000, 1, 1),
    end_time=datetime(2024, 1, 1),
    relationship_type="CEO_OF"
)

print("CEO History:")
for rel in ceo_history['results']:
    print(f"  {rel['source']} -> {rel['valid_from']} to {rel.get('valid_until', 'present')}")

from semantica.kg import TemporalPatternDetector

# Initialize pattern detector
detector = TemporalPatternDetector(kg)

# Detect sequences: A happened, then B, then C
sequences = detector.detect_sequences(
    event_types=["HIRED", "PROMOTED", "RESIGNED"],
    max_gap_days=365  # Events must be within 1 year
)

print("Detected Sequences:")
for seq in sequences:
    print(f"  {' -> '.join(seq['events'])}")
    print(f"    Entity: {seq['entity']}")
    print(f"    Duration: {seq['duration_days']} days")

cycles = detector.detect_cycles(
    min_occurrences=2,
    relationship_types=["QUARTERLY_REPORT"]
)

print("Detected Cycles:")
for cycle in cycles:
    print(f"  Pattern: {cycle['pattern']}")
    print(f"  Period: {cycle['period_days']} days")
    print(f"  Occurrences: {cycle['count']}")

trends = detector.detect_trends(
    metric="employee_count",
    entity_type="Organization",
    window_days=90
)

for trend in trends:
    direction = "UP" if trend['direction'] == 'increasing' else "DOWN"
    print(f"[{direction}] {trend['entity']}: {trend['change_percent']:.1f}% over {trend['period']}")

from semantica.kg import TemporalVersionManager
from datetime import datetime

# Initialize version manager
version_mgr = TemporalVersionManager(kg)

# Create a snapshot of current state
snapshot_id = version_mgr.create_snapshot(
    description="Q4 2024 knowledge graph",
    timestamp=datetime.now()
)
print(f"Created snapshot: {snapshot_id}")

diff = version_mgr.compare_versions(
    version_a=snapshot_id,
    version_b="current"
)

print("Changes since snapshot:")
print(f"  Added entities: {len(diff['added_entities'])}")
print(f"  Removed entities: {len(diff['removed_entities'])}")
print(f"  Modified entities: {len(diff['modified_entities'])}")
print(f"  Added relationships: {len(diff['added_relationships'])}")
print(f"  Removed relationships: {len(diff['removed_relationships'])}")

evolution = version_mgr.analyze_evolution(
    start_date=datetime(2024, 1, 1),
    end_date=datetime(2024, 12, 31)
)

print("Graph Evolution (2024):")
print(f"  Total snapshots: {evolution['snapshot_count']}")
print(f"  Net entity growth: {evolution['entity_growth']}")
print(f"  Net relationship growth: {evolution['relationship_growth']}")

from semantica.kg import GraphAnalyzer

analyzer = GraphAnalyzer()

# Analyze temporal evolution
evolution = analyzer.analyze_temporal_evolution(
    kg,
    time_periods=[
        ("2022-01-01", "2022-06-30"),
        ("2022-07-01", "2022-12-31"),
        ("2023-01-01", "2023-06-30"),
        ("2023-07-01", "2023-12-31")
    ]
)

print("Graph Evolution Analysis:")
for period in evolution['periods']:
    print(f"Period: {period['start']} to {period['end']}")
    print(f"  Entities: {period['entity_count']} (+{period['entity_growth']})")
    print(f"  Relationships: {period['relationship_count']} (+{period['rel_growth']})")
    print(f"  Density: {period['density']:.4f}")
    print(f"  New entity types: {period['new_types']}")
    print()

stability = analyzer.calculate_stability(kg, window_days=30)
print(f"Graph Stability Score: {stability['score']:.2f}")
print(f"  Most stable entities: {stability['most_stable'][:3]}")
print(f"  Most volatile entities: {stability['most_volatile'][:3]}")

from semantica.context import (
    ContextRetriever,
    AgentMemory,
    ContextGraphBuilder,
    build_context
)
from semantica.vector_store import VectorStore

# Initialize vector store
vector_store = VectorStore(backend="faiss", dimension=768)

# Build context graph
context_result = build_context(
    entities=kg["entities"],
    relationships=kg["relationships"],
    vector_store=vector_store,
    knowledge_graph=kg,
    store_initial_memories=True
)

print(f"Built context with {context_result['statistics']['graph'].get('node_count', 0)} nodes")

# Initialize agent memory
memory = AgentMemory(
    vector_store=vector_store,
    knowledge_graph=kg
)

# Store facts in memory
memory_id = memory.store(
    "Tim Cook is the CEO of Apple Inc.",
    metadata={"type": "fact", "source": "document"}
)
print(f"Stored memory: {memory_id}")

# Initialize context retriever
retriever = ContextRetriever(
    vector_store=vector_store,
    knowledge_graph=kg
)

# Retrieve relevant context
results = retriever.retrieve(
    query="Who leads Apple?",
    max_results=10
)

print("Retrieved context:")
for r in results:
    print(f"  {r.content} (score: {r.score:.2f})")

from semantica.vector_store import (
    VectorStore,
    HybridSearch,
    MetadataFilter,
    MetadataStore
)
from semantica.embeddings import embed_text

# Initialize stores
vector_store = VectorStore(backend="faiss", dimension=768)
metadata_store = MetadataStore()
hybrid_search = HybridSearch()

# Generate query embedding
query_embedding = embed_text("Apple CEO responsibilities", method="sentence_transformers")

# Create metadata filter
metadata_filter = MetadataFilter()
metadata_filter.eq("entity_type", "Person")
metadata_filter.eq("relationship", "CEO_OF")

# Get stored data
all_vectors = vector_store.get_all_vectors()
all_metadata = metadata_store.get_all()
all_ids = vector_store.get_all_ids()

# Perform hybrid search
results = hybrid_search.search(
    query_vector=query_embedding,
    vectors=all_vectors,
    metadata=all_metadata,
    vector_ids=all_ids,
    filter=metadata_filter,
    top_k=10
)

print("Hybrid search results:")
for result in results:
    print(f"  ID: {result['id']}, Score: {result['score']:.3f}")

from semantica.reasoning import Reasoner, Rule
from semantica.semantic_extract import ExplanationGenerator

# Initialize Reasoner
reasoner = Reasoner()

# Add reasoning rules
reasoner.add_rule(Rule(
    name="employment_transitivity",
    conditions=["?person CEO_OF ?company"],
    conclusions=["?person WORKS_FOR ?company"],
    priority=1
))

reasoner.add_rule(Rule(
    name="part_of_transitivity",
    conditions=["?a PART_OF ?b", "?b PART_OF ?c"],
    conclusions=["?a PART_OF ?c"],
    priority=2
))

# Define facts from knowledge graph
facts = [
    {"subject": "Tim Cook", "predicate": "CEO_OF", "object": "Apple"},
    {"subject": "iPhone", "predicate": "PART_OF", "object": "Apple"},
    {"subject": "A15 Chip", "predicate": "PART_OF", "object": "iPhone"}
]

# Run inference to discover hidden relationships
results = reasoner.infer_facts(facts)

print(f"Original facts: {len(facts)}")
print(f"Inferred {len(results)} new facts")

for fact in results:
    print(f"  New fact: {fact}")

# Generate explanations for why these facts were inferred
explainer = ExplanationGenerator()
# (Assuming we have the full inference results with paths)
# The Reasoner.forward_chain() provides detailed paths if needed

from semantica.ontology import OntologyGenerator, generate_ontology

# Your knowledge graph data
kg_data = {
    "entities": [
        {"id": "e1", "text": "Apple Inc.", "type": "Company"},
        {"id": "e2", "text": "Tim Cook", "type": "Person"},
        {"id": "e3", "text": "iPhone", "type": "Product"},
        {"id": "e4", "text": "Cupertino", "type": "Location"}
    ],
    "relationships": [
        {"source": "e2", "target": "e1", "type": "CEO_OF"},
        {"source": "e1", "target": "e3", "type": "MANUFACTURES"},
        {"source": "e1", "target": "e4", "type": "HEADQUARTERED_IN"}
    ]
}

# Method 1: Using convenience function
ontology = generate_ontology(kg_data, method="default")
print(f"Quick generation: {len(ontology.get('classes', []))} classes")

# Method 2: Using OntologyGenerator class for more control
generator = OntologyGenerator(
    base_uri="https://example.org/ontology/",
    version="1.0.0"
)

ontology = generator.generate_ontology(kg_data)

print(f"Generated Ontology:")
print(f"  Classes: {len(ontology['classes'])}")
print(f"  Properties: {len(ontology['properties'])}")
print(f"  Axioms: {len(ontology.get('axioms', []))}")

# Display class details
print("Classes:")
for cls in ontology['classes']:
    print(f"  {cls['name']}")
    print(f"    URI: {cls['uri']}")
    if cls.get('parent'):
        print(f"    Parent: {cls['parent']}")

from semantica.ontology import (
    ClassInferrer,
    PropertyGenerator,
    infer_classes,
    infer_properties
)

# Sample entities
entities = [
    {"text": "Apple", "type": "Company"},
    {"text": "Microsoft", "type": "Company"},
    {"text": "Google", "type": "Company"},
    {"text": "Tim Cook", "type": "Person"},
    {"text": "Satya Nadella", "type": "Person"},
    {"text": "iPhone", "type": "Product"},
    {"text": "Windows", "type": "Product"},
]

# Method 1: Using convenience function
classes = infer_classes(entities, method="default")

# Method 2: Using ClassInferrer for more control
class_inferrer = ClassInferrer(
    min_occurrence=2,  # Minimum entities to create a class
    merge_similar=True,
    similarity_threshold=0.8
)

classes = class_inferrer.infer_classes(entities)

print("Inferred Classes:")
for cls in classes:
    print(f"  {cls['name']}: {cls['instance_count']} instances")

# Infer properties from relationships
relationships = [
    {"source_type": "Person", "target_type": "Company", "type": "CEO_OF"},
    {"source_type": "Company", "target_type": "Product", "type": "MANUFACTURES"},
    {"source_type": "Person", "target_type": "Company", "type": "WORKS_FOR"},
]

# Using PropertyGenerator
prop_generator = PropertyGenerator()
properties = prop_generator.infer_properties(entities, relationships, classes)

print("Inferred Properties:")
for prop in properties:
    print(f"  {prop['name']}")
    print(f"    Domain: {prop['domain']} -> Range: {prop['range']}")
    print(f"    Type: {prop['property_type']}")

from semantica.ontology import OWLGenerator, generate_owl

# Initialize OWL generator
owl_gen = OWLGenerator(
    base_uri="https://example.org/onto/",
    output_format="turtle"  # turtle, rdf-xml, json-ld, n3
)

# Define ontology classes
owl_gen.add_class("Person", parent="Thing")
owl_gen.add_class("Company", parent="Thing")
owl_gen.add_class("CEO", parent="Person")

# Add object properties
owl_gen.add_object_property(
    name="worksFor",
    domain="Person",
    range="Company"
)

owl_gen.add_object_property(
    name="isCEOOf",
    domain="CEO",
    range="Company",
    functional=True  # A CEO can only be CEO of one company
)

# Add data properties
owl_gen.add_data_property(
    name="hasName",
    domain="Person",
    range="xsd:string"
)

owl_gen.add_data_property(
    name="foundedYear",
    domain="Company",
    range="xsd:integer"
)

# Add axioms/constraints
owl_gen.add_axiom(
    class_name="CEO",
    axiom="SubClassOf: worksFor exactly 1 Company"
)

# Generate Turtle output
turtle_output = owl_gen.serialize()
print(turtle_output)

# Example output:
# @prefix : <https://example.org/onto/> .
# @prefix owl: <http://www.w3.org/2002/07/owl#> .
# :Person a owl:Class .
# :Company a owl:Class .
# :CEO a owl:Class ; rdfs:subClassOf :Person .

# Save to file
owl_gen.save("company_ontology.ttl")
print("Ontology saved to company_ontology.ttl")

from semantica.ontology import (
    CompetencyQuestionsManager,
    CompetencyQuestion,
    OntologyEvaluator
)

# Initialize competency questions manager
cq_manager = CompetencyQuestionsManager()

# Add questions your ontology should be able to answer
cq_manager.add_question(CompetencyQuestion(
    question="Who is the CEO of a given company?",
    category="organizational",
    priority=1,  # 1=high, 2=medium, 3=low
    expected_elements=["Person", "Company", "isCEOOf"]
))

cq_manager.add_question(CompetencyQuestion(
    question="What products does a company manufacture?",
    category="products",
    priority=1,
    expected_elements=["Company", "Product", "manufactures"]
))

cq_manager.add_question(CompetencyQuestion(
    question="Where is a company headquartered?",
    category="location",
    priority=2,
    expected_elements=["Company", "Location", "headquarteredIn"]
))

# Get all questions
questions = cq_manager.get_questions()
print(f"Defined {len(questions)} competency questions")

# Evaluate ontology against competency questions
evaluator = OntologyEvaluator()
evaluation = evaluator.evaluate(
    ontology="company_ontology.ttl",
    competency_questions=questions
)

print(f"Ontology Evaluation:")
print(f"  Coverage Score: {evaluation.coverage_score:.1%}")
print(f"  Completeness Score: {evaluation.completeness_score:.1%}")

print("Question Coverage:")
for result in evaluation.question_results:
    status = "YES" if result['answerable'] else "NO"
    print(f"  [{status}] {result['question']}")
    if not result['answerable'] and result.get('missing_elements'):
        print(f"    Missing: {', '.join(result['missing_elements'])}")

from semantica.ontology import DomainOntologies, OWLGenerator

# Access pre-built domain ontologies
domains = DomainOntologies()

# List available domains
print("Available Domain Ontologies:")
for domain in domains.list_domains():
    print(f"  - {domain['name']}: {domain['description']}")

# Load healthcare ontology
healthcare_onto = domains.load("healthcare")

print(f"Healthcare Ontology:")
print(f"  Classes: {len(healthcare_onto.get('classes', []))}")
print(f"  Properties: {len(healthcare_onto.get('properties', []))}")

# Extend the ontology
owl_gen = OWLGenerator(base_uri="https://example.org/healthcare/")
owl_gen.add_class("MedicalDevice", parent="Equipment")

# Load and merge multiple ontologies
finance_onto = domains.load("finance")
merged = domains.merge([healthcare_onto, finance_onto])

print(f"Merged ontology: {len(merged.get('classes', []))} classes")

# Find alignments between ontologies
alignments = domains.find_alignments(
    healthcare_onto, 
    finance_onto,
    similarity_threshold=0.7
)

print(f"Found {len(alignments)} concept alignments:")
for align in alignments[:5]:
    print(f"  {align['source']} ~ {align['target']} ({align['similarity']:.2f})")

from semantica.reasoning import Reasoner, Rule

# Initialize the reasoner
reasoner = Reasoner()

# Define a logical rule: If A is a parent of B, and B is a parent of C, then A is a grandparent of C
reasoner.add_rule(Rule(
    name="grandparent_rule",
    conditions=["?a PARENT_OF ?b", "?b PARENT_OF ?c"],
    conclusions=["?a GRANDPARENT_OF ?c"]
))

# Add initial facts
facts = [
    "John PARENT_OF Mary",
    "Mary PARENT_OF Alice"
]

# Infer new facts
new_facts = reasoner.infer_facts(facts)

print(f"Inferred: {new_facts}")
# Output: ['John GRANDPARENT_OF Alice']

from semantica.reasoning import SPARQLReasoner

# Initialize SPARQL reasoner with a triplet store
sparql_reasoner = SPARQLReasoner(triplet_store=my_store)

# Define a rule
sparql_reasoner.reasoner.add_rule("(?x works_at ?y) -> (?x employee_of ?y)")

# Original query
query = "SELECT ?x WHERE { ?x employee_of <https://apple.com> }"

# Expand query to include 'works_at' patterns
expanded_query = sparql_reasoner.expand_query(query)

print(f"Expanded Query:\n{expanded_query}")

from semantica.reasoning import AbductiveReasoner

reasoner = AbductiveReasoner()

# Rule: Fire causes smoke
reasoner.reasoner.add_rule("Fire(?x) -> Smoke(?x)")

# Observation: There is smoke in the kitchen
observations = ["Smoke(Kitchen)"]

# What could have caused this?
hypotheses = reasoner.generate_hypotheses(observations)

for h in hypotheses:
    print(f"Possible cause: {h.conclusion} (Likelihood: {h.score})")

from semantica.kg import EntityResolver, Deduplicator, resolve_entities

# Sample entities with potential duplicates
entities = [
    {"id": "e1", "text": "Apple Inc.", "type": "Organization"},
    {"id": "e2", "text": "Apple", "type": "Organization"},
    {"id": "e3", "text": "Apple Computer, Inc.", "type": "Organization"},
    {"id": "e4", "text": "Microsoft", "type": "Organization"},
    {"id": "e5", "text": "MSFT", "type": "Organization"},
    {"id": "e6", "text": "Microsoft Corporation", "type": "Organization"},
]

# Method 1: Using convenience function
resolved = resolve_entities(entities, method="fuzzy")

# Method 2: Using EntityResolver class for more control
resolver = EntityResolver(
    strategy="fuzzy",  # "exact", "fuzzy", or "semantic"
    similarity_threshold=0.85,
    use_embeddings=True
)

# Find duplicate groups
duplicate_groups = resolver.find_duplicates(entities)

print("Duplicate Groups Found:")
for i, group in enumerate(duplicate_groups, 1):
    print(f"Group {i}:")
    for entity in group['entities']:
        print(f"  - {entity['text']} (id: {entity['id']})")
    print(f"  Confidence: {group['confidence']:.2f}")

from semantica.kg import EntityResolver
from semantica.embeddings import EmbeddingGenerator

# Initialize with semantic matching
generator = EmbeddingGenerator()

resolver = EntityResolver(
    strategy="semantic",
    embedding_generator=generator,
    similarity_threshold=0.8
)

# Entities with semantic variations
entities = [
    {"id": "e1", "text": "Chief Executive Officer", "type": "Title"},
    {"id": "e2", "text": "CEO", "type": "Title"},
    {"id": "e3", "text": "Managing Director", "type": "Title"},
    {"id": "e4", "text": "Head of the Company", "type": "Title"},
    {"id": "e5", "text": "Software Developer", "type": "Title"},
    {"id": "e6", "text": "Programmer", "type": "Title"},
]

# Find semantically similar entities
semantic_matches = resolver.find_semantic_matches(entities)

print("Semantic Matches:")
for match in semantic_matches:
    print(f"  {match['entity1']['text']} ~ {match['entity2']['text']}")
    print(f"    Similarity: {match['similarity']:.3f}")

clusters = resolver.cluster_entities(
    entities,
    method="semantic",
    min_cluster_size=2
)

print(f"Found {len(clusters)} semantic clusters")

from semantica.kg import Deduplicator, deduplicate_graph

# Method 1: Using convenience function
dedup_result = deduplicate_graph(kg, method="default")

# Method 2: Using Deduplicator class for more control
deduplicator = Deduplicator(
    entity_similarity_threshold=0.85,
    relationship_merge_strategy="union",  # "union", "intersection", "first"
    preserve_provenance=True
)

# Deduplicate the knowledge graph
dedup_result = deduplicator.deduplicate(kg)

print("Deduplication Results:")
print(f"  Original entities: {dedup_result['original_entity_count']}")
print(f"  After dedup: {dedup_result['final_entity_count']}")
print(f"  Duplicates merged: {dedup_result['merged_count']}")
print(f"  Reduction: {dedup_result['reduction_percent']:.1f}%")

# Get deduplicated graph
clean_kg = dedup_result['graph']

print("Merge Details:")
for merge in dedup_result['merges'][:5]:
    print(f"  Merged {len(merge['source_ids'])} entities -> {merge['canonical_id']}")
    print(f"    Canonical: {merge['canonical_text']}")
    print(f"    Aliases: {', '.join(merge['aliases'])}")

from semantica.kg import EntityResolver

# Define custom matching rules
custom_rules = {
    "Organization": {
        "normalize": [
            ("Inc.", ""),
            ("Corp.", ""),
            ("Corporation", ""),
            ("LLC", ""),
            ("Ltd.", ""),
        ],
        "abbreviations": {
            "IBM": "International Business Machines",
            "GE": "General Electric",
            "HP": "Hewlett-Packard",
        },
        "threshold": 0.8
    },
    "Person": {
        "match_fields": ["name", "email"],
        "normalize_case": True,
        "threshold": 0.9
    },
    "Location": {
        "normalize": [
            ("St.", "Street"),
            ("Ave.", "Avenue"),
            ("Blvd.", "Boulevard"),
        ],
        "threshold": 0.85
    }
}

resolver = EntityResolver(
    strategy="rule_based",
    custom_rules=custom_rules
)

# Apply custom rules
entities = [
    {"id": "e1", "text": "Apple Inc.", "type": "Organization"},
    {"id": "e2", "text": "Apple Corporation", "type": "Organization"},
    {"id": "e3", "text": "International Business Machines", "type": "Organization"},
    {"id": "e4", "text": "IBM", "type": "Organization"},
]

matches = resolver.find_duplicates(entities)

print("Rule-Based Matches:")
for match in matches:
    print(f"  {match['entities'][0]['text']} = {match['entities'][1]['text']}")
    print(f"    Rule: {match['matched_rule']}")

from semantica.kg import EntityResolver

resolver = EntityResolver(strategy="fuzzy", similarity_threshold=0.85)

# Define merge strategy
merged_entity = resolver.merge_entities(
    entities=[
        {"id": "e1", "text": "Apple", "properties": {"founded": 1976}},
        {"id": "e2", "text": "Apple Inc.", "properties": {"ceo": "Tim Cook"}},
        {"id": "e3", "text": "Apple Computer", "properties": {"founded": 1976, "industry": "Tech"}}
    ],
    strategy={
        "id": "keep_first",  # Use first entity's ID
        "text": "most_complete",  # Use longest/most complete text
        "properties": "merge_all",  # Combine all properties
        "conflicts": "keep_latest"  # For conflicting values, keep latest
    }
)

print("Merged Entity:")
print(f"  ID: {merged_entity['id']}")
print(f"  Text: {merged_entity['text']}")
print(f"  Properties: {merged_entity['properties']}")
print(f"  Source IDs: {merged_entity['source_ids']}")

from semantica.normalize import TextNormalizer

normalizer = TextNormalizer(
    lowercase=True,
    remove_punctuation=False,
    remove_extra_whitespace=True,
    unicode_normalize=True,
    expand_contractions=True
)

# Normalize text
raw_texts = [
    "  Apple Inc.   was founded   in 1976!!  ",
    "The iPhone's really great, isn't it?",
    "Microsoft™ announced Windows® 11",
    "café, naïve, résumé — special chars"
]

for raw in raw_texts:
    normalized = normalizer.normalize(raw)
    print(f"Before: {raw!r}")
    print(f"After:  {normalized!r}\n")

# Batch normalization
normalized_batch = normalizer.normalize_batch(raw_texts)