cognee 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

cognee/tests/unit/modules/users/test_conditional_authentication.py

@@ -107,29 +107,10 @@ class TestConditionalAuthenticationIntegration:
         # REQUIRE_AUTHENTICATION should be a boolean
         assert isinstance(REQUIRE_AUTHENTICATION, bool)
 
-        # Currently should be False (optional authentication)
-        assert not REQUIRE_AUTHENTICATION
-
 
 class TestConditionalAuthenticationEnvironmentVariables:
     """Test environment variable handling."""
 
-    def test_require_authentication_default_false(self):
-        """Test that REQUIRE_AUTHENTICATION defaults to false when imported with no env vars."""
-        with patch.dict(os.environ, {}, clear=True):
-            # Remove module from cache to force fresh import
-            module_name = "cognee.modules.users.methods.get_authenticated_user"
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-
-            # Import after patching environment - module will see empty environment
-            from cognee.modules.users.methods.get_authenticated_user import (
-                REQUIRE_AUTHENTICATION,
-            )
-
-            importlib.invalidate_caches()
-            assert not REQUIRE_AUTHENTICATION
-
     def test_require_authentication_true(self):
         """Test that REQUIRE_AUTHENTICATION=true is parsed correctly when imported."""
         with patch.dict(os.environ, {"REQUIRE_AUTHENTICATION": "true"}):
@@ -145,50 +126,6 @@ class TestConditionalAuthenticationEnvironmentVariables:
 
             assert REQUIRE_AUTHENTICATION
 
-    def test_require_authentication_false_explicit(self):
-        """Test that REQUIRE_AUTHENTICATION=false is parsed correctly when imported."""
-        with patch.dict(os.environ, {"REQUIRE_AUTHENTICATION": "false"}):
-            # Remove module from cache to force fresh import
-            module_name = "cognee.modules.users.methods.get_authenticated_user"
-            if module_name in sys.modules:
-                del sys.modules[module_name]
-
-            # Import after patching environment - module will see REQUIRE_AUTHENTICATION=false
-            from cognee.modules.users.methods.get_authenticated_user import (
-                REQUIRE_AUTHENTICATION,
-            )
-
-            assert not REQUIRE_AUTHENTICATION
-
-    def test_require_authentication_case_insensitive(self):
-        """Test that environment variable parsing is case insensitive when imported."""
-        test_cases = ["TRUE", "True", "tRuE", "FALSE", "False", "fAlSe"]
-
-        for case in test_cases:
-            with patch.dict(os.environ, {"REQUIRE_AUTHENTICATION": case}):
-                # Remove module from cache to force fresh import
-                module_name = "cognee.modules.users.methods.get_authenticated_user"
-                if module_name in sys.modules:
-                    del sys.modules[module_name]
-
-                # Import after patching environment
-                from cognee.modules.users.methods.get_authenticated_user import (
-                    REQUIRE_AUTHENTICATION,
-                )
-
-                expected = case.lower() == "true"
-                assert REQUIRE_AUTHENTICATION == expected, f"Failed for case: {case}"
-
-    def test_current_require_authentication_value(self):
-        """Test that the current REQUIRE_AUTHENTICATION module value is as expected."""
-        from cognee.modules.users.methods.get_authenticated_user import (
-            REQUIRE_AUTHENTICATION,
-        )
-
-        # The module-level variable should currently be False (set at import time)
-        assert isinstance(REQUIRE_AUTHENTICATION, bool)
-        assert not REQUIRE_AUTHENTICATION
-
 
 class TestConditionalAuthenticationEdgeCases:
     """Test edge cases and error scenarios."""

cognee/tests/unit/processing/chunks/chunk_by_row_test.py

