cognee 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

cognee/tests/test_cognee_server_start.py

@@ -48,7 +48,7 @@ class TestCogneeServerStart(unittest.TestCase):
         """Test that the server is running and can accept connections."""
         # Test health endpoint
         health_response = requests.get("http://localhost:8000/health", timeout=15)
-        self.assertIn(health_response.status_code, [200, 503])
+        self.assertIn(health_response.status_code, [200])
 
         # Test root endpoint
         root_response = requests.get("http://localhost:8000/", timeout=15)
@@ -88,7 +88,7 @@ class TestCogneeServerStart(unittest.TestCase):
         payload = {"datasets": [dataset_name]}
 
         add_response = requests.post(url, headers=headers, data=form_data, files=file, timeout=50)
-        if add_response.status_code not in [200, 201, 409]:
+        if add_response.status_code not in [200, 201]:
             add_response.raise_for_status()
 
         # Cognify request
@@ -99,7 +99,7 @@ class TestCogneeServerStart(unittest.TestCase):
         }
 
         cognify_response = requests.post(url, headers=headers, json=payload, timeout=150)
-        if cognify_response.status_code not in [200, 201, 409]:
+        if cognify_response.status_code not in [200, 201]:
             cognify_response.raise_for_status()
 
         # TODO: Add test to verify cognify pipeline is complete before testing search
@@ -115,7 +115,7 @@ class TestCogneeServerStart(unittest.TestCase):
         payload = {"searchType": "GRAPH_COMPLETION", "query": "What's in the document?"}
 
         search_response = requests.post(url, headers=headers, json=payload, timeout=50)
-        if search_response.status_code not in [200, 201, 409]:
+        if search_response.status_code not in [200, 201]:
             search_response.raise_for_status()
 
 

cognee/tests/test_temporal_graph.py

@@ -97,7 +97,7 @@ async def main():
         f"Expected exactly one DocumentChunk, but found {type_counts.get('DocumentChunk', 0)}"
     )
 
-    assert type_counts.get("Entity", 0) >= 20, (
+    assert type_counts.get("Entity", 0) >= 10, (
         f"Expected multiple entities (assert is set to 20), but found {type_counts.get('Entity', 0)}"
     )
 
@@ -105,52 +105,24 @@ async def main():
         f"Expected multiple entity types, but found {type_counts.get('EntityType', 0)}"
     )
 
