Implement code changes to enhance functionality and improve performance

Author: alelom

.vscode/settings.json

@@ -0,0 +1,87 @@
+{
+    "python.testing.unittestArgs": [
+        "-v",
+        "-s",
+        "./src",
+        "-p",
+        "test_*.py",
+        "*_test.py"
+    ],
+    "python.testing.pytestEnabled": true,
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestArgs": [
+        "--rootdir", "${workspaceFolder}/src",
+        "--ignore-glob", "_SS*",
+        "--ignore-glob", "src/deployment/api/_shared_od*",
+        "--ignore-glob", "GUI",
+        "--cache-clear"
+    ],
+    "python.analysis.typeCheckingMode": "strict",
+    "python.analysis.include": [
+        "./src/**",
+    ],
+    "python.analysis.exclude": [
+        "**/_SS**",
+        "**/dist/**",
+        "**/build/**",
+        "**/.git/**",
+        "**/.hg/**",
+        "**/.svn/**",
+        "**/.vscode/**",
+        "**/.history/**",
+        "**/CVS/**",
+        "**/.cache/**",
+        "**/venv/**",
+        "**/.venv/**",
+        "**/env/**",
+        "**/.env/**",
+        "**/site-packages/**",
+    ],
+    "python.analysis.diagnosticSeverityOverrides": {
+        "reportUnusedImport": "information",
+        "reportUnusedVariable": "information",
+        "reportPrivateUsage": "warning",
+        "reportMissingTypeStubs": "information",
+        "reportConstantRedefinition": "information",
+        "reportMissingTypeArgument": "information",
+        "reportMissingParameterType": "warning",
+        "reportUnknownArgumentType": "warning",
+        "reportUnnecessaryCast": "warning",
+        "reportUnknownMemberType": "warning",
+        "reportUnknownVariableType": "warning",
+        "reportUnknownParameterType": "warning"
+    },
+    "python.analysis.extraPaths": [
+        "./src",
+        "./src/data",
+        "./src/deployment",
+        "./src/features",
+        "./src/models",
+        "./src/integration",
+        "./src/visualisation",
+    ],
+    "python.autoComplete.extraPaths": [
+        "./src",
+        "./src/data",
+        "./src/deployment",
+        "./src/features",
+        "./src/models",
+        "./src/integration",
+        "./src/visualisation",
+    ],
+    "search.followSymlinks": false,
+    "search.exclude": {
+        "**/node_modules": true,
+        "**/bower_components": true,
+        "**/*.code-search": true,
+        "**/*.drawio": true,
+        "**/_SS/**": true,
+        "**.venv/**": true,
+    },
+    "files.exclude": {
+        "**/.pytest_cache": true,
+        "**/.*": {
+        "when": "$(basename).isDirectory"
+        }
+    }
+}

concurrent_collections/concurrent_dict.py

@@ -1,13 +1,13 @@
 import threading
-from typing import Any, Callable, Dict, Iterator, List, Optional, TypeVar
+from typing import Any, Callable, Dict, Iterator, List, Optional, TypeVar, Generic
 import warnings
 import sys
 
 T = TypeVar('T')
 K = TypeVar('K')
 V = TypeVar('V')
 
-class ConcurrentDictionary:
+class ConcurrentDictionary(Generic[K, V]):
     """
     A thread-safe dictionary implementation using a re-entrant lock.
     All operations that mutate or access the dictionary are protected.
@@ -64,7 +64,13 @@ def update_atomic(self, key: K, func: Callable[[V], V]) -> None:
             d.update_atomic('x', lambda v: v + 1)
         """
         with self._lock:
-            self._dict[key] = func(self._dict[key])
+            if key in self._dict:
+                old_value = self._dict[key]
+                new_value = func(old_value)
+                self._dict[key] = new_value
+            else:
+                # If the key does not exist, we can set it directly
+                self._dict[key] = func(None) # type: ignore
 
 
     def pop(self, key: K, default: Optional[V] = None) -> V:

pyproject.toml

@@ -10,7 +10,9 @@ authors = [{ name = "Alessio Lombardi", email = "[email protected]" }]
 license = { file = "MIT" }
 readme = "README.md"
 requires-python = ">=3.6"
-dependencies = []
+dependencies = [
+    "pytest>=7.0.1",
+]
 
 [tool.setuptools]
-packages = ["concurrent_collections"]
+packages = ["concurrent_collections"]

tests/concurrent_dict_test.py

@@ -6,16 +6,18 @@
 import threading
 import time
 from concurrent_collections import ConcurrentDictionary
+import pytest
 
 
 def test_concurrentdictionary_update_thread_safe():
-    D = ConcurrentDictionary({'x': 0})
+    dic : ConcurrentDictionary[str, int] = ConcurrentDictionary()
+    dic["x"] = 0
     def worker():
         for _ in range(10000):
-            old = D['x']
+            old = dic['x']
             time.sleep(0.00001)
             # D.__setitem__('x', old + 1)
-            D.update_atomic("x", lambda v: v + 1)
+            dic.update_atomic("x", lambda v: v + 1)
 
     threads = [threading.Thread(target=worker) for _ in range(8)]
     for t in threads:
@@ -24,12 +26,12 @@ def worker():
         t.join()
 
     # The expected value is 8 * 10000 = 80000
-    assert D['x'] == 80000, f"ConcurrentDictionary should be thread-safe, got {D['x']}"
+    assert dic['x'] == 80000, f"ConcurrentDictionary should be thread-safe, got {dic['x']}"
 
 
 def test_concurrentdictionary_setdefault_thread_safe():
-    D = ConcurrentDictionary()
-    errors = []
+    D : ConcurrentDictionary[str,int] = ConcurrentDictionary()
+    errors : list[Exception] = []
 
     def worker():
         for _ in range(10000):
@@ -49,8 +51,8 @@ def worker():
 
 
 def test_concurrentdictionary_pop_thread_safe():
-    D = ConcurrentDictionary({'x': 0})
-    errors = []
+    D : ConcurrentDictionary[str,int] = ConcurrentDictionary({'x': 0})
+    errors : list[Exception] = []
 
     def worker():
         for _ in range(1000):
@@ -71,8 +73,8 @@ def worker():
 
 
 def test_concurrentdictionary_clear_thread_safe():
-    D = ConcurrentDictionary({i: i for i in range(100)})
-    errors = []
+    D : ConcurrentDictionary[str,int] = ConcurrentDictionary({i: i for i in range(100)})
+    errors : list[Exception] = []
 
     def worker():
         for _ in range(100):
@@ -90,23 +92,7 @@ def worker():
 
     # No thread safety errors should occur
     assert not errors, f"Thread safety errors occurred: {errors}"
+      
 
-
 if __name__ == "__main__":
-    import types
-
-    # Collect all functions in globals() that start with 'test_' and are functions
-    test_functions = [
-        func for name, func in globals().items()
-        if name.startswith("test_") and isinstance(func, types.FunctionType)
-    ]
-    failed = 0
-    for func in test_functions:
-        try:
-            print(f"Running {func.__name__} ...")
-            func()
-        except Exception as e:
-            failed += 1
-            print(f"***\nFAILED: {func.__name__}: {e}\n***")
-
-    print(f"\n{len(test_functions) - failed} passed, {failed} failed.")
+    pytest.main([__file__])