@@ -0,0 +1,52 @@
+from itertools import product
+
+import numpy as np
+import pytest
+
+from cognee.infrastructure.databases.vector.embeddings import get_embedding_engine
+from cognee.tasks.chunks import chunk_by_row
+
+INPUT_TEXTS = "name: John, age: 30, city: New York, country: USA"
+max_chunk_size_vals = [8, 32]
+
+
+@pytest.mark.parametrize(
+    "input_text,max_chunk_size",
+    list(product([INPUT_TEXTS], max_chunk_size_vals)),
+)
+def test_chunk_by_row_isomorphism(input_text, max_chunk_size):
+    chunks = chunk_by_row(input_text, max_chunk_size)
+    reconstructed_text = ", ".join([chunk["text"] for chunk in chunks])
+    assert reconstructed_text == input_text, (
+        f"texts are not identical: {len(input_text) = }, {len(reconstructed_text) = }"
+    )
+
+
+@pytest.mark.parametrize(
+    "input_text,max_chunk_size",
+    list(product([INPUT_TEXTS], max_chunk_size_vals)),
+)
+def test_row_chunk_length(input_text, max_chunk_size):
+    chunks = list(chunk_by_row(data=input_text, max_chunk_size=max_chunk_size))
+    embedding_engine = get_embedding_engine()
+
+    chunk_lengths = np.array(
+        [embedding_engine.tokenizer.count_tokens(chunk["text"]) for chunk in chunks]
+    )
+
+    larger_chunks = chunk_lengths[chunk_lengths > max_chunk_size]
+    assert np.all(chunk_lengths <= max_chunk_size), (
+        f"{max_chunk_size = }: {larger_chunks} are too large"
+    )
+
+
+@pytest.mark.parametrize(
+    "input_text,max_chunk_size",
+    list(product([INPUT_TEXTS], max_chunk_size_vals)),
+)
+def test_chunk_by_row_chunk_numbering(input_text, max_chunk_size):
+    chunks = chunk_by_row(data=input_text, max_chunk_size=max_chunk_size)
+    chunk_indices = np.array([chunk["chunk_index"] for chunk in chunks])
+    assert np.all(chunk_indices == np.arange(len(chunk_indices))), (
+        f"{chunk_indices = } are not monotonically increasing"
+    )

cognee/tests/unit/tasks/storage/test_add_data_points.py

