memmachine-server 0.3.0__tar.gz → 0.3.2__tar.gz

{memmachine_server-0.3.0/src/memmachine_server.egg-info → memmachine_server-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.0
+Version: 0.3.2
 Summary: MemMachine Server - The complete MemMachine memory system server with episodic and profile memory
 Author-email: MemMachine <noreply@memmachine.ai>
 License-Expression: Apache-2.0
@@ -29,7 +29,7 @@ Requires-Dist: instructor[bedrock]>=1.12.0
 Requires-Dist: json-repair>=0.54
 Requires-Dist: langchain-aws>=0.2.33
 Requires-Dist: neo4j>=5.28.2
-Requires-Dist: nltk>=3.9.1
+Requires-Dist: nltk>=3.9.3
 Requires-Dist: openai>=2.21.0
 Requires-Dist: pgvector>=0.4.1
 Requires-Dist: prometheus-client>=0.22.1
@@ -44,6 +44,8 @@ Requires-Dist: tzdata>=2024.1; sys_platform == "win32"
 Requires-Dist: psutil>=7.1.0
 Provides-Extra: gpu
 Requires-Dist: sentence-transformers>=5.1.0; extra == "gpu"
+Provides-Extra: nebula
+Requires-Dist: nebula5-python>=5.2.1; extra == "nebula"
 Dynamic: license-file
 
 # MemMachine

{memmachine_server-0.3.0 → memmachine_server-0.3.2}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
     "json-repair>=0.54",
     "langchain-aws>=0.2.33",
     "neo4j>=5.28.2",
-    "nltk>=3.9.1",
+    "nltk>=3.9.3",
     "openai>=2.21.0",
     "pgvector>=0.4.1",
     "prometheus-client>=0.22.1",
@@ -54,6 +54,9 @@ license = "Apache-2.0"
 gpu = [
     "sentence-transformers>=5.1.0",
 ]
+nebula = [
+    "nebula5-python>=5.2.1",
+]
 
 [project.scripts]
 memmachine-server = "memmachine_server.server.app:main"

{memmachine_server-0.3.0 → memmachine_server-0.3.2}/server_tests/memmachine_server/common/configuration/test_database_conf.py

@@ -166,6 +166,39 @@ def test_serialize_deserialize_database_conf(db_conf_dict):
     assert conf == conf_cp
 
 
+def test_neo4j_pool_lifecycle_fields():
+    # Defaults are None (use driver's internal defaults)
+    conf = Neo4jConf()
+    assert conf.max_connection_lifetime is None
+    assert conf.liveness_check_timeout is None
+
+    # Explicit values round-trip correctly
+    conf = Neo4jConf(max_connection_lifetime=3000.0, liveness_check_timeout=300.0)
+    assert conf.max_connection_lifetime == 3000.0
+    assert conf.liveness_check_timeout == 300.0
+
+
+def test_sqlalchemy_pool_lifecycle_fields():
+    # Defaults are None (use SQLAlchemy's internal defaults)
+    conf = SqlAlchemyConf(dialect="sqlite", driver="aiosqlite", path="test.db")
+    assert conf.pool_timeout is None
+    assert conf.pool_recycle is None
+    assert conf.pool_pre_ping is None
+
+    # Explicit values round-trip correctly
+    conf = SqlAlchemyConf(
+        dialect="sqlite",
+        driver="aiosqlite",
+        path="test.db",
+        pool_timeout=30,
+        pool_recycle=3000,
+        pool_pre_ping=True,
+    )
+    assert conf.pool_timeout == 30
+    assert conf.pool_recycle == 3000
+    assert conf.pool_pre_ping is True
+
+
 def test_neo4j_uri():
     conf = Neo4jConf(uri="bolt://localhost:1234")
     assert conf.get_uri() == "bolt://localhost:1234"

memmachine_server-0.3.2/server_tests/memmachine_server/common/resource_manager/test_database_manager.py

@@ -0,0 +1,256 @@
+from typing import Any, cast
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from pydantic import SecretStr
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+from memmachine_server.common.configuration.database_conf import (
+    DatabasesConf,
+    Neo4jConf,
+    SqlAlchemyConf,
+)
+from memmachine_server.common.resource_manager.database_manager import DatabaseManager
+from memmachine_server.common.vector_graph_store import VectorGraphStore
+
+
+@pytest.fixture
+def mock_conf():
+    """Mock StoragesConf with dummy connection configurations."""
+    conf = MagicMock(spec=DatabasesConf)
+    conf.neo4j_confs = {
+        "neo1": Neo4jConf(
+            host="localhost", port=1234, user="neo", password=SecretStr("pw")
+        ),
+    }
+    conf.relational_db_confs = {
+        "pg1": SqlAlchemyConf(
+            dialect="postgresql",
+            driver="asyncpg",
+            host="localhost",
+            port=5432,
+            user="user",
+            password=SecretStr("password"),
+            db_name="testdb",
+        ),
+        "sqlite1": SqlAlchemyConf(
+            dialect="sqlite",
+            driver="aiosqlite",
+            path="test.db",
+        ),
+    }
+    conf.sqlite_confs = {}
+    conf.nebula_graph_confs = {}
+    return conf
+
+
+@pytest.mark.asyncio
+async def test_build_neo4j(mock_conf):
+    builder = DatabaseManager(mock_conf)
+    await builder._build_neo4j()
+
+    assert "neo1" in builder.graph_stores
+    driver = builder.graph_stores["neo1"]
+    assert isinstance(driver, VectorGraphStore)
+
+
+@pytest.mark.asyncio
+async def test_validate_neo4j(mock_conf):
+    builder = DatabaseManager(mock_conf)
+
+    mock_driver = MagicMock()
+    mock_session = AsyncMock()
+    mock_result = AsyncMock()
+    mock_record = {"ok": 1}
+
+    mock_driver.close = AsyncMock()
+    mock_result.single.return_value = mock_record
+    mock_session.run.return_value = mock_result
+
+    mock_driver.session.return_value.__aenter__ = AsyncMock(return_value=mock_session)
+    mock_driver.session.return_value.__aexit__ = AsyncMock(return_value=None)
+
+    builder.neo4j_drivers = {"neo1": mock_driver}
+
+    await builder._validate_neo4j_drivers()
+    mock_session.run.assert_awaited_once_with("RETURN 1 AS ok")
+
+
+@pytest.mark.asyncio
+async def test_build_sqlite(mock_conf):
+    builder = DatabaseManager(mock_conf)
+    await builder._build_sql_engines()
+
+    assert "sqlite1" in builder.sql_engines
+    assert isinstance(builder.sql_engines["sqlite1"], AsyncEngine)
+
+
+@pytest.mark.asyncio
+async def test_build_and_validate_sqlite():
+    conf = MagicMock(spec=DatabasesConf)
+    conf.neo4j_confs = {}
+    conf.nebula_graph_confs = {}
+    conf.relational_db_confs = {
+        "sqlite1": SqlAlchemyConf(
+            dialect="sqlite",
+            driver="aiosqlite",
+            path=":memory:",
+        )
+    }
+    builder = DatabaseManager(conf)
+    await builder.build_all(validate=True)
+    # If no exception is raised, validation passed
+    assert "sqlite1" in builder.sql_engines
+    await builder.close()
+    assert "sqlite1" not in builder.sql_engines
+
+
+@pytest.mark.asyncio
+async def test_build_all_without_validation(mock_conf):
+    builder = DatabaseManager(mock_conf)
+    builder_any = cast(Any, builder)
+    builder_any._build_neo4j = AsyncMock()
+    builder_any._build_sql_engines = AsyncMock()
+    builder_any._validate_neo4j_drivers = AsyncMock()
+    builder_any._validate_sql_engines = AsyncMock()
+
+    await builder.build_all(validate=False)
+
+    assert "sqlite1" in builder.sql_engines
+    assert "pg1" in builder.sql_engines
+    assert "neo1" in builder.graph_stores
+
+
+@pytest.mark.asyncio
+async def test_neo4j_pool_lifecycle_kwargs():
+    """max_connection_lifetime and liveness_check_timeout are forwarded to the driver."""
+    conf = MagicMock(spec=DatabasesConf)
+    neo4j_conf = Neo4jConf(
+        host="localhost",
+        port=7687,
+        user="neo4j",
+        password=SecretStr("pw"),
+        max_connection_lifetime=3000.0,
+        liveness_check_timeout=300.0,
+    )
+    conf.neo4j_confs = {"neo1": neo4j_conf}
+    conf.relational_db_confs = {}
+    conf.nebula_graph_confs = {}
+
+    mock_driver = MagicMock()
+    mock_driver.close = AsyncMock()
+
+    with (
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.AsyncGraphDatabase.driver",
+            return_value=mock_driver,
+        ) as mock_driver_cls,
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStoreParams",
+        ),
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStore",
+        ),
+    ):
+        builder = DatabaseManager(conf)
+        await builder.async_get_neo4j_driver("neo1")
+
+    call_kwargs = mock_driver_cls.call_args.kwargs
+    assert call_kwargs["max_connection_lifetime"] == 3000.0
+    assert call_kwargs["liveness_check_timeout"] == 300.0
+
+
+@pytest.mark.asyncio
+async def test_sqlalchemy_pool_lifecycle_kwargs():
+    """pool_timeout, pool_recycle, and pool_pre_ping are forwarded to create_async_engine."""
+    conf = MagicMock(spec=DatabasesConf)
+    sql_conf = SqlAlchemyConf(
+        dialect="sqlite",
+        driver="aiosqlite",
+        path=":memory:",
+        pool_timeout=30,
+        pool_recycle=3000,
+        pool_pre_ping=True,
+    )
+    conf.neo4j_confs = {}
+    conf.nebula_graph_confs = {}
+    conf.relational_db_confs = {"db1": sql_conf}
+
+    mock_engine = MagicMock(spec=AsyncEngine)
+
+    with patch(
+        "memmachine_server.common.resource_manager.database_manager.create_async_engine",
+        return_value=mock_engine,
+    ) as mock_create:
+        builder = DatabaseManager(conf)
+        await builder.async_get_sql_engine("db1")
+
+    call_kwargs = mock_create.call_args.kwargs
+    assert call_kwargs["pool_timeout"] == 30
+    assert call_kwargs["pool_recycle"] == 3000
+    assert call_kwargs["pool_pre_ping"] is True
+
+
+@pytest.mark.asyncio
+async def test_neo4j_pool_lifecycle_kwargs_none_omitted():
+    """When pool lifecycle fields are None, they are not forwarded to the driver."""
+    conf = MagicMock(spec=DatabasesConf)
+    neo4j_conf = Neo4jConf(
+        host="localhost",
+        port=7687,
+        user="neo4j",
+        password=SecretStr("pw"),
+    )
+    conf.neo4j_confs = {"neo1": neo4j_conf}
+    conf.relational_db_confs = {}
+    conf.nebula_graph_confs = {}
+
+    mock_driver = MagicMock()
+    mock_driver.close = AsyncMock()
+
+    with (
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.AsyncGraphDatabase.driver",
+            return_value=mock_driver,
+        ) as mock_driver_cls,
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStoreParams",
+        ),
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStore",
+        ),
+    ):
+        builder = DatabaseManager(conf)
+        await builder.async_get_neo4j_driver("neo1")
+
+    call_kwargs = mock_driver_cls.call_args.kwargs
+    assert "max_connection_lifetime" not in call_kwargs
+    assert "liveness_check_timeout" not in call_kwargs
+
+
+@pytest.mark.asyncio
+async def test_sqlalchemy_pool_lifecycle_kwargs_none_omitted():
+    """When pool lifecycle fields are None, they are not forwarded to create_async_engine."""
+    conf = MagicMock(spec=DatabasesConf)
+    sql_conf = SqlAlchemyConf(
+        dialect="sqlite",
+        driver="aiosqlite",
+        path=":memory:",
+    )
+    conf.neo4j_confs = {}
+    conf.nebula_graph_confs = {}
+    conf.relational_db_confs = {"db1": sql_conf}
+
+    mock_engine = MagicMock(spec=AsyncEngine)
+
+    with patch(
+        "memmachine_server.common.resource_manager.database_manager.create_async_engine",
+        return_value=mock_engine,
+    ) as mock_create:
+        builder = DatabaseManager(conf)
+        await builder.async_get_sql_engine("db1")
+
+    call_kwargs = mock_create.call_args.kwargs
+    assert "pool_timeout" not in call_kwargs
+    assert "pool_recycle" not in call_kwargs
+    assert "pool_pre_ping" not in call_kwargs

{memmachine_server-0.3.0 → memmachine_server-0.3.2}/server_tests/memmachine_server/common/session_manager/test_session_manager.py

@@ -2,6 +2,7 @@ from unittest.mock import MagicMock
 
 import pytest
 import pytest_asyncio
+from pydantic import JsonValue
 from sqlalchemy.ext.asyncio import AsyncEngine
 
 from memmachine_server.common.configuration.episodic_config import (
@@ -102,9 +103,9 @@ async def test_create_new_session(
 ):
     """Test creating a new session successfully."""
     session_key = "session1"
-    config = {"key": "value"}
+    config: dict[str, JsonValue] = {"key": "value"}
     description = "A test session"
-    metadata = {"user": "tester"}
+    metadata: dict[str, JsonValue] = {"user": "tester"}
 
     await session_manager.create_new_session(
         session_key,