wip

Author: mkrd

dictdatabase/sessions.py

@@ -29,13 +29,13 @@ def __enter__(self):
 		self.data_handle = {}
 
 	def __exit__(self, type, value, tb):
-		wl = getattr(self, "write_lock", None)
-		if wl is not None:
-			if isinstance(wl, list):
-				for lock in wl:
+		write_lock = getattr(self, "write_lock", None)
+		if write_lock is not None:
+			if isinstance(write_lock, list):
+				for lock in write_lock:
 					lock._unlock()
 			else:
-				wl._unlock()
+				write_lock._unlock()
 		self.write_lock, self.in_session = None, False
 
 	def write(self):
@@ -46,12 +46,10 @@ def write(self):
 
 class SessionFileFull(SessionBase, Generic[T]):
 	"""
-		Enter:
-		>>> with DDBSession(db_name) as (session, data):
+		Context manager for read-write access to a full file.
 
-		Where `data` is the dict that was read from the filesystem. Modify
-		`data` and call session.write() to save changes. If you don't call it,
-		the changes will be lost after exiting the with statement.
+		Efficiency:
+		Reads and writes the entire file.
 	"""
 
 	def __init__(self, db_name: str, as_type: T = None):
@@ -76,12 +74,12 @@ def write(self):
 
 class SessionFileKey(SessionBase, Generic[T]):
 	"""
-		Enter:
-		>>> with DDBSession(db_name) as (session, data):
+		Context manager for read-write access to a single key-value item in a file.
 
-		Where `data` is the dict that was read from the filesystem. Modify
-		`data` and call session.write() to save changes. If you don't call it,
-		the changes will be lost after exiting the with statement.
+		Efficiency:
+		Uses partial reading, which allows only reading the bytes of the key-value item.
+		When writing, only the bytes of the key-value and the bytes of the file after
+		the key-value are written.
 	"""
 
 	def __init__(self, db_name: str, key: str, as_type: T = None):
@@ -108,14 +106,13 @@ def write(self):
 
 class SessionFileWhere(SessionBase, Generic[T]):
 	"""
-		Enter:
-		>>> with DDBSession(db_name) as (session, data):
+		Context manager for read-write access to selection of key-value items in a file.
+		The where callable is called with the key and value of each item in the file.
 
-		Where `data` is the dict that was read from the filesystem. Modify
-		`data` and call session.write() to save changes. If you don't call it,
-		the changes will be lost after exiting the with statement.
+		Efficiency:
+		Reads and writes the entire file, so it is not more efficient than
+		SessionFileFull.
 	"""
-
 	def __init__(self, db_name: str, where: Callable[[Any, Any], bool], as_type: T = None):
 		super().__init__(db_name, as_type)
 		self.where = where
@@ -143,14 +140,13 @@ def write(self):
 
 class SessionDirFull(SessionBase, Generic[T]):
 	"""
-		Enter:
-		>>> with DDBSession(db_name) as (session, data):
+		Context manager for read-write access to all files in a directory.
+		They are provided as a dict of {str(file_name): dict(file_content)}, where the
+		file name does not contain the directory name nor the file extension.
 
-		Where `data` is the dict that was read from the filesystem. Modify
-		`data` and call session.write() to save changes. If you don't call it,
-		the changes will be lost after exiting the with statement.
+		Efficiency:
+		Fully reads and writes all files.
 	"""
-
 	def __init__(self, db_name: str, as_type: T = None):
 		super().__init__(utils.find_all(db_name), as_type)
 
@@ -175,14 +171,12 @@ def write(self):
 
 class SessionDirWhere(SessionBase, Generic[T]):
 	"""
-		Enter:
-		>>> with DDBSession(db_name) as (session, data):
+		Context manager for read-write access to selection of files in a directory.
+		The where callable is called with the file name and parsed content of each file.
 
-		Where `data` is the dict that was read from the filesystem. Modify
-		`data` and call session.write() to save changes. If you don't call it,
-		the changes will be lost after exiting the with statement.
+		Efficiency:
+		Fully reads all files, but only writes the selected files.
 	"""
-
 	def __init__(self, db_name: str, where: Callable[[Any, Any], bool], as_type: T = None):
 		super().__init__(utils.find_all(db_name), as_type)
 		self.where = where

tests/conftest.py

@@ -13,6 +13,12 @@ def use_test_dir(request):
 
 
 
+@pytest.fixture(scope="function")
+def name_of_test(request):
+	return request.function.__name__
+
+
+
 @pytest.fixture(params=[True, False])
 def use_compression(request):
 	DDB.config.use_compression = request.param

tests/test_create.py

@@ -6,21 +6,21 @@
 from tests.utils import make_complex_nested_random_dict
 
 
-def test_create(use_test_dir, use_compression, use_orjson, indent):
-	DDB.at("create").create(force_overwrite=True)
-	db = DDB.at("create").read()
+def test_create(use_test_dir, name_of_test,  use_compression, use_orjson, indent):
+	DDB.at(name_of_test).create(force_overwrite=True)
+	db = DDB.at(name_of_test).read()
 	assert db == {}
 
-	with DDB.at("create").session(as_type=pd) as (session, d):
+	with DDB.at(name_of_test).session(as_type=pd) as (session, d):
 		d["a", "b", "c"] = "😁"
 		session.write()
-	assert DDB.at("create").read() == {"a": {"b": {"c": "😁"}}}
+	assert DDB.at(name_of_test).read() == {"a": {"b": {"c": "😁"}}}
 
 	with pytest.raises(RuntimeError):
-		DDB.at("create", where=lambda k, v: True).create(force_overwrite=True)
+		DDB.at(name_of_test, where=lambda k, v: True).create(force_overwrite=True)
 
 	with pytest.raises(RuntimeError):
-		DDB.at("create", key="any").create(force_overwrite=True)
+		DDB.at(name_of_test, key="any").create(force_overwrite=True)
 
 
 def test_create_edge_cases(use_test_dir, use_compression, use_orjson, indent):