-    assert type_counts.get("Event", 0) >= 20, (
+    assert type_counts.get("Event", 0) >= 10, (
         f"Expected multiple events (assert is set to 20), but found {type_counts.get('Event', 0)}"
     )
 
-    assert type_counts.get("Timestamp", 0) >= 20, (
-        f"Expected multiple timestamps (assert is set to 20), but found {type_counts.get('Timestamp', 0)}"
+    assert type_counts.get("Timestamp", 0) >= 10, (
+        f"Expected multiple timestamps (assert is set to 10), but found {type_counts.get('Timestamp', 0)}"
     )
 
-    assert type_counts.get("Interval", 0) >= 2, (
-        f"Expected multiple intervals, but found {type_counts.get('Interval', 0)}"
-    )
-
-    assert edge_type_counts.get("contains", 0) >= 20, (
+    assert edge_type_counts.get("contains", 0) >= 10, (
         f"Expected multiple 'contains' edge, but found {edge_type_counts.get('contains', 0)}"
     )
 
-    assert edge_type_counts.get("is_a", 0) >= 20, (
+    assert edge_type_counts.get("is_a", 0) >= 10, (
         f"Expected multiple 'is_a' edge, but found {edge_type_counts.get('is_a', 0)}"
     )
 
-    assert edge_type_counts.get("during", 0) == type_counts.get("Interval", 0), (
-        "Expected the same amount of during and interval objects in the graph"
-    )
-
-    assert edge_type_counts.get("during", 0) == type_counts.get("Interval", 0), (
-        "Expected the same amount of during and interval objects in the graph"
-    )
-
-    assert edge_type_counts.get("time_from", 0) == type_counts.get("Interval", 0), (
-        "Expected the same amount of time_from and interval objects in the graph"
-    )
-
-    assert edge_type_counts.get("time_to", 0) == type_counts.get("Interval", 0), (
-        "Expected the same amount of time_to and interval objects in the graph"
-    )
-
     retriever = TemporalRetriever()
 
-    result_before = await retriever.extract_time_from_query("What happened before 1890?")
-
-    assert result_before[0] is None
-
-    result_after = await retriever.extract_time_from_query("What happened after 1891?")
-
-    assert result_after[1] is None
-
     result_between = await retriever.extract_time_from_query("What happened between 1890 and 1900?")
 
     assert result_between[1]

cognee/tests/unit/modules/ontology/test_ontology_adapter.py

@@ -1,12 +1,14 @@
 import pytest
 from rdflib import Graph, Namespace, RDF, OWL, RDFS
-from cognee.modules.ontology.rdf_xml.OntologyResolver import OntologyResolver, AttachedOntologyNode
+from cognee.modules.ontology.rdf_xml.RDFLibOntologyResolver import RDFLibOntologyResolver
+from cognee.modules.ontology.models import AttachedOntologyNode
+from cognee.modules.ontology.get_default_ontology_resolver import get_default_ontology_resolver
 
 
 def test_ontology_adapter_initialization_success():
-    """Test successful initialization of OntologyAdapter."""
+    """Test successful initialization of RDFLibOntologyResolver from get_default_ontology_resolver."""
 
-    adapter = OntologyResolver()
+    adapter = get_default_ontology_resolver()
     adapter.build_lookup()
 
     assert isinstance(adapter.lookup, dict)
@@ -14,7 +16,7 @@ def test_ontology_adapter_initialization_success():
 
 def test_ontology_adapter_initialization_file_not_found():
     """Test OntologyAdapter initialization with nonexistent file."""
-    adapter = OntologyResolver(ontology_file="nonexistent.owl")
+    adapter = RDFLibOntologyResolver(ontology_file="nonexistent.owl")
     assert adapter.graph is None
 
 
@@ -27,7 +29,7 @@ def test_build_lookup():
 
     g.add((ns.Audi, RDF.type, ns.Car))
 
-    resolver = OntologyResolver()
+    resolver = RDFLibOntologyResolver()
     resolver.graph = g
     resolver.build_lookup()
 
@@ -50,7 +52,7 @@ def test_find_closest_match_exact():
     g.add((ns.Car, RDF.type, OWL.Class))
     g.add((ns.Audi, RDF.type, ns.Car))
 
-    resolver = OntologyResolver()
+    resolver = RDFLibOntologyResolver()
     resolver.graph = g
     resolver.build_lookup()
 
@@ -71,7 +73,7 @@ def test_find_closest_match_fuzzy():
     g.add((ns.Audi, RDF.type, ns.Car))
     g.add((ns.BMW, RDF.type, ns.Car))
 
-    resolver = OntologyResolver()
+    resolver = RDFLibOntologyResolver()
     resolver.graph = g
     resolver.build_lookup()
 
@@ -92,7 +94,7 @@ def test_find_closest_match_no_match():
     g.add((ns.Audi, RDF.type, ns.Car))
     g.add((ns.BMW, RDF.type, ns.Car))
 
-    resolver = OntologyResolver()
+    resolver = RDFLibOntologyResolver()
     resolver.graph = g
     resolver.build_lookup()
 
@@ -102,10 +104,10 @@ def test_find_closest_match_no_match():
 
 
 def test_get_subgraph_no_match_rdflib():
-    """Test get_subgraph returns empty results for a non-existent node."""
+    """Test get_subgraph returns empty results for a non-existent node using RDFLibOntologyResolver."""
     g = Graph()
 
-    resolver = OntologyResolver()
+    resolver = get_default_ontology_resolver()
     resolver.graph = g
     resolver.build_lookup()
 
@@ -138,7 +140,7 @@ def test_get_subgraph_success_rdflib():
     g.add((ns.VW, owns, ns.Audi))
     g.add((ns.VW, owns, ns.Porsche))
 
-    resolver = OntologyResolver()
+    resolver = RDFLibOntologyResolver()
     resolver.graph = g
     resolver.build_lookup()
 
@@ -160,10 +162,10 @@ def test_get_subgraph_success_rdflib():
 
 
 def test_refresh_lookup_rdflib():
-    """Test that refresh_lookup rebuilds the lookup dict into a new object."""
+    """Test that refresh_lookup rebuilds the lookup dict into a new object using RDFLibOntologyResolver."""
     g = Graph()
 
-    resolver = OntologyResolver()
+    resolver = get_default_ontology_resolver()
     resolver.graph = g
     resolver.build_lookup()
 
@@ -172,3 +174,318 @@ def test_refresh_lookup_rdflib():
     resolver.refresh_lookup()
 
     assert resolver.lookup is not original_lookup
+
+
+def test_fuzzy_matching_strategy_exact_match():
+    """Test FuzzyMatchingStrategy finds exact matches."""
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    strategy = FuzzyMatchingStrategy()
+    candidates = ["audi", "bmw", "mercedes"]
+
+    result = strategy.find_match("audi", candidates)
+    assert result == "audi"
+
+
+def test_fuzzy_matching_strategy_fuzzy_match():
+    """Test FuzzyMatchingStrategy finds fuzzy matches."""
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    strategy = FuzzyMatchingStrategy(cutoff=0.6)
+    candidates = ["audi", "bmw", "mercedes"]
+
+    result = strategy.find_match("audii", candidates)
+    assert result == "audi"
+
+
+def test_fuzzy_matching_strategy_no_match():
+    """Test FuzzyMatchingStrategy returns None when no match meets cutoff."""
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    strategy = FuzzyMatchingStrategy(cutoff=0.9)
+    candidates = ["audi", "bmw", "mercedes"]
+
+    result = strategy.find_match("completely_different", candidates)
+    assert result is None
+
+
+def test_fuzzy_matching_strategy_empty_candidates():
+    """Test FuzzyMatchingStrategy handles empty candidates list."""
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    strategy = FuzzyMatchingStrategy()
+
+    result = strategy.find_match("audi", [])
+    assert result is None
+
+
+def test_base_ontology_resolver_initialization():
+    """Test BaseOntologyResolver initialization with default matching strategy."""
+    from cognee.modules.ontology.base_ontology_resolver import BaseOntologyResolver
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    class TestOntologyResolver(BaseOntologyResolver):
+        def build_lookup(self):
+            pass
+
+        def refresh_lookup(self):
+            pass
+
+        def find_closest_match(self, name, category):
+            return None
+
+        def get_subgraph(self, node_name, node_type="individuals", directed=True):
+            return [], [], None
+
+    resolver = TestOntologyResolver()
+    assert isinstance(resolver.matching_strategy, FuzzyMatchingStrategy)
+
+
+def test_base_ontology_resolver_custom_matching_strategy():
+    """Test BaseOntologyResolver initialization with custom matching strategy."""
+    from cognee.modules.ontology.base_ontology_resolver import BaseOntologyResolver
+    from cognee.modules.ontology.matching_strategies import MatchingStrategy
+
+    class CustomMatchingStrategy(MatchingStrategy):
+        def find_match(self, name, candidates):
+            return "custom_match"
+
+    class TestOntologyResolver(BaseOntologyResolver):
+        def build_lookup(self):
+            pass
+
+        def refresh_lookup(self):
+            pass
+
+        def find_closest_match(self, name, category):
+            return None
+
+        def get_subgraph(self, node_name, node_type="individuals", directed=True):
+            return [], [], None
+
+    custom_strategy = CustomMatchingStrategy()
+    resolver = TestOntologyResolver(matching_strategy=custom_strategy)
+    assert resolver.matching_strategy == custom_strategy
+
+
+def test_ontology_config_structure():
+    """Test TypedDict structure for ontology configuration."""
+    from cognee.modules.ontology.ontology_config import Config
+    from cognee.modules.ontology.rdf_xml.RDFLibOntologyResolver import RDFLibOntologyResolver
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    matching_strategy = FuzzyMatchingStrategy()
+    resolver = RDFLibOntologyResolver(matching_strategy=matching_strategy)
+
+    config: Config = {"ontology_config": {"ontology_resolver": resolver}}
+
+    assert config["ontology_config"]["ontology_resolver"] == resolver
+
+
+def test_get_ontology_resolver_default():
+    """Test get_default_ontology_resolver returns a properly configured RDFLibOntologyResolver with FuzzyMatchingStrategy."""
+    from cognee.modules.ontology.rdf_xml.RDFLibOntologyResolver import RDFLibOntologyResolver
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    resolver = get_default_ontology_resolver()
+
+    assert isinstance(resolver, RDFLibOntologyResolver)
+    assert isinstance(resolver.matching_strategy, FuzzyMatchingStrategy)
+
+
+def test_get_default_ontology_resolver():
+    """Test get_default_ontology_resolver returns a properly configured RDFLibOntologyResolver with FuzzyMatchingStrategy."""
+    from cognee.modules.ontology.rdf_xml.RDFLibOntologyResolver import RDFLibOntologyResolver
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    resolver = get_default_ontology_resolver()
+
+    assert isinstance(resolver, RDFLibOntologyResolver)
+    assert isinstance(resolver.matching_strategy, FuzzyMatchingStrategy)
+
+
+def test_rdflib_ontology_resolver_uses_matching_strategy():
+    """Test that RDFLibOntologyResolver uses the provided matching strategy."""
+    from cognee.modules.ontology.matching_strategies import MatchingStrategy
+
+    class TestMatchingStrategy(MatchingStrategy):
+        def find_match(self, name, candidates):
+            return "test_match" if candidates else None
+
+    ns = Namespace("http://example.org/test#")
+    g = Graph()
+    g.add((ns.Car, RDF.type, OWL.Class))
+    g.add((ns.Audi, RDF.type, ns.Car))
+
+    resolver = RDFLibOntologyResolver(matching_strategy=TestMatchingStrategy())
+    resolver.graph = g
+    resolver.build_lookup()
+
+    result = resolver.find_closest_match("Audi", "individuals")
+    assert result == "test_match"
+
+
+def test_rdflib_ontology_resolver_default_matching_strategy():
+    """Test that RDFLibOntologyResolver uses FuzzyMatchingStrategy by default."""
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    resolver = RDFLibOntologyResolver()
+    assert isinstance(resolver.matching_strategy, FuzzyMatchingStrategy)
+
+
+def test_get_ontology_resolver_from_env_success():
+    """Test get_ontology_resolver_from_env returns correct resolver with valid parameters."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+    from cognee.modules.ontology.rdf_xml.RDFLibOntologyResolver import RDFLibOntologyResolver
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    resolver = get_ontology_resolver_from_env(
+        ontology_resolver="rdflib", matching_strategy="fuzzy", ontology_file_path="/test/path.owl"
+    )
+
+    assert isinstance(resolver, RDFLibOntologyResolver)
+    assert isinstance(resolver.matching_strategy, FuzzyMatchingStrategy)
+    assert resolver.ontology_file == "/test/path.owl"
+
+
+def test_get_ontology_resolver_from_env_unsupported_resolver():
+    """Test get_ontology_resolver_from_env raises EnvironmentError for unsupported resolver."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError) as exc_info:
+        get_ontology_resolver_from_env(
+            ontology_resolver="unsupported",
+            matching_strategy="fuzzy",
+            ontology_file_path="/test/path.owl",
+        )
+
+    assert "Unsupported ontology resolver: unsupported" in str(exc_info.value)
+    assert "Supported resolvers are: RdfLib with FuzzyMatchingStrategy" in str(exc_info.value)
+
+
+def test_get_ontology_resolver_from_env_unsupported_strategy():
+    """Test get_ontology_resolver_from_env raises EnvironmentError for unsupported strategy."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError) as exc_info:
+        get_ontology_resolver_from_env(
+            ontology_resolver="rdflib",
+            matching_strategy="unsupported",
+            ontology_file_path="/test/path.owl",
+        )
+
+    assert "Unsupported ontology resolver: rdflib" in str(exc_info.value)
+
+
+def test_get_ontology_resolver_from_env_empty_file_path():
+    """Test get_ontology_resolver_from_env raises EnvironmentError for empty file path."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError) as exc_info:
+        get_ontology_resolver_from_env(
+            ontology_resolver="rdflib", matching_strategy="fuzzy", ontology_file_path=""
+        )
+
+    assert "Unsupported ontology resolver: rdflib" in str(exc_info.value)
+
+
+def test_get_ontology_resolver_from_env_none_file_path():
+    """Test get_ontology_resolver_from_env raises EnvironmentError for None file path."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError) as exc_info:
+        get_ontology_resolver_from_env(
+            ontology_resolver="rdflib", matching_strategy="fuzzy", ontology_file_path=None
+        )
+
+    assert "Unsupported ontology resolver: rdflib" in str(exc_info.value)
+
+
+def test_get_ontology_resolver_from_env_empty_resolver():
+    """Test get_ontology_resolver_from_env raises EnvironmentError for empty resolver."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError) as exc_info:
+        get_ontology_resolver_from_env(
+            ontology_resolver="", matching_strategy="fuzzy", ontology_file_path="/test/path.owl"
+        )
+
+    assert "Unsupported ontology resolver:" in str(exc_info.value)
+
+
+def test_get_ontology_resolver_from_env_empty_strategy():
+    """Test get_ontology_resolver_from_env raises EnvironmentError for empty strategy."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError) as exc_info:
+        get_ontology_resolver_from_env(
+            ontology_resolver="rdflib", matching_strategy="", ontology_file_path="/test/path.owl"
+        )
+
+    assert "Unsupported ontology resolver: rdflib" in str(exc_info.value)
+
+
+def test_get_ontology_resolver_from_env_default_parameters():
+    """Test get_ontology_resolver_from_env with default empty parameters raises EnvironmentError."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError) as exc_info:
+        get_ontology_resolver_from_env()
+
+    assert "Unsupported ontology resolver:" in str(exc_info.value)
+
+
+def test_get_ontology_resolver_from_env_case_sensitivity():
+    """Test get_ontology_resolver_from_env is case sensitive."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    with pytest.raises(EnvironmentError):
+        get_ontology_resolver_from_env(
+            ontology_resolver="RDFLIB",
+            matching_strategy="fuzzy",
+            ontology_file_path="/test/path.owl",
+        )
+
+    with pytest.raises(EnvironmentError):
+        get_ontology_resolver_from_env(
+            ontology_resolver="RdfLib",
+            matching_strategy="fuzzy",
+            ontology_file_path="/test/path.owl",
+        )
+
+
+def test_get_ontology_resolver_from_env_with_actual_file():
+    """Test get_ontology_resolver_from_env works with actual file path."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+    from cognee.modules.ontology.rdf_xml.RDFLibOntologyResolver import RDFLibOntologyResolver
+    from cognee.modules.ontology.matching_strategies import FuzzyMatchingStrategy
+
+    resolver = get_ontology_resolver_from_env(
+        ontology_resolver="rdflib",
+        matching_strategy="fuzzy",
+        ontology_file_path="/path/to/ontology.owl",
+    )
+
+    assert isinstance(resolver, RDFLibOntologyResolver)
+    assert isinstance(resolver.matching_strategy, FuzzyMatchingStrategy)
+    assert resolver.ontology_file == "/path/to/ontology.owl"
+
+
+def test_get_ontology_resolver_from_env_resolver_functionality():
+    """Test that resolver created from env function works correctly."""
+    from cognee.modules.ontology.get_default_ontology_resolver import get_ontology_resolver_from_env
+
+    resolver = get_ontology_resolver_from_env(
+        ontology_resolver="rdflib", matching_strategy="fuzzy", ontology_file_path="/test/path.owl"
+    )
+
+    resolver.build_lookup()
+    assert isinstance(resolver.lookup, dict)
+
+    result = resolver.find_closest_match("test", "individuals")
+    assert result is None  # Should return None for non-existent entity
+
+    nodes, relationships, start_node = resolver.get_subgraph("test", "individuals")
+    assert nodes == []
+    assert relationships == []
+    assert start_node is None