rwlocker 3.0__tar.gz → 3.2__tar.gz

{rwlocker-3.0/rwlocker.egg-info → rwlocker-3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rwlocker
-Version: 3.0
+Version: 3.2
 Summary: Advanced, High-Performance, and State-Machine Based Synchronous/Asynchronous Read-Write Locks.
 Author-email: TahsinCr <TahsinCrs@gmail.com>
 License: MIT
@@ -112,29 +112,33 @@ If you use the lock objects directly like a standard lock without specifying the
 
 ## 📊 Performance and Benchmark Results
 
-`rwlocker` unlocks the system's true potential during Network and Database I/O operations where Python's GIL (Global Interpreter Lock) is released. In aggressive scenario tests conducted with zero OS sleep interference, it overwhelmingly outperformed standard locks.
+The performance results demonstrate `rwlocker`'s true potential during Network and Database I/O operations where Python's GIL (Global Interpreter Lock) is released or context-switched. 
 
-**Summary of Performance Outputs:**
+**🖥️ Test Environment:** All tests were executed on an **Intel Core i7-12700H (2.4GHz)** processor running **EndeavourOS (Arch-based Linux)**, using **Python 3.14.3** and the experimental **Free-Threading (3.14.3t)** interpreters.
 
-* **🚀 Read-Heavy Scenario (100 Readers, 2 Writers):**
-While standard locks queue readers single-file and choke the system, `rwlocker` allows readers to access the data simultaneously. This achieves **~37x FASTER** speed and throughput in **Threading** and **~30x FASTER** in **Asyncio**.
-* **⚖️ Balanced Scenario (50 Readers, 50 Writers):**
-Thanks to the Fair state machine, read operations are squeezed in parallel between write queues. It increases performance by **2x** compared to standard locks without creating a system bottleneck.
-* **🛡️ Write-Heavy Scenario (2 Readers, 100 Writers):**
-Even though write operations inherently cannot be executed concurrently (in parallel), thanks to `rwlocker`'s zero-allocation smart proxy architecture, it runs **7-8% faster** than standard `C`-based locks. Even the O(1) cost "ReentrantWriter" (reentrancy) feature adds almost no overhead to performance.
+**🧪 Methodology:** To ensure absolute precision and zero margin of error, all reader and writer entities (threads or async tasks) are spawned in advance and held at a starting line using a synchronization `Event`. Once the event triggers, they execute simultaneously. The workloads strictly follow an `IOBoundScenario` that enforces a precise `time.sleep(0.001)` or `asyncio.sleep(0.001)` delay to accurately simulate real network/database I/O latency.
 
-**Condition Variable Performance Outputs:**
+### 1. Read-Write Lock (RWLock) Benchmarks
 
-Standard library Condition structures lock up the CPU during multiple wake-ups due to O(N) scanning. `rwlocker`'s O(1) queue architecture absolutely crushes the standard library at this point.
+Standard locks force threads to queue single-file even if they are only reading data. `rwlocker` unleashes concurrent read access.
 
-* **📣 Massive Broadcast (1 Writer, 100 Readers):**
-When a single writer updates the database and wakes up hundreds of waiting readers (`notify_all`); thanks to our O(1) architecture, **~65x FASTER** throughput (Ops/sec) is achieved in **Threading**, and **~70x FASTER** in **Asyncio**. The system is saved from entering a "Cache Stampede".
-* **🔀 Balanced Pub/Sub (50 Writers, 50 Readers):**
-In mixed waiting and waking scenarios, our Condition locks with the `Write-Pref` strategy ran **~2x FASTER** than the standard library.
-* **📉 Write-Heavy Limit (Stress Test - 100 Writers, 2 Readers):**
-In this brutal scenario where writers constantly block each other and call `notify()`, C-based standard locks utilize their raw speed advantage. `rwlocker`'s Write-Pref model holds its ground neck-and-neck (1.0x) with the standard lock, while the Fair and Read-Pref models intentionally slow down (0.5x - 0.7x) for the sake of maintaining fairness.
+**Synchronous (Thread) RWLock Performance:**
+In the Read-Heavy scenario, standard C-based locks choke the system, whereas `rwlocker` achieves up to **~35x speedup**. Even in Write-Heavy workloads where parallelism isn't inherently possible, `rwlocker` matches or slightly outperforms the C-baseline thanks to its zero-allocation fast-paths.
 
-*(Note: All lock, adapter, and condition classes have passed a massive suite of **266 different unit tests** covering reentrancy, deadlock, timeout, OS interrupts, O(N) leaks, and cancellation safety scenarios with 0 errors, and this entire test suite was completed in just **8.5 seconds**.)*
+**Asynchronous (Asyncio) RWLock Performance:**
+`rwlocker` achieves **~30x faster throughput** by allowing thousands of reader tasks to await I/O simultaneously without blocking one another.
+
+### 2. Condition Variable (RWCondition) Benchmarks
+
+Standard `Condition` variables iterate through all sleeping threads/tasks one by one `O(N)` during a broadcast (`notify_all`), causing massive CPU spikes and "Cache Stampedes". `rwlocker` completely eradicates this with its pure `O(1)` queueing architecture.
+
+**Synchronous (Thread) RWCondition Performance:**
+When 100 sleeping readers are awakened simultaneously, `rwlocker` processes them instantly without locking the OS. This architectural leap results in a mind-blowing **~45x speedup** compared to the standard library's `threading.Condition`.
+
+**Asynchronous (Asyncio) RWCondition Performance:**
+In event-driven caching systems, waking up hundreds of waiting web requests simultaneously is a major bottleneck. The `AsyncRWCondition` completely bypasses standard asyncio constraints, reaching up to **~45x higher throughput** during massive broadcast scenarios, completely saving the loop from freezing.
+
+*(Note: All lock, adapter, and condition classes have passed a massive suite of **315 different unit tests** covering reentrancy, deadlock, timeout, OS interrupts, O(N) leaks, and cancellation safety scenarios with 0 errors, and this entire test suite was completed in just **13.2 seconds**.)*
 
 
 <br/>
@@ -469,7 +473,7 @@ Email: TahsinCrs@gmail.com
 
 [issues-url]: https://github.com/TahsinCr/python-rwlocker/issues
 
-[examples-url]: https://github.com/TahsinCr/python-rwlocker/wiki
+[examples-url]: https://github.com/TahsinCr/python-rwlocker/tree/main/examples
 
 [license-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/LICENSE
 
@@ -482,11 +486,3 @@ Email: TahsinCrs@gmail.com
 [linkedin-url]: https://linkedin.com/in/TahsinCr
 
 [x-url]: https://twitter.com/TahsinCrs
-
-
-
-<!-- File URL -->
-
-[lang-tr-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README_TR.md
-
-[lang-en-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README.md

{rwlocker-3.0 → rwlocker-3.2}/README-pypi.md

@@ -83,29 +83,33 @@ If you use the lock objects directly like a standard lock without specifying the
 
 ## 📊 Performance and Benchmark Results
 
-`rwlocker` unlocks the system's true potential during Network and Database I/O operations where Python's GIL (Global Interpreter Lock) is released. In aggressive scenario tests conducted with zero OS sleep interference, it overwhelmingly outperformed standard locks.
+The performance results demonstrate `rwlocker`'s true potential during Network and Database I/O operations where Python's GIL (Global Interpreter Lock) is released or context-switched. 
 
-**Summary of Performance Outputs:**
+**🖥️ Test Environment:** All tests were executed on an **Intel Core i7-12700H (2.4GHz)** processor running **EndeavourOS (Arch-based Linux)**, using **Python 3.14.3** and the experimental **Free-Threading (3.14.3t)** interpreters.
 
-* **🚀 Read-Heavy Scenario (100 Readers, 2 Writers):**
-While standard locks queue readers single-file and choke the system, `rwlocker` allows readers to access the data simultaneously. This achieves **~37x FASTER** speed and throughput in **Threading** and **~30x FASTER** in **Asyncio**.
-* **⚖️ Balanced Scenario (50 Readers, 50 Writers):**
-Thanks to the Fair state machine, read operations are squeezed in parallel between write queues. It increases performance by **2x** compared to standard locks without creating a system bottleneck.
-* **🛡️ Write-Heavy Scenario (2 Readers, 100 Writers):**
-Even though write operations inherently cannot be executed concurrently (in parallel), thanks to `rwlocker`'s zero-allocation smart proxy architecture, it runs **7-8% faster** than standard `C`-based locks. Even the O(1) cost "ReentrantWriter" (reentrancy) feature adds almost no overhead to performance.
+**🧪 Methodology:** To ensure absolute precision and zero margin of error, all reader and writer entities (threads or async tasks) are spawned in advance and held at a starting line using a synchronization `Event`. Once the event triggers, they execute simultaneously. The workloads strictly follow an `IOBoundScenario` that enforces a precise `time.sleep(0.001)` or `asyncio.sleep(0.001)` delay to accurately simulate real network/database I/O latency.
 
-**Condition Variable Performance Outputs:**
+### 1. Read-Write Lock (RWLock) Benchmarks
 
-Standard library Condition structures lock up the CPU during multiple wake-ups due to O(N) scanning. `rwlocker`'s O(1) queue architecture absolutely crushes the standard library at this point.
+Standard locks force threads to queue single-file even if they are only reading data. `rwlocker` unleashes concurrent read access.
 
-* **📣 Massive Broadcast (1 Writer, 100 Readers):**
-When a single writer updates the database and wakes up hundreds of waiting readers (`notify_all`); thanks to our O(1) architecture, **~65x FASTER** throughput (Ops/sec) is achieved in **Threading**, and **~70x FASTER** in **Asyncio**. The system is saved from entering a "Cache Stampede".
-* **🔀 Balanced Pub/Sub (50 Writers, 50 Readers):**
-In mixed waiting and waking scenarios, our Condition locks with the `Write-Pref` strategy ran **~2x FASTER** than the standard library.
-* **📉 Write-Heavy Limit (Stress Test - 100 Writers, 2 Readers):**
-In this brutal scenario where writers constantly block each other and call `notify()`, C-based standard locks utilize their raw speed advantage. `rwlocker`'s Write-Pref model holds its ground neck-and-neck (1.0x) with the standard lock, while the Fair and Read-Pref models intentionally slow down (0.5x - 0.7x) for the sake of maintaining fairness.
+**Synchronous (Thread) RWLock Performance:**
+In the Read-Heavy scenario, standard C-based locks choke the system, whereas `rwlocker` achieves up to **~35x speedup**. Even in Write-Heavy workloads where parallelism isn't inherently possible, `rwlocker` matches or slightly outperforms the C-baseline thanks to its zero-allocation fast-paths.
 
-*(Note: All lock, adapter, and condition classes have passed a massive suite of **266 different unit tests** covering reentrancy, deadlock, timeout, OS interrupts, O(N) leaks, and cancellation safety scenarios with 0 errors, and this entire test suite was completed in just **8.5 seconds**.)*
+**Asynchronous (Asyncio) RWLock Performance:**
+`rwlocker` achieves **~30x faster throughput** by allowing thousands of reader tasks to await I/O simultaneously without blocking one another.
+
+### 2. Condition Variable (RWCondition) Benchmarks
+
+Standard `Condition` variables iterate through all sleeping threads/tasks one by one `O(N)` during a broadcast (`notify_all`), causing massive CPU spikes and "Cache Stampedes". `rwlocker` completely eradicates this with its pure `O(1)` queueing architecture.
+
+**Synchronous (Thread) RWCondition Performance:**
+When 100 sleeping readers are awakened simultaneously, `rwlocker` processes them instantly without locking the OS. This architectural leap results in a mind-blowing **~45x speedup** compared to the standard library's `threading.Condition`.
+
+**Asynchronous (Asyncio) RWCondition Performance:**
+In event-driven caching systems, waking up hundreds of waiting web requests simultaneously is a major bottleneck. The `AsyncRWCondition` completely bypasses standard asyncio constraints, reaching up to **~45x higher throughput** during massive broadcast scenarios, completely saving the loop from freezing.
+
+*(Note: All lock, adapter, and condition classes have passed a massive suite of **315 different unit tests** covering reentrancy, deadlock, timeout, OS interrupts, O(N) leaks, and cancellation safety scenarios with 0 errors, and this entire test suite was completed in just **13.2 seconds**.)*
 
 
 <br/>
@@ -440,7 +444,7 @@ Email: TahsinCrs@gmail.com
 
 [issues-url]: https://github.com/TahsinCr/python-rwlocker/issues
 
-[examples-url]: https://github.com/TahsinCr/python-rwlocker/wiki
+[examples-url]: https://github.com/TahsinCr/python-rwlocker/tree/main/examples
 
 [license-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/LICENSE
 
@@ -453,11 +457,3 @@ Email: TahsinCrs@gmail.com
 [linkedin-url]: https://linkedin.com/in/TahsinCr
 
 [x-url]: https://twitter.com/TahsinCrs
-
-
-
-<!-- File URL -->
-
-[lang-tr-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README_TR.md
-
-[lang-en-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README.md

{rwlocker-3.0 → rwlocker-3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rwlocker"
-version = "3.0"
+version = "3.2"
 description = "Advanced, High-Performance, and State-Machine Based Synchronous/Asynchronous Read-Write Locks."
 readme = {file = "README-pypi.md", content-type = "text/markdown"}
 license = {text = "MIT"}

{rwlocker-3.0 → rwlocker-3.2}/rwlocker/__init__.py

@@ -64,4 +64,4 @@ Basic Example:
 from .thread_rwlock import *
 from .async_rwlock import *
 
-__version__ = '3.0'
+__version__ = '3.2'

{rwlocker-3.0 → rwlocker-3.2}/rwlocker/async_rwlock.py

@@ -37,8 +37,9 @@ from collections import deque
 from abc import ABC, abstractmethod
 from typing import Callable, Protocol, Optional
 from types import TracebackType
+import weakref
 
-__version__ = '3.0'
+__version__ = '3.2'
 __all__ = (
     'AsyncLockable', 'AsyncLockDowngradable', 'AsyncRWLockBase', 'AsyncRWLockWithProxyBase', 
     'AsyncRWLockProxy', 'AsyncRWLockReaderProxy', 'AsyncRWLockWriterProxy',
@@ -180,6 +181,7 @@ class _AsyncWaitQueue:
         for fut in waiters:
             if not fut.done():
                 fut.set_result(True)
+        waiters.clear()
 
 class AsyncRWLockProxy:
     """
@@ -277,7 +279,7 @@ class AsyncRWLockWriterProxy(AsyncRWLockProxy):
         )
         self._read_lock = rwlock.read
         self._downgrade_core = rwlock._downgrade_core
-        self._downgraded_tasks:set[asyncio.Task] = set()
+        self._downgraded_tasks:weakref.WeakSet[asyncio.Task] = weakref.WeakSet()
             
     def downgrade(self):
         """
@@ -299,11 +301,12 @@ class AsyncRWLockWriterProxy(AsyncRWLockProxy):
         the release logic to the reader core, avoiding Deadlocks and RuntimeErrors.
         """
         if self._downgraded_tasks: 
-            task = asyncio.current_task()
-            if task in self._downgraded_tasks:
-                self._downgraded_tasks.remove(task)
+            try:
+                self._downgraded_tasks.remove(asyncio.current_task())
                 self._read_lock._release_core()
                 return
+            except KeyError:
+                pass
         self._release_core()
 
 # Read and Write Lock
@@ -344,17 +347,17 @@ class AsyncRWLockWrite(AsyncRWLockWithProxyBase):
         self._writer_active = False
         self._readers_active = 0
 
-    def _can_read(self) -> bool:
+    def _can_read(self) -> bool: 
         return not self._writer_active and self.write.those_waiting == 0
     
-    def _acquire_read_core(self):
+    def _acquire_read_core(self): 
         self._readers_active += 1
 
     def _release_read_core(self):
-        if self._readers_active == 0:
+        if self._readers_active == 0: 
             raise RuntimeError("Unacquired read lock")
         self._readers_active -= 1
-        if self._readers_active == 0:
+        if self._readers_active == 0: 
             self.write.condition.notify()
 
     def _on_reader_abort(self):
@@ -365,7 +368,7 @@ class AsyncRWLockWrite(AsyncRWLockWithProxyBase):
     
     def _acquire_write_core(self): 
         self._writer_active = True
-        
+
     def _release_write_core(self):
         if not self._writer_active: 
             raise RuntimeError("Unacquired write lock")
@@ -390,7 +393,7 @@ class AsyncRWLockWrite(AsyncRWLockWithProxyBase):
     
     def _is_read_locked(self) -> bool:
         return self._readers_active > 0
-
+        
 class AsyncRWLockWriteReentrantWriter(AsyncRWLockWrite):
     """
     Write-preferring Asynchronous Read-Write Lock with Task-Reentrancy.
@@ -434,36 +437,47 @@ class AsyncRWLockWriteReentrantWriter(AsyncRWLockWrite):
         self._writer_id: Optional[asyncio.Task] = None
         self._write_count: int = 0
 
+    def _is_current_writer(self) -> bool:
+        return self._writer_id is asyncio.current_task()
+        
+    def _set_current_writer(self) -> None:
+        self._writer_id = asyncio.current_task()
+        
+    def _clear_current_writer(self) -> None:
+        self._writer_id = None
+
     def _can_read(self) -> bool:
-        if self._writer_id is asyncio.current_task(): 
-            return True
-        return self._writer_id is None and self.write.those_waiting == 0
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self.write.those_waiting == 0
 
     def _can_write(self) -> bool:
-        return (self._writer_id is None and self._readers_active == 0) or self._writer_id is asyncio.current_task()
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self._readers_active == 0
     
     def _acquire_write_core(self):
-        self._writer_id = asyncio.current_task()
+        self._set_current_writer()
         self._write_count += 1
 
     def _release_write_core(self):
-        if self._writer_id is not asyncio.current_task():
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         self._write_count -= 1
         if self._write_count == 0:
-            self._writer_id = None
+            self._clear_current_writer()
             self._on_writer_abort()
 
     def _downgrade_core(self):
-        if self._writer_id is not asyncio.current_task():
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         if self._write_count > 1:
-            raise RuntimeError("Cannot downgrade a nested write lock.")
-        self._writer_id = None
+            raise RuntimeError("Cannot downgrade a nested write lock. Release inner locks first.")
+        self._clear_current_writer()
         self._write_count = 0
         self._readers_active += 1
         self.read.condition.notify_all()
-
+        
     def _is_write_locked(self) -> bool: 
         return self._writer_id is not None
 
@@ -504,43 +518,44 @@ class AsyncRWLockRead(AsyncRWLockWithProxyBase):
         self._writer_active = False
         self._readers_active = 0
 
-    def _can_read(self) -> bool:
+    def _can_read(self) -> bool: 
         return not self._writer_active
     
-    def _acquire_read_core(self):
+    def _acquire_read_core(self): 
         self._readers_active += 1
 
     def _release_read_core(self):
-        if self._readers_active == 0:
+        if self._readers_active == 0: 
             raise RuntimeError("Unacquired read lock")
         self._readers_active -= 1
-        if self._readers_active == 0:
+        if self._readers_active == 0: 
             self.write.condition.notify()
 
     def _on_reader_abort(self):
-        if self.read.those_waiting == 0 and self._readers_active == 0:
+        if self.read.those_waiting == 0 and self._readers_active == 0: 
             self.write.condition.notify()
 
     def _can_write(self) -> bool: 
         return not self._writer_active and self._readers_active == 0 and self.read.those_waiting == 0
     
-    def _acquire_write_core(self):
+    def _acquire_write_core(self): 
         self._writer_active = True
 
     def _release_write_core(self):
-        if not self._writer_active:
+        if not self._writer_active: 
             raise RuntimeError("Unacquired write lock")
         self._writer_active = False
         self._on_writer_abort()
+
     def _downgrade_core(self):
-        if not self._writer_active:
+        if not self._writer_active: 
             raise RuntimeError("Cannot downgrade unlocked lock")
         self._writer_active = False
         self._readers_active += 1
         self.read.condition.notify_all()
 
     def _on_writer_abort(self):
-        if self.read.those_waiting > 0:
+        if self.read.those_waiting > 0: 
             self.read.condition.notify_all()
         else: 
             self.write.condition.notify()
@@ -550,7 +565,7 @@ class AsyncRWLockRead(AsyncRWLockWithProxyBase):
     
     def _is_read_locked(self) -> bool:
         return self._readers_active > 0
-
+        
 class AsyncRWLockReadReentrantWriter(AsyncRWLockRead):
     """
     Read-preferring Asynchronous Read-Write Lock with Task-Reentrancy.
@@ -592,32 +607,43 @@ class AsyncRWLockReadReentrantWriter(AsyncRWLockRead):
         self._writer_id: Optional[asyncio.Task] = None
         self._write_count: int = 0
 
+    def _is_current_writer(self) -> bool:
+        return self._writer_id is asyncio.current_task()
+        
+    def _set_current_writer(self) -> None:
+        self._writer_id = asyncio.current_task()
+        
+    def _clear_current_writer(self) -> None:
+        self._writer_id = None
+
     def _can_read(self) -> bool:
-        if self._writer_id is asyncio.current_task():
-            return True
-        return self._writer_id is None
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return True
 
     def _can_write(self) -> bool:
-        return (self._writer_id is None and self._readers_active == 0 and self.read.those_waiting == 0) or self._writer_id is asyncio.current_task()
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self._readers_active == 0 and self.read.those_waiting == 0
     
     def _acquire_write_core(self):
-        self._writer_id = asyncio.current_task()
+        self._set_current_writer()
         self._write_count += 1
 
     def _release_write_core(self):
-        if self._writer_id is not asyncio.current_task():
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         self._write_count -= 1
         if self._write_count == 0:
-            self._writer_id = None
+            self._clear_current_writer()
             self._on_writer_abort()
 
     def _downgrade_core(self):
-        if self._writer_id is not asyncio.current_task():
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         if self._write_count > 1:
-            raise RuntimeError("Cannot downgrade a nested write lock.")
-        self._writer_id = None
+            raise RuntimeError("Cannot downgrade a nested write lock. Release inner locks first.")
+        self._clear_current_writer()
         self._write_count = 0
         self._readers_active += 1
         self.read.condition.notify_all()
@@ -668,11 +694,11 @@ class AsyncRWLockFair(AsyncRWLockWithProxyBase):
             return False
         return self._readers_turn or self.write.those_waiting == 0
     
-    def _acquire_read_core(self):
+    def _acquire_read_core(self): 
         self._readers_active += 1
 
     def _release_read_core(self):
-        if self._readers_active == 0:
+        if self._readers_active == 0: 
             raise RuntimeError("Unacquired read lock")
         self._readers_active -= 1
         if self._readers_active == 0:
@@ -685,9 +711,9 @@ class AsyncRWLockFair(AsyncRWLockWithProxyBase):
             self.write.condition.notify()
 
     def _can_write(self) -> bool:
-        if self._writer_active or self._readers_active > 0:
+        if self._writer_active or self._readers_active > 0: 
             return False
-        if self._readers_turn and self.read.those_waiting > 0:
+        if self._readers_turn and self.read.those_waiting > 0: 
             return False
         return True
     
@@ -695,13 +721,13 @@ class AsyncRWLockFair(AsyncRWLockWithProxyBase):
         self._writer_active = True
 
     def _release_write_core(self):
-        if not self._writer_active:
+        if not self._writer_active: 
             raise RuntimeError("Unacquired write lock")
         self._writer_active = False
         self._on_writer_abort()
 
     def _downgrade_core(self):
-        if not self._writer_active:
+        if not self._writer_active: 
             raise RuntimeError("Cannot downgrade unlocked lock")
         self._writer_active = False
         self._readers_active += 1
@@ -712,7 +738,7 @@ class AsyncRWLockFair(AsyncRWLockWithProxyBase):
         if self.read.those_waiting > 0:
             self._readers_turn = True
             self.read.condition.notify_all()
-        else:
+        else: 
             self.write.condition.notify()
 
     def _is_write_locked(self) -> bool:
@@ -720,7 +746,7 @@ class AsyncRWLockFair(AsyncRWLockWithProxyBase):
     
     def _is_read_locked(self) -> bool:
         return self._readers_active > 0
-
+        
 class AsyncRWLockFairReentrantWriter(AsyncRWLockFair):
     """
     Fair (First-In-First-Out) Asynchronous Read-Write Lock with Task-Reentrancy.
@@ -762,46 +788,57 @@ class AsyncRWLockFairReentrantWriter(AsyncRWLockFair):
         self._writer_id: Optional[asyncio.Task] = None
         self._write_count: int = 0
 
+    def _is_current_writer(self) -> bool:
+        return self._writer_id is asyncio.current_task()
+        
+    def _set_current_writer(self) -> None:
+        self._writer_id = asyncio.current_task()
+        
+    def _clear_current_writer(self) -> None:
+        self._writer_id = None
+
     def _can_read(self) -> bool:
-        if self._writer_id is asyncio.current_task():
-            return True
         if self._writer_id is not None:
+            if self._is_current_writer():
+                return True
             return False
         return self._readers_turn or self.write.those_waiting == 0
 
     def _can_write(self) -> bool:
-        if self._writer_id is asyncio.current_task():
-            return True
-        if self._writer_id is not None or self._readers_active > 0:
+        if self._writer_id is not None:
+            if self._is_current_writer():
+                return True
+            return False
+        if self._readers_active > 0:
             return False
-        if self._readers_turn and self.read.those_waiting > 0:
+        if self._readers_turn and self.read.those_waiting > 0: 
             return False
         return True
     
     def _acquire_write_core(self):
-        self._writer_id = asyncio.current_task()
+        self._set_current_writer()
         self._write_count += 1
         
     def _release_write_core(self):
-        if self._writer_id is not asyncio.current_task():
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         self._write_count -= 1
         if self._write_count == 0:
-            self._writer_id = None
+            self._clear_current_writer()
             self._on_writer_abort()
 
     def _downgrade_core(self):
-        if self._writer_id is not asyncio.current_task():
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         if self._write_count > 1:
-            raise RuntimeError("Cannot downgrade a nested write lock.")
-        self._writer_id = None
+            raise RuntimeError("Cannot downgrade a nested write lock. Release inner locks first.")
+        self._clear_current_writer()
         self._write_count = 0
         self._readers_active += 1
         self._readers_turn = True
         self.read.condition.notify_all()
 
-    def _is_write_locked(self) -> bool:
+    def _is_write_locked(self) -> bool: 
         return self._writer_id is not None
 
 # Standart Lock Adapter
@@ -861,7 +898,7 @@ class AsyncRWConditionBase(ABC):
     """
     __slots__ = ('_lock', 'read', 'write')
 
-    def __init__(self, lock: Optional[AsyncRWLockBase] = None):
+    def __init__(self, lock: Optional[AsyncLockable] = None):
         self._lock = AsyncLock() if lock is None else lock
         self.write: AsyncConditionLockable = asyncio.Condition(self._lock)
         self.read: AsyncConditionLockable = self.write
@@ -1274,7 +1311,7 @@ class AsyncCondition(AsyncRWConditionBase):
         ```
     """
     __slots__ = ()
-    def __init__(self, lock: Optional[AsyncRWLockBase] = None):
+    def __init__(self, lock: Optional[AsyncLockable] = None):
         if lock is not None and isinstance(lock, AsyncRWLockWithProxyBase):
             raise TypeError("Standard 'AsyncCondition' adapters cannot be used with proxy-based RWLocks. Use 'AsyncRWCondition' instead.")
         super().__init__(lock)

{rwlocker-3.0 → rwlocker-3.2}/rwlocker/thread_rwlock.py

@@ -37,7 +37,7 @@ from abc import ABC, abstractmethod
 from typing import Callable, Protocol, Optional
 from types import TracebackType
 
-__version__ = '3.0'
+__version__ = '3.2'
 __all__ = (
     'Lockable', 'LockDowngradable', 'RWLockBase', 'RWLockWithProxyBase',
     'RWLockProxy', 'RWLockReaderProxy', 'RWLockWriterProxy',
@@ -304,7 +304,7 @@ class RWLockWriterProxy(RWLockProxy):
     Proxy specifically handling Writer logic, extending capabilities with
     atomic state degradation (downgrading).
     """
-    __slots__ = ('_read_lock', '_downgrade_core', '_downgraded_threads')
+    __slots__ = ('_read_lock', '_downgrade_core', '_downgraded_thread_id')
     def __init__(self, rwlock: RWLockWithProxyBase):
         super().__init__(
             lock=rwlock._lock,
@@ -316,7 +316,7 @@ class RWLockWriterProxy(RWLockProxy):
         )
         self._read_lock = rwlock.read
         self._downgrade_core = rwlock._downgrade_core
-        self._downgraded_threads:set[int] = set()
+        self._downgraded_thread_id: Optional[int] = None
         
     def downgrade(self):
         """
@@ -330,7 +330,7 @@ class RWLockWriterProxy(RWLockProxy):
         """
         with self._lock:
             self._downgrade_core()
-            self._downgraded_threads.add(threading.get_ident())
+            self._downgraded_thread_id = threading.get_ident()
     
     def release(self):
         """
@@ -339,15 +339,13 @@ class RWLockWriterProxy(RWLockProxy):
         and routes the release to the reader core to prevent deadlocks.
         """
         with self._lock:
-            if self._downgraded_threads: 
-                ident = threading.get_ident()
-                if ident in self._downgraded_threads:
-                    self._downgraded_threads.remove(ident)
-                    self._read_lock._release_core()
-                    return
+            if self._downgraded_thread_id == threading.get_ident(): 
+                self._downgraded_thread_id = None
+                self._read_lock._release_core()
+                return
             self._release_core()
 
-#  Read and Write Lock
+# Read and Write Lock
 class RWLockWrite(RWLockWithProxyBase):
     """
     Write-preferring Read-Write Lock.
@@ -431,7 +429,7 @@ class RWLockWrite(RWLockWithProxyBase):
     
     def _is_read_locked(self) -> bool:
         return self._readers_active > 0
-    
+
 class RWLockWriteReentrantWriter(RWLockWrite):
     """
     Write-preferring Read-Write Lock with Write-Reentrancy support.
@@ -475,36 +473,47 @@ class RWLockWriteReentrantWriter(RWLockWrite):
         self._writer_id: Optional[int] = None
         self._write_count: int = 0
 
+    def _is_current_writer(self) -> bool:
+        return self._writer_id == threading.get_ident()
+        
+    def _set_current_writer(self) -> None:
+        self._writer_id = threading.get_ident()
+        
+    def _clear_current_writer(self) -> None:
+        self._writer_id = None
+
     def _can_read(self) -> bool:
-        if self._writer_id == threading.get_ident(): 
-            return True
-        return self._writer_id is None and self.write.those_waiting == 0
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self.write.those_waiting == 0
 
     def _can_write(self) -> bool:
-        return (self._writer_id is None and self._readers_active == 0) or self._writer_id == threading.get_ident()
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self._readers_active == 0
     
     def _acquire_write_core(self):
-        self._writer_id = threading.get_ident()
+        self._set_current_writer()
         self._write_count += 1
 
     def _release_write_core(self):
-        if self._writer_id != threading.get_ident(): 
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         self._write_count -= 1
         if self._write_count == 0:
-            self._writer_id = None
+            self._clear_current_writer()
             self._on_writer_abort()
 
     def _downgrade_core(self):
-        if self._writer_id != threading.get_ident(): 
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         if self._write_count > 1:
             raise RuntimeError("Cannot downgrade a nested write lock. Release inner locks first.")
-        self._writer_id = None
+        self._clear_current_writer()
         self._write_count = 0
         self._readers_active += 1
         self.read.condition.notify_all()
-
+        
     def _is_write_locked(self) -> bool: 
         return self._writer_id is not None
 
@@ -634,32 +643,43 @@ class RWLockReadReentrantWriter(RWLockRead):
         self._writer_id: Optional[int] = None
         self._write_count: int = 0
 
+    def _is_current_writer(self) -> bool:
+        return self._writer_id == threading.get_ident()
+        
+    def _set_current_writer(self) -> None:
+        self._writer_id = threading.get_ident()
+        
+    def _clear_current_writer(self) -> None:
+        self._writer_id = None
+
     def _can_read(self) -> bool:
-        if self._writer_id == threading.get_ident(): 
-            return True
-        return self._writer_id is None
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return True
 
     def _can_write(self) -> bool:
-        return (self._writer_id is None and self._readers_active == 0 and self.read.those_waiting == 0) or self._writer_id == threading.get_ident()
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self._readers_active == 0 and self.read.those_waiting == 0
     
     def _acquire_write_core(self):
-        self._writer_id = threading.get_ident()
+        self._set_current_writer()
         self._write_count += 1
 
     def _release_write_core(self):
-        if self._writer_id != threading.get_ident(): 
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         self._write_count -= 1
         if self._write_count == 0:
-            self._writer_id = None
+            self._clear_current_writer()
             self._on_writer_abort()
 
     def _downgrade_core(self):
-        if self._writer_id != threading.get_ident(): 
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         if self._write_count > 1:
             raise RuntimeError("Cannot downgrade a nested write lock. Release inner locks first.")
-        self._writer_id = None
+        self._clear_current_writer()
         self._write_count = 0
         self._readers_active += 1
         self.read.condition.notify_all()
@@ -762,7 +782,7 @@ class RWLockFair(RWLockWithProxyBase):
     
     def _is_read_locked(self) -> bool:
         return self._readers_active > 0
-
+        
 class RWLockFairReentrantWriter(RWLockFair):
     """
     Fair (First-In-First-Out) Read-Write Lock with Write-Reentrancy support.
@@ -804,40 +824,51 @@ class RWLockFairReentrantWriter(RWLockFair):
         self._writer_id: Optional[int] = None
         self._write_count: int = 0
 
+    def _is_current_writer(self) -> bool:
+        return self._writer_id == threading.get_ident()
+        
+    def _set_current_writer(self) -> None:
+        self._writer_id = threading.get_ident()
+        
+    def _clear_current_writer(self) -> None:
+        self._writer_id = None
+
     def _can_read(self) -> bool:
-        if self._writer_id == threading.get_ident(): 
-            return True
-        if self._writer_id is not None: 
+        if self._writer_id is not None:
+            if self._is_current_writer():
+                return True
             return False
         return self._readers_turn or self.write.those_waiting == 0
 
     def _can_write(self) -> bool:
-        if self._writer_id == threading.get_ident():
-            return True
-        if self._writer_id is not None or self._readers_active > 0: 
+        if self._writer_id is not None:
+            if self._is_current_writer():
+                return True
+            return False
+        if self._readers_active > 0:
             return False
         if self._readers_turn and self.read.those_waiting > 0: 
             return False
         return True
     
     def _acquire_write_core(self):
-        self._writer_id = threading.get_ident()
+        self._set_current_writer()
         self._write_count += 1
         
     def _release_write_core(self):
-        if self._writer_id != threading.get_ident(): 
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         self._write_count -= 1
         if self._write_count == 0:
-            self._writer_id = None
+            self._clear_current_writer()
             self._on_writer_abort()
 
     def _downgrade_core(self):
-        if self._writer_id != threading.get_ident(): 
+        if not self._is_current_writer(): 
             raise RuntimeError("Permission denied")
         if self._write_count > 1:
             raise RuntimeError("Cannot downgrade a nested write lock. Release inner locks first.")
-        self._writer_id = None
+        self._clear_current_writer()
         self._write_count = 0
         self._readers_active += 1
         self._readers_turn = True
@@ -902,7 +933,7 @@ class RWConditionBase(ABC):
     `.write` proxy. Designed to act as a common type hint and contract.
     """
     __slots__ = ('_lock', 'read', 'write')
-    def __init__(self, lock: Optional[RWLockBase] = None):
+    def __init__(self, lock: Optional[Lockable] = None):
         self._lock = Lock() if lock is None else lock
         self.write: ConditionLockable = threading.Condition(self._lock)
         self.read: ConditionLockable = self.write
@@ -1238,7 +1269,7 @@ class RWCondition(RWConditionWithProxyBase):
         self._waiters = deque()
         self._internal_lock = threading.Lock()
         super().__init__(lock)
-    
+
     def _is_owned_read(self) -> bool:
         return self._lock._is_read_locked()
 
@@ -1317,7 +1348,7 @@ class Condition(RWConditionBase):
         ```
     """
     __slots__ = ()
-    def __init__(self, lock: Optional[RWLockBase] = None):
+    def __init__(self, lock: Optional[Lockable] = None):
         if lock is not None and isinstance(lock, RWLockWithProxyBase):
             raise TypeError("Standard 'Condition' adapters cannot be used with proxy-based RWLocks. Use 'RWCondition' instead.")
         super().__init__(lock)

{rwlocker-3.0 → rwlocker-3.2/rwlocker.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rwlocker
-Version: 3.0
+Version: 3.2
 Summary: Advanced, High-Performance, and State-Machine Based Synchronous/Asynchronous Read-Write Locks.
 Author-email: TahsinCr <TahsinCrs@gmail.com>
 License: MIT
@@ -112,29 +112,33 @@ If you use the lock objects directly like a standard lock without specifying the
 
 ## 📊 Performance and Benchmark Results
 
-`rwlocker` unlocks the system's true potential during Network and Database I/O operations where Python's GIL (Global Interpreter Lock) is released. In aggressive scenario tests conducted with zero OS sleep interference, it overwhelmingly outperformed standard locks.
+The performance results demonstrate `rwlocker`'s true potential during Network and Database I/O operations where Python's GIL (Global Interpreter Lock) is released or context-switched. 
 
-**Summary of Performance Outputs:**
+**🖥️ Test Environment:** All tests were executed on an **Intel Core i7-12700H (2.4GHz)** processor running **EndeavourOS (Arch-based Linux)**, using **Python 3.14.3** and the experimental **Free-Threading (3.14.3t)** interpreters.
 
-* **🚀 Read-Heavy Scenario (100 Readers, 2 Writers):**
-While standard locks queue readers single-file and choke the system, `rwlocker` allows readers to access the data simultaneously. This achieves **~37x FASTER** speed and throughput in **Threading** and **~30x FASTER** in **Asyncio**.
-* **⚖️ Balanced Scenario (50 Readers, 50 Writers):**
-Thanks to the Fair state machine, read operations are squeezed in parallel between write queues. It increases performance by **2x** compared to standard locks without creating a system bottleneck.
-* **🛡️ Write-Heavy Scenario (2 Readers, 100 Writers):**
-Even though write operations inherently cannot be executed concurrently (in parallel), thanks to `rwlocker`'s zero-allocation smart proxy architecture, it runs **7-8% faster** than standard `C`-based locks. Even the O(1) cost "ReentrantWriter" (reentrancy) feature adds almost no overhead to performance.
+**🧪 Methodology:** To ensure absolute precision and zero margin of error, all reader and writer entities (threads or async tasks) are spawned in advance and held at a starting line using a synchronization `Event`. Once the event triggers, they execute simultaneously. The workloads strictly follow an `IOBoundScenario` that enforces a precise `time.sleep(0.001)` or `asyncio.sleep(0.001)` delay to accurately simulate real network/database I/O latency.
 
-**Condition Variable Performance Outputs:**
+### 1. Read-Write Lock (RWLock) Benchmarks
 
-Standard library Condition structures lock up the CPU during multiple wake-ups due to O(N) scanning. `rwlocker`'s O(1) queue architecture absolutely crushes the standard library at this point.
+Standard locks force threads to queue single-file even if they are only reading data. `rwlocker` unleashes concurrent read access.
 
-* **📣 Massive Broadcast (1 Writer, 100 Readers):**
-When a single writer updates the database and wakes up hundreds of waiting readers (`notify_all`); thanks to our O(1) architecture, **~65x FASTER** throughput (Ops/sec) is achieved in **Threading**, and **~70x FASTER** in **Asyncio**. The system is saved from entering a "Cache Stampede".
-* **🔀 Balanced Pub/Sub (50 Writers, 50 Readers):**
-In mixed waiting and waking scenarios, our Condition locks with the `Write-Pref` strategy ran **~2x FASTER** than the standard library.
-* **📉 Write-Heavy Limit (Stress Test - 100 Writers, 2 Readers):**
-In this brutal scenario where writers constantly block each other and call `notify()`, C-based standard locks utilize their raw speed advantage. `rwlocker`'s Write-Pref model holds its ground neck-and-neck (1.0x) with the standard lock, while the Fair and Read-Pref models intentionally slow down (0.5x - 0.7x) for the sake of maintaining fairness.
+**Synchronous (Thread) RWLock Performance:**
+In the Read-Heavy scenario, standard C-based locks choke the system, whereas `rwlocker` achieves up to **~35x speedup**. Even in Write-Heavy workloads where parallelism isn't inherently possible, `rwlocker` matches or slightly outperforms the C-baseline thanks to its zero-allocation fast-paths.
 
-*(Note: All lock, adapter, and condition classes have passed a massive suite of **266 different unit tests** covering reentrancy, deadlock, timeout, OS interrupts, O(N) leaks, and cancellation safety scenarios with 0 errors, and this entire test suite was completed in just **8.5 seconds**.)*
+**Asynchronous (Asyncio) RWLock Performance:**
+`rwlocker` achieves **~30x faster throughput** by allowing thousands of reader tasks to await I/O simultaneously without blocking one another.
+
+### 2. Condition Variable (RWCondition) Benchmarks
+
+Standard `Condition` variables iterate through all sleeping threads/tasks one by one `O(N)` during a broadcast (`notify_all`), causing massive CPU spikes and "Cache Stampedes". `rwlocker` completely eradicates this with its pure `O(1)` queueing architecture.
+
+**Synchronous (Thread) RWCondition Performance:**
+When 100 sleeping readers are awakened simultaneously, `rwlocker` processes them instantly without locking the OS. This architectural leap results in a mind-blowing **~45x speedup** compared to the standard library's `threading.Condition`.
+
+**Asynchronous (Asyncio) RWCondition Performance:**
+In event-driven caching systems, waking up hundreds of waiting web requests simultaneously is a major bottleneck. The `AsyncRWCondition` completely bypasses standard asyncio constraints, reaching up to **~45x higher throughput** during massive broadcast scenarios, completely saving the loop from freezing.
+
+*(Note: All lock, adapter, and condition classes have passed a massive suite of **315 different unit tests** covering reentrancy, deadlock, timeout, OS interrupts, O(N) leaks, and cancellation safety scenarios with 0 errors, and this entire test suite was completed in just **13.2 seconds**.)*
 
 
 <br/>
@@ -469,7 +473,7 @@ Email: TahsinCrs@gmail.com
 
 [issues-url]: https://github.com/TahsinCr/python-rwlocker/issues
 
-[examples-url]: https://github.com/TahsinCr/python-rwlocker/wiki
+[examples-url]: https://github.com/TahsinCr/python-rwlocker/tree/main/examples
 
 [license-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/LICENSE
 
@@ -482,11 +486,3 @@ Email: TahsinCrs@gmail.com
 [linkedin-url]: https://linkedin.com/in/TahsinCr
 
 [x-url]: https://twitter.com/TahsinCrs
-
-
-
-<!-- File URL -->
-
-[lang-tr-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README_TR.md
-
-[lang-en-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README.md