provide-foundation 0.0.0.dev2__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

provide/foundation/testing/threading/execution_fixtures.py

@@ -5,10 +5,10 @@ Advanced fixtures for concurrent execution, synchronization testing, deadlock de
 and exception handling in threaded code.
 """
 
+from concurrent.futures import ThreadPoolExecutor
 import threading
 import time
 from typing import Any, Callable, Optional
-from concurrent.futures import ThreadPoolExecutor
 
 import pytest
 
@@ -17,24 +17,27 @@ import pytest
 def concurrent_executor():
     """
     Helper for executing functions concurrently in tests.
-    
+
     Returns:
         Concurrent execution helper.
     """
+
     class ConcurrentExecutor:
         def __init__(self):
             self.results = []
             self.exceptions = []
-        
-        def run_concurrent(self, func: Callable, args_list: list[tuple], max_workers: int = 4) -> list[Any]:
+
+        def run_concurrent(
+            self, func: Callable, args_list: list[tuple], max_workers: int = 4
+        ) -> list[Any]:
             """
             Run function concurrently with different arguments.
-            
+
             Args:
                 func: Function to execute
                 args_list: List of argument tuples
                 max_workers: Maximum concurrent workers
-                
+
             Returns:
                 List of results in order
             """
@@ -46,7 +49,7 @@ def concurrent_executor():
                     else:
                         future = executor.submit(func, args)
                     futures.append(future)
-                
+
                 results = []
                 for future in futures:
                     try:
@@ -56,24 +59,24 @@ def concurrent_executor():
                     except Exception as e:
                         self.exceptions.append(e)
                         results.append(None)
-                
+
                 return results
-        
+
         def run_parallel(self, funcs: list[Callable], timeout: float = 10) -> list[Any]:
             """
             Run different functions in parallel.
-            
+
             Args:
                 funcs: List of functions to execute
                 timeout: Timeout for each function
-                
+
             Returns:
                 List of results
             """
             with ThreadPoolExecutor(max_workers=len(funcs)) as executor:
                 futures = [executor.submit(func) for func in funcs]
                 results = []
-                
+
                 for future in futures:
                     try:
                         result = future.result(timeout=timeout)
@@ -81,9 +84,9 @@ def concurrent_executor():
                     except Exception as e:
                         self.exceptions.append(e)
                         results.append(None)
-                
+
                 return results
-    
+
     return ConcurrentExecutor()
 
 
@@ -91,18 +94,19 @@ def concurrent_executor():
 def thread_synchronizer():
     """
     Helper for synchronizing test threads.
-    
+
     Returns:
         Thread synchronization helper.
     """
+
     class ThreadSynchronizer:
         def __init__(self):
             self.checkpoints = {}
-        
+
         def checkpoint(self, name: str, thread_id: Optional[int] = None):
             """
             Record that a thread reached a checkpoint.
-            
+
             Args:
                 name: Checkpoint name
                 thread_id: Optional thread ID (uses current if None)
@@ -111,16 +115,18 @@ def thread_synchronizer():
             if name not in self.checkpoints:
                 self.checkpoints[name] = []
             self.checkpoints[name].append((thread_id, time.time()))
-        
-        def wait_for_checkpoint(self, name: str, count: int, timeout: float = 5.0) -> bool:
+
+        def wait_for_checkpoint(
+            self, name: str, count: int, timeout: float = 5.0
+        ) -> bool:
             """
             Wait for N threads to reach a checkpoint.
-            
+
             Args:
                 name: Checkpoint name
                 count: Number of threads to wait for
                 timeout: Maximum wait time
-                
+
             Returns:
                 True if checkpoint reached, False if timeout
             """
@@ -130,25 +136,28 @@ def thread_synchronizer():
                     return True
                 time.sleep(0.01)
             return False
-        
+
         def get_order(self, checkpoint: str) -> list[int]:
             """
             Get order in which threads reached checkpoint.
-            
+
             Args:
                 checkpoint: Checkpoint name
-                
+
             Returns:
                 List of thread IDs in order
             """
             if checkpoint not in self.checkpoints:
                 return []
