cognee 0.5.1.dev0__py3-none-any.whl → 0.5.2.dev0__py3-none-any.whl

cognee/tests/unit/shared/test_usage_logger.py

@@ -0,0 +1,241 @@
+"""Unit tests for usage logger core functions."""
+
+import pytest
+from datetime import datetime, timezone
+from uuid import UUID
+from types import SimpleNamespace
+
+from cognee.shared.usage_logger import (
+    _sanitize_value,
+    _sanitize_dict_key,
+    _get_param_names,
+    _get_param_defaults,
+    _extract_user_id,
+    _extract_parameters,
+    log_usage,
+)
+from cognee.shared.exceptions import UsageLoggerError
+
+
+class TestSanitizeValue:
+    """Test _sanitize_value function."""
+
+    @pytest.mark.parametrize(
+        "value,expected",
+        [
+            (None, None),
+            ("string", "string"),
+            (42, 42),
+            (3.14, 3.14),
+            (True, True),
+            (False, False),
+        ],
+    )
+    def test_basic_types(self, value, expected):
+        assert _sanitize_value(value) == expected
+
+    def test_uuid_and_datetime(self):
+        """Test UUID and datetime serialization."""
+        uuid_val = UUID("123e4567-e89b-12d3-a456-426614174000")
+        dt = datetime(2024, 1, 15, 12, 30, 45, tzinfo=timezone.utc)
+
+        assert _sanitize_value(uuid_val) == "123e4567-e89b-12d3-a456-426614174000"
+        assert _sanitize_value(dt) == "2024-01-15T12:30:45+00:00"
+
+    def test_collections(self):
+        """Test list, tuple, and dict serialization."""
+        assert _sanitize_value(
+            [1, "string", UUID("123e4567-e89b-12d3-a456-426614174000"), None]
+        ) == [1, "string", "123e4567-e89b-12d3-a456-426614174000", None]
+        assert _sanitize_value((1, "string", True)) == [1, "string", True]
+        assert _sanitize_value({"key": UUID("123e4567-e89b-12d3-a456-426614174000")}) == {
+            "key": "123e4567-e89b-12d3-a456-426614174000"
+        }
+        assert _sanitize_value([]) == []
+        assert _sanitize_value({}) == {}
+
+    def test_nested_and_complex(self):
+        """Test nested structures and non-serializable types."""
+        # Nested structure
+        nested = {"level1": {"level2": {"level3": [1, 2, {"nested": "value"}]}}}
+        assert _sanitize_value(nested)["level1"]["level2"]["level3"][2]["nested"] == "value"
+
+        # Non-serializable
+        class CustomObject:
+            def __str__(self):
+                return "<CustomObject instance>"
+
+        result = _sanitize_value(CustomObject())
+        assert isinstance(result, str)
+        assert "<cannot be serialized" in result or "<CustomObject" in result
+
+
+class TestSanitizeDictKey:
+    """Test _sanitize_dict_key function."""
+
+    @pytest.mark.parametrize(
+        "key,expected_contains",
+        [
+            ("simple_key", "simple_key"),
+            (UUID("123e4567-e89b-12d3-a456-426614174000"), "123e4567-e89b-12d3-a456-426614174000"),
+            ((1, 2, 3), ["1", "2"]),
+        ],
+    )
+    def test_key_types(self, key, expected_contains):
+        result = _sanitize_dict_key(key)
+        assert isinstance(result, str)
+        if isinstance(expected_contains, list):
+            assert all(item in result for item in expected_contains)
+        else:
+            assert expected_contains in result
+
+    def test_non_serializable_key(self):
+        class BadKey:
+            def __str__(self):
+                return "<BadKey instance>"
+
+        result = _sanitize_dict_key(BadKey())
+        assert isinstance(result, str)
+        assert "<key:" in result or "<BadKey" in result
+
+
+class TestGetParamNames:
+    """Test _get_param_names function."""
+
+    @pytest.mark.parametrize(
+        "func_def,expected",
+        [
+            (lambda a, b, c: None, ["a", "b", "c"]),
+            (lambda a, b=42, c="default": None, ["a", "b", "c"]),
+            (lambda a, **kwargs: None, ["a", "kwargs"]),
+            (lambda *args: None, ["args"]),
+        ],
+    )
+    def test_param_extraction(self, func_def, expected):
+        assert _get_param_names(func_def) == expected
+
+    def test_async_function(self):
+        async def func(a, b):
+            pass
+
+        assert _get_param_names(func) == ["a", "b"]
+
+
+class TestGetParamDefaults:
+    """Test _get_param_defaults function."""
+
+    @pytest.mark.parametrize(
+        "func_def,expected",
+        [
+            (lambda a, b=42, c="default", d=None: None, {"b": 42, "c": "default", "d": None}),
+            (lambda a, b, c: None, {}),
+            (lambda a, b=10, c="test", d=None: None, {"b": 10, "c": "test", "d": None}),
+        ],
+    )
+    def test_default_extraction(self, func_def, expected):
+        assert _get_param_defaults(func_def) == expected
+
+
+class TestExtractUserId:
+    """Test _extract_user_id function."""
+
+    def test_user_extraction(self):
+        """Test extracting user_id from kwargs and args."""
+        user1 = SimpleNamespace(id=UUID("123e4567-e89b-12d3-a456-426614174000"))
+        user2 = SimpleNamespace(id="user-123")
+
+        # From kwargs
+        assert (
+            _extract_user_id((), {"user": user1}, ["user", "other"])
+            == "123e4567-e89b-12d3-a456-426614174000"
+        )
+        # From args
+        assert _extract_user_id((user2, "other"), {}, ["user", "other"]) == "user-123"
+        # Not present
+        assert _extract_user_id(("arg1",), {}, ["param1"]) is None
+        # None value
+        assert _extract_user_id((None,), {}, ["user"]) is None
+        # No id attribute
+        assert _extract_user_id((SimpleNamespace(name="test"),), {}, ["user"]) is None
+
+
+class TestExtractParameters:
+    """Test _extract_parameters function."""
+
+    def test_parameter_extraction(self):
+        """Test parameter extraction with various scenarios."""
+
+        def func1(param1, param2, user=None):
+            pass
+
+        def func2(param1, param2=42, param3="default", user=None):
+            pass
+
+        def func3():
+            pass
+
+        def func4(param1, user):
+            pass
+
+        # Kwargs only
+        result = _extract_parameters(
+            (), {"param1": "v1", "param2": 42}, _get_param_names(func1), func1
+        )
+        assert result == {"param1": "v1", "param2": 42}
+        assert "user" not in result
+
+        # Args only
+        result = _extract_parameters(("v1", 42), {}, _get_param_names(func1), func1)
+        assert result == {"param1": "v1", "param2": 42}
+
+        # Mixed args/kwargs
+        result = _extract_parameters(("v1",), {"param3": "v3"}, _get_param_names(func2), func2)
+        assert result["param1"] == "v1" and result["param3"] == "v3"
+
+        # Defaults included
+        result = _extract_parameters(("v1",), {}, _get_param_names(func2), func2)
+        assert result["param1"] == "v1" and result["param2"] == 42 and result["param3"] == "default"
+
+        # No parameters
+        assert _extract_parameters((), {}, _get_param_names(func3), func3) == {}
+
+        # User excluded
+        user = SimpleNamespace(id="user-123")
+        result = _extract_parameters(("v1", user), {}, _get_param_names(func4), func4)
+        assert result == {"param1": "v1"} and "user" not in result
+
+        # Fallback when inspection fails
+        class BadFunc:
+            pass
+
+        result = _extract_parameters(("arg1", "arg2"), {}, [], BadFunc())
+        assert "arg_0" in result or "arg_1" in result
+
+
+class TestDecoratorValidation:
+    """Test decorator validation and behavior."""
+
+    def test_decorator_validation(self):
+        """Test decorator validation and metadata preservation."""
+        # Sync function raises error
+        with pytest.raises(UsageLoggerError, match="requires an async function"):
+
+            @log_usage()
+            def sync_func():
+                pass
+
+        # Async function accepted
+        @log_usage()
+        async def async_func():
+            pass
+
+        assert callable(async_func)
+
+        # Metadata preserved
+        @log_usage(function_name="test_func", log_type="test")
+        async def test_func(param1: str, param2: int = 42):
+            """Test docstring."""
+            return param1
+
+        assert test_func.__name__ == "test_func"
+        assert "Test docstring" in test_func.__doc__

