Added added to ConcurrentDictionary to give possibility of avoiding warning when assigning a new key-value pair. Updated tests

Author: alelom

concurrent_collections/concurrent_dict.py

@@ -29,10 +29,11 @@ def __getitem__(self, key: K) -> V:
     def __setitem__(self, key: K, value: V) -> None:
         warnings.warn(
             f"Direct assignment (D[key] = value) is discouraged. "
-            f"Use update_atomic for thread-safe compound updates.",
+            f"Use assign_atomic() for assigning a value to a new key safely, "
+            f"or update_atomic() for thread-safe update of an existing dictionary key.",
             stacklevel=2
         )
-        self.update_atomic(key, lambda _: value)
+        self.assign_atomic(key, value)
 
 
     def __delitem__(self, key: K) -> None:
@@ -50,17 +51,27 @@ def setdefault(self, key: K, default: V) -> V:
             return self._dict.setdefault(key, default)
 
 
+    def assign_atomic(self, key: K, value: V) -> None:
+        """
+        Atomically assign a value to a key.
+
+        This method ensures that the assignment is performed atomically,
+        preventing
+        """
+        self.update_atomic(key, lambda _: value)
+        
+    
     def update_atomic(self, key: K, func: Callable[[V], V]) -> None:
         """
-        Atomically update the value for a key using func(old_value) -> new_value.
+        Atomically modify the value for a key using func(old_value) -> new_value.
 
         This method ensures that the read-modify-write sequence is performed atomically,
         preventing race conditions in concurrent environments.
 
         Example:
             d = ConcurrentDictionary({'x': 0})
             # Atomically increment the value for 'x'
-            d.update_atomic('x', lambda v: v + 1)
+            d.modify_atomic('x', lambda v: v + 1)
         """
         with self._lock:
             if key in self._dict:

tests/concurrent_dict_test.py

@@ -12,22 +12,24 @@
 
 def test_concurrentdictionary_update_thread_safe():
     dic : ConcurrentDictionary[str, int] = ConcurrentDictionary()
-    dic["x"] = 0
+    update_actions : int = 10000
+    dic.assign_atomic("x", 0)
     def worker():
-        for _ in range(10000):
-            old = dic['x']
+        for _ in range(update_actions):
             time.sleep(0.00001)
             # D.__setitem__('x', old + 1)
             dic.update_atomic("x", lambda v: v + 1)
 
-    threads = [threading.Thread(target=worker) for _ in range(8)]
+    threads_num : int = 8
+    threads = [threading.Thread(target=worker) for _ in range(threads_num)]
     for t in threads:
         t.start()
     for t in threads:
         t.join()
 
     # The expected value is 8 * 10000 = 80000
-    assert dic['x'] == 80000, f"ConcurrentDictionary should be thread-safe, got {dic['x']}"
+    expected_value = threads_num * update_actions
+    assert dic['x'] == expected_value, f"ConcurrentDictionary should be thread-safe and with a value of {expected_value} for the `x` key, got {dic['x']}"
 
 
 def test_concurrentdictionary_setdefault_thread_safe():