-            return [tid for tid, _ in sorted(self.checkpoints[checkpoint], key=lambda x: x[1])]
-        
+            return [
+                tid
+                for tid, _ in sorted(self.checkpoints[checkpoint], key=lambda x: x[1])
+            ]
+
         def clear(self):
             """Clear all checkpoints."""
             self.checkpoints.clear()
-    
+
     return ThreadSynchronizer()
 
 
@@ -156,15 +165,16 @@ def thread_synchronizer():
 def deadlock_detector():
     """
     Helper for detecting potential deadlocks in tests.
-    
+
     Returns:
         Deadlock detection helper.
     """
+
     class DeadlockDetector:
         def __init__(self):
             self.locks_held = {}  # thread_id -> set of locks
             self.lock = threading.Lock()
-        
+
         def acquire(self, lock_name: str, thread_id: Optional[int] = None):
             """Record lock acquisition."""
             thread_id = thread_id or threading.get_ident()
@@ -172,18 +182,18 @@ def deadlock_detector():
                 if thread_id not in self.locks_held:
                     self.locks_held[thread_id] = set()
                 self.locks_held[thread_id].add(lock_name)
-        
+
         def release(self, lock_name: str, thread_id: Optional[int] = None):
             """Record lock release."""
             thread_id = thread_id or threading.get_ident()
             with self.lock:
                 if thread_id in self.locks_held:
                     self.locks_held[thread_id].discard(lock_name)
-        
+
         def check_circular_wait(self) -> bool:
             """
             Check for potential circular wait conditions.
-            
+
             Returns:
                 True if potential deadlock detected
             """
@@ -191,16 +201,15 @@ def deadlock_detector():
             with self.lock:
                 # Check if multiple threads hold multiple locks
                 multi_lock_threads = [
-                    tid for tid, locks in self.locks_held.items()
-                    if len(locks) > 1
+                    tid for tid, locks in self.locks_held.items() if len(locks) > 1
                 ]
                 return len(multi_lock_threads) > 1
-        
+
         def get_held_locks(self) -> dict[int, set[str]]:
             """Get current lock holdings."""
             with self.lock:
                 return self.locks_held.copy()
-    
+
     return DeadlockDetector()
 
 
@@ -208,56 +217,62 @@ def deadlock_detector():
 def thread_exception_handler():
     """
     Capture exceptions from threads for testing.
-    
+
     Returns:
         Exception handler for threads.
     """
+
     class ThreadExceptionHandler:
         def __init__(self):
             self.exceptions = []
             self.lock = threading.Lock()
-        
+
         def handle(self, func: Callable) -> Callable:
             """
             Wrap function to capture exceptions.
-            
+
             Args:
                 func: Function to wrap
-                
+
             Returns:
                 Wrapped function
             """
+
             def wrapper(*args, **kwargs):
                 try:
                     return func(*args, **kwargs)
                 except Exception as e:
                     with self.lock:
-                        self.exceptions.append({
-                            'thread': threading.current_thread().name,
-                            'exception': e,
-                            'time': time.time()
-                        })
+                        self.exceptions.append(
+                            {
+                                "thread": threading.current_thread().name,
+                                "exception": e,
+                                "time": time.time(),
+                            }
+                        )
                     raise
-            
+
             return wrapper
-        
+
         def get_exceptions(self) -> list[dict]:
             """Get all captured exceptions."""
             with self.lock:
                 return self.exceptions.copy()
-        
+
         def assert_no_exceptions(self):
             """Assert no exceptions were raised."""
             with self.lock:
                 if self.exceptions:
-                    raise AssertionError(f"Thread exceptions occurred: {self.exceptions}")
-    
+                    raise AssertionError(
+                        f"Thread exceptions occurred: {self.exceptions}"
+                    )
+
     return ThreadExceptionHandler()
 
 
 __all__ = [
     "concurrent_executor",
-    "thread_synchronizer",
     "deadlock_detector",
     "thread_exception_handler",
-]
+    "thread_synchronizer",
+]

provide/foundation/testing/threading/fixtures.py

@@ -8,30 +8,26 @@ and concurrent operations across the provide-io ecosystem.
 
 # Re-export all fixtures from specialized modules
 from provide.foundation.testing.threading.basic_fixtures import (
-    test_thread,
-    thread_pool,
     mock_thread,
+    test_thread,
     thread_local_storage,
+    thread_pool,
 )