@@ -0,0 +1,288 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+import sys
+
+from cognee.infrastructure.engine import DataPoint
+from cognee.modules.engine.models import Triplet
+from cognee.tasks.storage.add_data_points import (
+    add_data_points,
+    InvalidDataPointsInAddDataPointsError,
+    _extract_embeddable_text_from_datapoint,
+    _create_triplets_from_graph,
+)
+
+adp_module = sys.modules["cognee.tasks.storage.add_data_points"]
+
+
+class SimplePoint(DataPoint):
+    text: str
+    metadata: dict = {"index_fields": ["text"]}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("bad_input", [None, ["not_datapoint"]])
+async def test_add_data_points_validates_inputs(bad_input):
+    with pytest.raises(InvalidDataPointsInAddDataPointsError):
+        await add_data_points(bad_input)
+
+
+@pytest.mark.asyncio
+@patch.object(adp_module, "index_graph_edges")
+@patch.object(adp_module, "index_data_points")
+@patch.object(adp_module, "get_graph_engine")
+@patch.object(adp_module, "deduplicate_nodes_and_edges")
+@patch.object(adp_module, "get_graph_from_model")
+async def test_add_data_points_indexes_nodes_and_edges(
+    mock_get_graph, mock_dedup, mock_get_engine, mock_index_nodes, mock_index_edges
+):
+    dp1 = SimplePoint(text="first")
+    dp2 = SimplePoint(text="second")
+
+    edge1 = (str(dp1.id), str(dp2.id), "related_to", {"edge_text": "connects"})
+    custom_edges = [(str(dp2.id), str(dp1.id), "custom_edge", {})]
+
+    mock_get_graph.side_effect = [([dp1], [edge1]), ([dp2], [])]
+    mock_dedup.side_effect = lambda n, e: (n, e)
+    graph_engine = AsyncMock()
+    mock_get_engine.return_value = graph_engine
+
+    result = await add_data_points([dp1, dp2], custom_edges=custom_edges)
+
+    assert result == [dp1, dp2]
+    graph_engine.add_nodes.assert_awaited_once()
+    mock_index_nodes.assert_awaited_once()
+    assert graph_engine.add_edges.await_count == 2
+    assert edge1 in graph_engine.add_edges.await_args_list[0].args[0]
+    assert graph_engine.add_edges.await_args_list[1].args[0] == custom_edges
+    assert mock_index_edges.await_count == 2
+
+
+@pytest.mark.asyncio
+@patch.object(adp_module, "index_graph_edges")
+@patch.object(adp_module, "index_data_points")
+@patch.object(adp_module, "get_graph_engine")
+@patch.object(adp_module, "deduplicate_nodes_and_edges")
+@patch.object(adp_module, "get_graph_from_model")
+async def test_add_data_points_indexes_triplets_when_enabled(
+    mock_get_graph, mock_dedup, mock_get_engine, mock_index_nodes, mock_index_edges
+):
+    dp1 = SimplePoint(text="source")
+    dp2 = SimplePoint(text="target")
+
+    edge1 = (str(dp1.id), str(dp2.id), "relates", {"edge_text": "describes"})
+
+    mock_get_graph.side_effect = [([dp1], [edge1]), ([dp2], [])]
+    mock_dedup.side_effect = lambda n, e: (n, e)
+    graph_engine = AsyncMock()
+    mock_get_engine.return_value = graph_engine
+
+    await add_data_points([dp1, dp2], embed_triplets=True)
+
+    assert mock_index_nodes.await_count == 2
+    nodes_arg = mock_index_nodes.await_args_list[0].args[0]
+    triplets_arg = mock_index_nodes.await_args_list[1].args[0]
+    assert nodes_arg == [dp1, dp2]
+    assert len(triplets_arg) == 1
+    assert isinstance(triplets_arg[0], Triplet)
+    mock_index_edges.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+@patch.object(adp_module, "index_graph_edges")
+@patch.object(adp_module, "index_data_points")
+@patch.object(adp_module, "get_graph_engine")
+@patch.object(adp_module, "deduplicate_nodes_and_edges")
+@patch.object(adp_module, "get_graph_from_model")
+async def test_add_data_points_with_empty_list(
+    mock_get_graph, mock_dedup, mock_get_engine, mock_index_nodes, mock_index_edges
+):
+    mock_dedup.side_effect = lambda n, e: (n, e)
+    graph_engine = AsyncMock()
+    mock_get_engine.return_value = graph_engine
+
+    result = await add_data_points([])
+
+    assert result == []
+    mock_get_graph.assert_not_called()
+    graph_engine.add_nodes.assert_awaited_once_with([])
+
+
+@pytest.mark.asyncio
+@patch.object(adp_module, "index_graph_edges")
+@patch.object(adp_module, "index_data_points")
+@patch.object(adp_module, "get_graph_engine")
+@patch.object(adp_module, "deduplicate_nodes_and_edges")
+@patch.object(adp_module, "get_graph_from_model")
+async def test_add_data_points_with_single_datapoint(
+    mock_get_graph, mock_dedup, mock_get_engine, mock_index_nodes, mock_index_edges
+):
+    dp = SimplePoint(text="single")
+    mock_get_graph.side_effect = [([dp], [])]
+    mock_dedup.side_effect = lambda n, e: (n, e)
+    graph_engine = AsyncMock()
+    mock_get_engine.return_value = graph_engine
+
+    result = await add_data_points([dp])
+
+    assert result == [dp]
+    mock_get_graph.assert_called_once()
+    mock_index_nodes.assert_awaited_once()
+
+
+def test_extract_embeddable_text_from_datapoint():
+    dp = SimplePoint(text="hello world")
+    text = _extract_embeddable_text_from_datapoint(dp)
+    assert text == "hello world"
+
+
+def test_extract_embeddable_text_with_multiple_fields():
+    class MultiField(DataPoint):
+        title: str
+        description: str
+        metadata: dict = {"index_fields": ["title", "description"]}
+
+    dp = MultiField(title="Test", description="Description")
+    text = _extract_embeddable_text_from_datapoint(dp)
+    assert text == "Test Description"
+
+
+def test_extract_embeddable_text_with_no_index_fields():
+    class NoIndex(DataPoint):
+        text: str
+        metadata: dict = {"index_fields": []}
+
+    dp = NoIndex(text="ignored")
+    text = _extract_embeddable_text_from_datapoint(dp)
+    assert text == ""
+
+
+def test_create_triplets_from_graph():
+    dp1 = SimplePoint(text="source node")
+    dp2 = SimplePoint(text="target node")
+    edge = (str(dp1.id), str(dp2.id), "connects_to", {"edge_text": "links"})
+
+    triplets = _create_triplets_from_graph([dp1, dp2], [edge])
+
+    assert len(triplets) == 1
+    assert isinstance(triplets[0], Triplet)
+    assert triplets[0].from_node_id == str(dp1.id)
+    assert triplets[0].to_node_id == str(dp2.id)
+    assert "source node" in triplets[0].text
+    assert "target node" in triplets[0].text
+
+
+def test_extract_embeddable_text_with_none_datapoint():
+    text = _extract_embeddable_text_from_datapoint(None)
+    assert text == ""
+
+
+def test_extract_embeddable_text_without_metadata():
+    class NoMetadata(DataPoint):
+        text: str
+
+    dp = NoMetadata(text="test")
+    delattr(dp, "metadata")
+    text = _extract_embeddable_text_from_datapoint(dp)
+    assert text == ""
+
+
+def test_extract_embeddable_text_with_whitespace_only():
+    class WhitespaceField(DataPoint):
+        text: str
+        metadata: dict = {"index_fields": ["text"]}
+
+    dp = WhitespaceField(text="   ")
+    text = _extract_embeddable_text_from_datapoint(dp)
+    assert text == ""
+
+
+def test_create_triplets_skips_short_edge_tuples():
+    dp = SimplePoint(text="node")
+    incomplete_edge = (str(dp.id), str(dp.id))
+
+    triplets = _create_triplets_from_graph([dp], [incomplete_edge])
+
+    assert len(triplets) == 0
+
+
+def test_create_triplets_skips_missing_source_node():
+    dp1 = SimplePoint(text="target")
+    edge = ("missing_id", str(dp1.id), "relates", {})
+
+    triplets = _create_triplets_from_graph([dp1], [edge])
+
+    assert len(triplets) == 0
+
+
+def test_create_triplets_skips_missing_target_node():
+    dp1 = SimplePoint(text="source")
+    edge = (str(dp1.id), "missing_id", "relates", {})
+
+    triplets = _create_triplets_from_graph([dp1], [edge])
+
+    assert len(triplets) == 0
+
+
+def test_create_triplets_skips_none_relationship():
+    dp1 = SimplePoint(text="source")
+    dp2 = SimplePoint(text="target")
+    edge = (str(dp1.id), str(dp2.id), None, {})
+
+    triplets = _create_triplets_from_graph([dp1, dp2], [edge])
+
+    assert len(triplets) == 0
+
+
+def test_create_triplets_uses_relationship_name_when_no_edge_text():
+    dp1 = SimplePoint(text="source")
+    dp2 = SimplePoint(text="target")
+    edge = (str(dp1.id), str(dp2.id), "connects_to", {})
+
+    triplets = _create_triplets_from_graph([dp1, dp2], [edge])
+
+    assert len(triplets) == 1
+    assert "connects_to" in triplets[0].text
+
+
+def test_create_triplets_prevents_duplicates():
+    dp1 = SimplePoint(text="source")
+    dp2 = SimplePoint(text="target")
+    edge = (str(dp1.id), str(dp2.id), "relates", {"edge_text": "links"})
+
+    triplets = _create_triplets_from_graph([dp1, dp2], [edge, edge])
+
+    assert len(triplets) == 1
+
+
+def test_create_triplets_skips_nodes_without_id():
+    class NodeNoId:
+        pass
+
+    dp = SimplePoint(text="valid")
+    node_no_id = NodeNoId()
+    edge = (str(dp.id), "some_id", "relates", {})
+
+    triplets = _create_triplets_from_graph([dp, node_no_id], [edge])
+
+    assert len(triplets) == 0
+
+
+@pytest.mark.asyncio
+@patch.object(adp_module, "index_graph_edges")
+@patch.object(adp_module, "index_data_points")
+@patch.object(adp_module, "get_graph_engine")
+@patch.object(adp_module, "deduplicate_nodes_and_edges")
+@patch.object(adp_module, "get_graph_from_model")
+async def test_add_data_points_with_empty_custom_edges(
+    mock_get_graph, mock_dedup, mock_get_engine, mock_index_nodes, mock_index_edges
+):
+    dp = SimplePoint(text="test")
+    mock_get_graph.side_effect = [([dp], [])]
+    mock_dedup.side_effect = lambda n, e: (n, e)
+    graph_engine = AsyncMock()
+    mock_get_engine.return_value = graph_engine
+
+    result = await add_data_points([dp], custom_edges=[])
+
+    assert result == [dp]
+    assert graph_engine.add_edges.await_count == 1

