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

{memmachine_server-0.3.1/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.1
+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

{memmachine_server-0.3.1 → 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.1 → memmachine_server-0.3.2}/src/memmachine_server/common/configuration/database_conf.py

@@ -60,6 +60,24 @@ class Neo4jConf(YamlSerializableMixin, PasswordMixin):
             "Internal default is 60.0."
         ),
     )
+    max_connection_lifetime: float | None = Field(
+        default=None,
+        description=(
+            "Maximum connection lifetime in seconds. Connections older than this "
+            "are proactively closed and replaced. Set below your infrastructure's "
+            "idle-connection timeout (e.g. AuraDB's 60-minute limit) to avoid "
+            "handing out defunct connections. Internal default is 3600."
+        ),
+    )
+    liveness_check_timeout: float | None = Field(
+        default=None,
+        description=(
+            "Idle time in seconds after which a pooled connection is tested for "
+            "liveness before being handed to a caller. Catches connections that "
+            "were reset server-side while sitting idle in the pool. "
+            "Set to None to disable liveness checks."
+        ),
+    )
 
     def get_uri(self) -> str:
         if self.uri:
@@ -241,6 +259,31 @@ class SqlAlchemyConf(YamlSerializableMixin, PasswordMixin):
             "disposed of when no longer needed."
         ),
     )
+    pool_timeout: int | None = Field(
+        default=None,
+        description=(
+            "Maximum time in seconds to wait for a connection from the pool. "
+            "If no connection is available within this period, a TimeoutError "
+            "is raised. Internal default is 30."
+        ),
+    )
+    pool_recycle: int | None = Field(
+        default=None,
+        description=(
+            "Maximum age of a connection in seconds before it is recycled. "
+            "Connections older than this are transparently replaced on checkout. "
+            "Set below your database server's idle-connection timeout to avoid "
+            "handing out stale connections. Internal default is -1 (disabled)."
+        ),
+    )
+    pool_pre_ping: bool | None = Field(
+        default=None,
+        description=(
+            "When True, test each connection for liveness (via a lightweight "
+            "SELECT 1) before checking it out of the pool. Catches connections "
+            "that were reset server-side. Internal default is False."
+        ),
+    )
 
     @property
     def schema_part(self) -> str:

{memmachine_server-0.3.1 → memmachine_server-0.3.2}/src/memmachine_server/common/resource_manager/database_manager.py

@@ -9,7 +9,10 @@ from neo4j import AsyncDriver, AsyncGraphDatabase
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
-from memmachine_server.common.configuration.database_conf import DatabasesConf
+from memmachine_server.common.configuration.database_conf import (
+    DatabasesConf,
+    Neo4jConf,
+)
 from memmachine_server.common.errors import (
     Neo4JConfigurationError,
     SQLConfigurationError,
@@ -120,6 +123,25 @@ class DatabaseManager:
         if tasks:
             await asyncio.gather(*tasks)
 
+    @staticmethod
+    def _build_neo4j_driver_kwargs(conf: Neo4jConf) -> dict[str, Any]:
+        """Build keyword arguments for AsyncGraphDatabase.driver from config."""
+        kwargs: dict[str, Any] = {
+            "uri": conf.get_uri(),
+            "auth": (conf.user, conf.password.get_secret_value()),
+        }
+        optional_fields = (
+            "max_connection_pool_size",
+            "connection_acquisition_timeout",
+            "max_connection_lifetime",
+            "liveness_check_timeout",
+        )
+        for field in optional_fields:
+            value = getattr(conf, field)
+            if value is not None:
+                kwargs[field] = value
+        return kwargs
+
     async def async_get_neo4j_driver(
         self, name: str, validate: bool = False
     ) -> AsyncDriver:
@@ -136,20 +158,7 @@ class DatabaseManager:
             if not conf:
                 raise ValueError(f"Neo4j config '{name}' not found.")
 
-            driver_kwargs: dict[str, Any] = {
-                "uri": conf.get_uri(),
-                "auth": (conf.user, conf.password.get_secret_value()),
-            }
-            if conf.max_connection_pool_size is not None:
-                driver_kwargs["max_connection_pool_size"] = (
-                    conf.max_connection_pool_size
-                )
-            if conf.connection_acquisition_timeout is not None:
-                driver_kwargs["connection_acquisition_timeout"] = (
-                    conf.connection_acquisition_timeout
-                )
-
-            driver = AsyncGraphDatabase.driver(**driver_kwargs)
+            driver = AsyncGraphDatabase.driver(**self._build_neo4j_driver_kwargs(conf))
             if validate:
                 await self.validate_neo4j_driver(name, driver)
             self.neo4j_drivers[name] = driver
@@ -255,6 +264,12 @@ class DatabaseManager:
                 engine_kwargs["pool_size"] = conf.pool_size
             if conf.max_overflow is not None:
                 engine_kwargs["max_overflow"] = conf.max_overflow
+            if conf.pool_timeout is not None:
+                engine_kwargs["pool_timeout"] = conf.pool_timeout
+            if conf.pool_recycle is not None:
+                engine_kwargs["pool_recycle"] = conf.pool_recycle
+            if conf.pool_pre_ping is not None:
+                engine_kwargs["pool_pre_ping"] = conf.pool_pre_ping
 
             engine = create_async_engine(conf.uri, **engine_kwargs)
             if validate:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.1
+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

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

@@ -1,121 +0,0 @@
-from typing import Any, cast
-from unittest.mock import AsyncMock, MagicMock
-
-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