Skip to content

armgit / burr

Public Imported from GitHub
0

Build applications that make decisions (chatbots, agents, simulations, etc...). Monitor, trace, persist, and execute on your own infrastructure.

Adds InMemoryPersister

elijahbenizzy1440029dce8f
diff --git a/burr/core/persistence.py b/burr/core/persistence.py
index 36c8a23c..71eeff51 100644
--- a/burr/core/persistence.py
+++ b/burr/core/persistence.py
@@ -1,7 +1,9 @@
import abc
+import datetime
import json
import sqlite3
from abc import ABCMeta
+from collections import defaultdict
from typing import Any, Dict, Literal, Optional, TypedDict
from burr.core import Action
@@ -336,6 +338,59 @@ class SQLLitePersister(BaseStatePersister):
self.connection.close()
+class InMemoryPersister(BaseStatePersister):
+ """In-memory persister for testing purposes. This is not recommended for production use."""
+
+ def __init__(self):
+ self._storage = defaultdict(lambda: defaultdict(list))
+
+ def load(
+ self, partition_key: str, app_id: Optional[str], sequence_id: Optional[int] = None, **kwargs
+ ) -> Optional[PersistedStateData]:
+ # If no app_id provided, return None
+ if app_id is None:
+ return None
+
+ if not (states := self._storage[partition_key][app_id]):
+ return None
+
+ if sequence_id is None:
+ return states[-1]
+
+ # Find states matching the specific sequence_id
+ matching_states = [state for state in states if state["sequence_id"] == sequence_id]
+
+ # Return the latest state for this sequence_id, if exists
+ return matching_states[-1] if matching_states else None
+
+ def list_app_ids(self, partition_key: str, **kwargs) -> list[str]:
+ return list(self._storage[partition_key].keys())
+
+ def save(
+ self,
+ partition_key: Optional[str],
+ app_id: str,
+ sequence_id: int,
+ position: str,
+ state: State,
+ status: Literal["completed", "failed"],
+ **kwargs,
+ ):
+ # Create a PersistedStateData entry
+ persisted_state: PersistedStateData = {
+ "partition_key": partition_key or "",
+ "app_id": app_id,
+ "sequence_id": sequence_id,
+ "position": position,
+ "state": state,
+ "created_at": datetime.datetime.now().isoformat(),
+ "status": status,
+ }
+
+ # Store the state
+ self._storage[partition_key][app_id].append(persisted_state)
+
+
if __name__ == "__main__":
s = SQLLitePersister(db_path=".sqllite.db", table_name="test1")
s.initialize()
diff --git a/tests/core/test_persistence.py b/tests/core/test_persistence.py
index bd43c7fb..8bd0a57f 100644
--- a/tests/core/test_persistence.py
+++ b/tests/core/test_persistence.py
@@ -1,50 +1,68 @@
import pytest
from burr.core import State
-from burr.core.persistence import SQLLitePersister
+from burr.core.persistence import InMemoryPersister, SQLLitePersister
-def persistence():
+ params=[
+ {"which": "sqlite"},
+ {"which": "memory"},
+ ]
+)
+def persistence(request):
+ which = request.param["which"]
+ if which == "sqlite":
+ return SQLLitePersister(db_path=":memory:", table_name="test_table")
+ elif which == "memory":
+ return InMemoryPersister()
+ # return SQLLitePersister(db_path=":memory:", table_name="test_table")
+
+
+def initializing_persistence():
return SQLLitePersister(db_path=":memory:", table_name="test_table")
-def test_persistence_initialization_creates_table(persistence):
- persistence.initialize()
- assert persistence.list_app_ids("partition_key") == []
+def test_persistence_initialization_creates_table(initializing_persistence):
+ initializing_persistence.initialize()
+ assert initializing_persistence.list_app_ids("partition_key") == []
def test_persistence_saves_and_loads_state(persistence):
- persistence.initialize()
+ if hasattr(persistence, "initialize"):
+ persistence.initialize()
persistence.save("partition_key", "app_id", 1, "position", State({"key": "value"}), "status")
loaded_state = persistence.load("partition_key", "app_id")
assert loaded_state["state"] == State({"key": "value"})
def test_persistence_returns_none_when_no_state(persistence):
- persistence.initialize()
+ if hasattr(persistence, "initialize"):
+ persistence.initialize()
loaded_state = persistence.load("partition_key", "app_id")
assert loaded_state is None
def test_persistence_lists_app_ids(persistence):
- persistence.initialize()
+ if hasattr(persistence, "initialize"):
+ persistence.initialize()
persistence.save("partition_key", "app_id1", 1, "position", State({"key": "value"}), "status")
persistence.save("partition_key", "app_id2", 1, "position", State({"key": "value"}), "status")
app_ids = persistence.list_app_ids("partition_key")
assert set(app_ids) == set(["app_id1", "app_id2"])
-def test_persistence_is_initialized_false(persistence):
- assert not persistence.is_initialized()
+def test_persistence_is_initialized_false(initializing_persistence):
+ assert not initializing_persistence.is_initialized()
-def test_persistence_is_initialized_true(persistence):
- persistence.initialize()
- assert persistence.is_initialized()
+def test_persistence_is_initialized_true(initializing_persistence):
+ initializing_persistence.initialize()
+ assert initializing_persistence.is_initialized()
-def test_persistence_is_initialized_true_new_connection(tmp_path):
+def test_sqlite_persistence_is_initialized_true_new_connection(tmp_path):
db_path = tmp_path / "test.db"
p = SQLLitePersister(db_path=db_path, table_name="test_table")
p.initialize()
@@ -72,7 +90,8 @@ def test_persistence_is_initialized_true_new_connection(tmp_path):
],
)
def test_persister_methods_none_partition_key(persistence, method_name: str, kwargs: dict):
- persistence.initialize()
+ if hasattr(persistence, "initialize"):
+ persistence.initialize()
method = getattr(persistence, method_name)
# method can be executed with `partition_key=None`
method(**kwargs)