{cognee-0.4.1.dist-info → cognee-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee
-Version: 0.4.1
+Version: 0.5.0
 Summary: Cognee - is a library for enriching LLM context with a semantic layer for better understanding and reasoning.
 Project-URL: Homepage, https://www.cognee.ai
 Project-URL: Repository, https://github.com/topoteretes/cognee
@@ -16,10 +16,13 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: <3.14,>=3.10
-Requires-Dist: aiofiles<24.0.0,>=23.2.1
+Requires-Dist: aiofiles>=23.2.1
 Requires-Dist: aiohttp<4.0.0,>=3.11.14
+Requires-Dist: aiolimiter>=1.2.1
 Requires-Dist: aiosqlite<1.0.0,>=0.20.0
 Requires-Dist: alembic<2,>=1.13.3
+Requires-Dist: diskcache>=5.6.3
+Requires-Dist: fakeredis[lua]>=2.32.0
 Requires-Dist: fastapi-users[sqlalchemy]<15.0.0,>=14.0.1
 Requires-Dist: fastapi<1.0.0,>=0.116.2
 Requires-Dist: fastembed<=0.6.0
@@ -28,8 +31,7 @@ Requires-Dist: gunicorn<24,>=20.1.0
 Requires-Dist: instructor<2.0.0,>=1.9.1
 Requires-Dist: jinja2<4,>=3.1.3
 Requires-Dist: kuzu==0.11.3
-Requires-Dist: lance-namespace<=0.0.21
-Requires-Dist: lancedb<=0.25.3,>=0.24.0
+Requires-Dist: lancedb<1.0.0,>=0.24.0
 Requires-Dist: limits<5,>=4.4.1
 Requires-Dist: litellm>=1.76.0
 Requires-Dist: mistralai>=1.9.10
@@ -39,7 +41,7 @@ Requires-Dist: numpy<=4.0.0,>=1.26.4
 Requires-Dist: onnxruntime<=1.22.1
 Requires-Dist: openai>=1.80.1
 Requires-Dist: pydantic-settings<3,>=2.2.1
-Requires-Dist: pydantic<3.0.0,>=2.10.5
+Requires-Dist: pydantic<2.12.0,>=2.10.5
 Requires-Dist: pylance<=0.36.0,>=0.22.0
 Requires-Dist: pympler<2.0.0,>=1.1
 Requires-Dist: pypdf<7.0.0,>=4.1.0
@@ -97,7 +99,8 @@ Provides-Extra: docling
 Requires-Dist: docling>=2.54; extra == 'docling'
 Requires-Dist: transformers>=4.55; extra == 'docling'
 Provides-Extra: docs
-Requires-Dist: lxml<6.0.0; extra == 'docs'
+Requires-Dist: lxml<5,>=4.9.3; (python_version < '3.13') and extra == 'docs'
+Requires-Dist: lxml<6,>=5; (python_version >= '3.13') and extra == 'docs'
 Requires-Dist: unstructured[csv,doc,docx,epub,md,odt,org,pdf,ppt,pptx,rst,rtf,tsv,xlsx]<19,>=0.18.1; extra == 'docs'
 Provides-Extra: evals
 Requires-Dist: gdown<6,>=5.2.0; extra == 'evals'
@@ -144,7 +147,8 @@ Requires-Dist: redis<6.0.0,>=5.0.3; extra == 'redis'
 Provides-Extra: scraping
 Requires-Dist: apscheduler<=3.11.0,>=3.10.0; extra == 'scraping'
 Requires-Dist: beautifulsoup4>=4.13.1; extra == 'scraping'
-Requires-Dist: lxml>=4.9.3; extra == 'scraping'
+Requires-Dist: lxml<5,>=4.9.3; (python_version < '3.13') and extra == 'scraping'
+Requires-Dist: lxml<6,>=5; (python_version >= '3.13') and extra == 'scraping'
 Requires-Dist: playwright>=1.9.0; extra == 'scraping'
 Requires-Dist: protego>=0.1; extra == 'scraping'
 Requires-Dist: tavily-python>=0.7.12; extra == 'scraping'