-
-from provide.foundation.testing.threading.sync_fixtures import (
-    thread_barrier,
-    thread_event,
-    thread_condition,
-)
-
 from provide.foundation.testing.threading.data_fixtures import (
-    thread_safe_list,
     thread_safe_counter,
+    thread_safe_list,
 )
-
 from provide.foundation.testing.threading.execution_fixtures import (
     concurrent_executor,
-    thread_synchronizer,
     deadlock_detector,
     thread_exception_handler,
+    thread_synchronizer,
+)
+from provide.foundation.testing.threading.sync_fixtures import (
+    thread_barrier,
+    thread_condition,
+    thread_event,
 )
-
 
 __all__ = [
     # Basic threading fixtures
@@ -51,4 +47,4 @@ __all__ = [
     "thread_synchronizer",
     "deadlock_detector",
     "thread_exception_handler",
-]
+]

provide/foundation/testing/threading/sync_fixtures.py

@@ -13,29 +13,31 @@ import pytest
 def thread_barrier():
     """
     Create a barrier for thread synchronization.
-    
+
     Returns:
         Function to create barriers for N threads.
     """
     barriers = []
-    
-    def _create_barrier(n_threads: int, timeout: float | None = None) -> threading.Barrier:
+
+    def _create_barrier(
+        n_threads: int, timeout: float | None = None
+    ) -> threading.Barrier:
         """
         Create a barrier for synchronizing threads.
-        
+
         Args:
             n_threads: Number of threads to synchronize
             timeout: Optional timeout for barrier
-            
+
         Returns:
             Barrier instance
         """
         barrier = threading.Barrier(n_threads, timeout=timeout)
         barriers.append(barrier)
         return barrier
-    
+
     yield _create_barrier
-    
+
     # Cleanup: abort all barriers
     for barrier in barriers:
         try:
@@ -48,20 +50,20 @@ def thread_barrier():
 def thread_event():
     """
     Create thread events for signaling.
-    
+
     Returns:
         Function to create thread events.
     """
     events = []
-    
+
     def _create_event() -> threading.Event:
         """Create a thread event."""
         event = threading.Event()
         events.append(event)
         return event
-    
+
     yield _create_event
-    
+
     # Cleanup: set all events to release waiting threads
     for event in events:
         event.set()
@@ -71,27 +73,28 @@ def thread_event():
 def thread_condition():
     """
     Create condition variables for thread coordination.
-    
+
     Returns:
         Function to create condition variables.
     """
-    def _create_condition(lock: Optional[threading.Lock] = None) -> threading.Condition:
+
+    def _create_condition(lock: threading.Lock | None = None) -> threading.Condition:
         """
         Create a condition variable.
-        
+
         Args:
             lock: Optional lock to use (creates new if None)
-            
+
         Returns:
             Condition variable
         """
         return threading.Condition(lock)
-    
+
     return _create_condition
 
 
 __all__ = [
     "thread_barrier",
-    "thread_event", 
     "thread_condition",
-]
+    "thread_event",
+]

provide/foundation/testing/time/__init__.py

@@ -6,27 +6,27 @@ time-dependent code across any project that depends on provide.foundation.
 """
 
 from provide.foundation.testing.time.fixtures import (
+    advance_time,
+    benchmark_timer,
     freeze_time,
+    mock_datetime,
     mock_sleep,
     mock_sleep_with_callback,
+    rate_limiter_mock,
     time_machine,
-    timer,
-    mock_datetime,
     time_travel,
-    rate_limiter_mock,
-    benchmark_timer,
-    advance_time,
+    timer,
 )
 
 __all__ = [
+    "advance_time",
+    "benchmark_timer",
     "freeze_time",
+    "mock_datetime",
     "mock_sleep",
     "mock_sleep_with_callback",
+    "rate_limiter_mock",
     "time_machine",
-    "timer",
-    "mock_datetime",
     "time_travel",
-    "rate_limiter_mock",
-    "benchmark_timer",
-    "advance_time",
-]
+    "timer",
+]