cognee/tests/unit/users/permissions/test_has_user_management_permission.py

@@ -0,0 +1,46 @@
+import pytest
+from uuid import uuid4
+
+from cognee.modules.users.permissions.methods.has_user_management_permission import (
+    has_user_management_permission,
+)
+from cognee.modules.users.exceptions import PermissionDeniedError
+
+
+class FakeTenant:
+    def __init__(self, owner_id):
+        self.owner_id = owner_id
+
+
+@pytest.mark.asyncio
+async def test_has_user_management_permission_owner_allowed(monkeypatch):
+    requester_id = uuid4()
+    tenant_id = uuid4()
+
+    async def fake_get_tenant(_):
+        return FakeTenant(owner_id=requester_id)
+
+    monkeypatch.setattr(
+        "cognee.modules.users.permissions.methods.has_user_management_permission.get_tenant",
+        fake_get_tenant,
+    )
+
+    result = await has_user_management_permission(requester_id, tenant_id)
+    assert result is True
+
+
+@pytest.mark.asyncio
+async def test_has_user_management_permission_non_owner_denied(monkeypatch):
+    requester_id = uuid4()
+    tenant_id = uuid4()
+
+    async def fake_get_tenant(_):
+        return FakeTenant(owner_id=uuid4())
+
+    monkeypatch.setattr(
+        "cognee.modules.users.permissions.methods.has_user_management_permission.get_tenant",
+        fake_get_tenant,
+    )
+
+    with pytest.raises(PermissionDeniedError):
+        await has_user_management_permission(requester_id, tenant_id)

{cognee-0.5.1.dev0.dist-info → cognee-0.5.2.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognee
-Version: 0.5.1.dev0
+Version: 0.5.2.dev0
 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
@@ -17,10 +17,11 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: <3.14,>=3.10
 Requires-Dist: aiofiles>=23.2.1
-Requires-Dist: aiohttp<4.0.0,>=3.11.14
+Requires-Dist: aiohttp<4.0.0,>=3.13.3
 Requires-Dist: aiolimiter>=1.2.1
 Requires-Dist: aiosqlite<1.0.0,>=0.20.0
 Requires-Dist: alembic<2,>=1.13.3
+Requires-Dist: cbor2>=5.8.0
 Requires-Dist: diskcache>=5.6.3
 Requires-Dist: fakeredis[lua]>=2.32.0
 Requires-Dist: fastapi-users[sqlalchemy]<15.0.0,>=14.0.1
@@ -32,6 +33,7 @@ Requires-Dist: instructor<2.0.0,>=1.9.1
 Requires-Dist: jinja2<4,>=3.1.3
 Requires-Dist: kuzu==0.11.3
 Requires-Dist: lancedb<1.0.0,>=0.24.0
+Requires-Dist: langdetect>=1.0.9
 Requires-Dist: limits<5,>=4.4.1
 Requires-Dist: litellm>=1.76.0
 Requires-Dist: mistralai>=1.9.10
@@ -41,7 +43,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<2.12.0,>=2.10.5
+Requires-Dist: pydantic>=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
@@ -54,6 +56,7 @@ Requires-Dist: structlog<26,>=25.2.0
 Requires-Dist: tenacity>=9.0.0
 Requires-Dist: tiktoken<1.0.0,>=0.8.0
 Requires-Dist: typing-extensions<5.0.0,>=4.12.2
+Requires-Dist: urllib3>=2.6.0
 Requires-Dist: uvicorn<1.0.0,>=0.34.0
 Requires-Dist: websockets<16.0.0,>=15.0.1
 Provides-Extra: anthropic
@@ -115,8 +118,11 @@ Requires-Dist: groq<1.0.0,>=0.8.0; extra == 'groq'
 Provides-Extra: huggingface
 Requires-Dist: transformers<5,>=4.46.3; extra == 'huggingface'
 Provides-Extra: langchain
+Requires-Dist: langchain-core>=1.2.5; extra == 'langchain'
 Requires-Dist: langchain-text-splitters<1.0.0,>=0.3.2; extra == 'langchain'
 Requires-Dist: langsmith<1.0.0,>=0.2.3; extra == 'langchain'
+Provides-Extra: llama-cpp
+Requires-Dist: llama-cpp-python[server]<1.0.0,>=0.3.0; extra == 'llama-cpp'
 Provides-Extra: llama-index
 Requires-Dist: llama-index-core<0.13,>=0.12.11; extra == 'llama-index'
 Provides-Extra: mistral
@@ -221,12 +227,12 @@ Use your data to build personalized and dynamic memory for AI Agents. Cognee let
 
 ## About Cognee
 
-Cognee is an open-source tool and platform that transforms your raw data into persistent and dynamic AI memory for Agents. It combines vector search with graph databases to make your documents both searchable by meaning and connected by relationships. 
+Cognee is an open-source tool and platform that transforms your raw data into persistent and dynamic AI memory for Agents. It combines vector search with graph databases to make your documents both searchable by meaning and connected by relationships.
 
 You can use Cognee in two ways:
 
 1. [Self-host Cognee Open Source](https://docs.cognee.ai/getting-started/installation), which stores all data locally by default.
-2. [Connect to Cognee Cloud](https://platform.cognee.ai/), and get the same OSS stack on managed infrastructure for easier development and productionization. 
+2. [Connect to Cognee Cloud](https://platform.cognee.ai/), and get the same OSS stack on managed infrastructure for easier development and productionization.
 
 ### Cognee Open Source (self-hosted):
 
@@ -237,8 +243,8 @@ You can use Cognee in two ways:
 - Offers high customizability through user-defined tasks, modular pipelines, and built-in search endpoints
 
 ### Cognee Cloud (managed):
-- Hosted web UI dashboard 
-- Automatic version updates 
+- Hosted web UI dashboard
+- Automatic version updates
 - Resource usage analytics
 - GDPR compliant, enterprise-grade security
 
@@ -275,13 +281,14 @@ To integrate other LLM providers, see our [LLM Provider Documentation](https://d
 
 ### Step 3: Run the Pipeline
 
-Cognee will take your documents, generate a knowledge graph from them and then query the graph based on combined relationships. 
+Cognee will take your documents, generate a knowledge graph from them and then query the graph based on combined relationships.
 
 Now, run a minimal pipeline:
 
 ```python
 import cognee
 import asyncio
+from pprint import pprint
 
 
 async def main():
@@ -299,7 +306,7 @@ async def main():
 
     # Display the results
     for result in results:
-        print(result)
+        pprint(result)
 
 
 if __name__ == '__main__':
@@ -313,7 +320,7 @@ As you can see, the output is generated from the document we previously stored i
   Cognee turns documents into AI memory.
 ```
 
-### Use the Cognee CLI 
+### Use the Cognee CLI
 
 As an alternative, you can get started with these essential commands: