rwlocker 3.1__tar.gz → 3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rwlocker
-Version: 3.1
+Version: 3.2
 Summary: Advanced, High-Performance, and State-Machine Based Synchronous/Asynchronous Read-Write Locks.
 Author-email: TahsinCr <TahsinCrs@gmail.com>
 License: MIT
@@ -486,13 +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
-
-[lang-ru-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README_ru.md

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

@@ -457,13 +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
-
-[lang-ru-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README_ru.md

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rwlocker"
-version = "3.1"
+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.1 → rwlocker-3.2}/rwlocker/__init__.py

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

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

@@ -37,10 +37,9 @@ from collections import deque
 from abc import ABC, abstractmethod
 from typing import Callable, Protocol, Optional
 from types import TracebackType
+import weakref
 
-from . import mixins
-
-__version__ = '3.1'
+__version__ = '3.2'
 __all__ = (
     'AsyncLockable', 'AsyncLockDowngradable', 'AsyncRWLockBase', 'AsyncRWLockWithProxyBase', 
     'AsyncRWLockProxy', 'AsyncRWLockReaderProxy', 'AsyncRWLockWriterProxy',
@@ -280,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):
         """
@@ -311,7 +310,7 @@ class AsyncRWLockWriterProxy(AsyncRWLockProxy):
         self._release_core()
 
 # Read and Write Lock
-class AsyncRWLockWrite(mixins._RWLockWriteMixin, AsyncRWLockWithProxyBase):
+class AsyncRWLockWrite(AsyncRWLockWithProxyBase):
     """
     Write-preferring Asynchronous Read-Write Lock.
     
@@ -347,8 +346,55 @@ class AsyncRWLockWrite(mixins._RWLockWriteMixin, AsyncRWLockWithProxyBase):
         super().__init__()
         self._writer_active = False
         self._readers_active = 0
+
+    def _can_read(self) -> bool: 
+        return not self._writer_active and self.write.those_waiting == 0
+    
+    def _acquire_read_core(self): 
+        self._readers_active += 1
+
+    def _release_read_core(self):
+        if self._readers_active == 0: 
+            raise RuntimeError("Unacquired read lock")
+        self._readers_active -= 1
+        if self._readers_active == 0: 
+            self.write.condition.notify()
+
+    def _on_reader_abort(self):
+        pass
+
+    def _can_write(self) -> bool: 
+        return not self._writer_active and self._readers_active == 0
+    
+    def _acquire_write_core(self): 
+        self._writer_active = True
+
+    def _release_write_core(self):
+        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: 
+            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.write.those_waiting > 0: 
+            self.write.condition.notify()
+        else: 
+            self.read.condition.notify_all()
+
+    def _is_write_locked(self) -> bool: 
+        return self._writer_active
+    
+    def _is_read_locked(self) -> bool:
+        return self._readers_active > 0
         
-class AsyncRWLockWriteReentrantWriter(mixins._RWLockWriteReentrantMixin, AsyncRWLockWrite):
+class AsyncRWLockWriteReentrantWriter(AsyncRWLockWrite):
     """
     Write-preferring Asynchronous Read-Write Lock with Task-Reentrancy.
     
@@ -400,7 +446,42 @@ class AsyncRWLockWriteReentrantWriter(mixins._RWLockWriteReentrantMixin, AsyncRW
     def _clear_current_writer(self) -> None:
         self._writer_id = None
 
-class AsyncRWLockRead(mixins._RWLockReadMixin, AsyncRWLockWithProxyBase):
+    def _can_read(self) -> bool:
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self.write.those_waiting == 0
+
+    def _can_write(self) -> bool:
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self._readers_active == 0
+    
+    def _acquire_write_core(self):
+        self._set_current_writer()
+        self._write_count += 1
+
+    def _release_write_core(self):
+        if not self._is_current_writer(): 
+            raise RuntimeError("Permission denied")
+        self._write_count -= 1
+        if self._write_count == 0:
+            self._clear_current_writer()
+            self._on_writer_abort()
+
+    def _downgrade_core(self):
+        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._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
+
+class AsyncRWLockRead(AsyncRWLockWithProxyBase):
     """
     Read-preferring Asynchronous Read-Write Lock.
     
@@ -436,8 +517,56 @@ class AsyncRWLockRead(mixins._RWLockReadMixin, AsyncRWLockWithProxyBase):
         super().__init__()
         self._writer_active = False
         self._readers_active = 0
+
+    def _can_read(self) -> bool: 
+        return not self._writer_active
+    
+    def _acquire_read_core(self): 
+        self._readers_active += 1
+
+    def _release_read_core(self):
+        if self._readers_active == 0: 
+            raise RuntimeError("Unacquired read lock")
+        self._readers_active -= 1
+        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: 
+            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): 
+        self._writer_active = True
+
+    def _release_write_core(self):
+        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: 
+            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: 
+            self.read.condition.notify_all()
+        else: 
+            self.write.condition.notify()
+
+    def _is_write_locked(self) -> bool: 
+        return self._writer_active
+    
+    def _is_read_locked(self) -> bool:
+        return self._readers_active > 0
         
-class AsyncRWLockReadReentrantWriter(mixins._RWLockReadReentrantMixin, AsyncRWLockRead):
+class AsyncRWLockReadReentrantWriter(AsyncRWLockRead):
     """
     Read-preferring Asynchronous Read-Write Lock with Task-Reentrancy.
     
@@ -487,7 +616,42 @@ class AsyncRWLockReadReentrantWriter(mixins._RWLockReadReentrantMixin, AsyncRWLo
     def _clear_current_writer(self) -> None:
         self._writer_id = None
 
-class AsyncRWLockFair(mixins._RWLockFairMixin, AsyncRWLockWithProxyBase):
+    def _can_read(self) -> bool:
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return True
+
+    def _can_write(self) -> bool:
+        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._set_current_writer()
+        self._write_count += 1
+
+    def _release_write_core(self):
+        if not self._is_current_writer(): 
+            raise RuntimeError("Permission denied")
+        self._write_count -= 1
+        if self._write_count == 0:
+            self._clear_current_writer()
+            self._on_writer_abort()
+
+    def _downgrade_core(self):
+        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._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
+
+class AsyncRWLockFair(AsyncRWLockWithProxyBase):
     """
     Fair (First-In-First-Out) Asynchronous Read-Write Lock.
     
@@ -524,8 +688,66 @@ class AsyncRWLockFair(mixins._RWLockFairMixin, AsyncRWLockWithProxyBase):
         self._writer_active = False
         self._readers_turn = False
         self._readers_active = 0
+
+    def _can_read(self) -> bool:
+        if self._writer_active: 
+            return False
+        return self._readers_turn or self.write.those_waiting == 0
+    
+    def _acquire_read_core(self): 
+        self._readers_active += 1
+
+    def _release_read_core(self):
+        if self._readers_active == 0: 
+            raise RuntimeError("Unacquired read lock")
+        self._readers_active -= 1
+        if self._readers_active == 0:
+            self._readers_turn = False
+            self.write.condition.notify()
+
+    def _on_reader_abort(self):
+        if self._readers_turn and self.read.those_waiting == 0 and self._readers_active == 0:
+            self._readers_turn = False
+            self.write.condition.notify()
+
+    def _can_write(self) -> bool:
+        if self._writer_active or 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_active = True
+
+    def _release_write_core(self):
+        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: 
+            raise RuntimeError("Cannot downgrade unlocked lock")
+        self._writer_active = False
+        self._readers_active += 1
+        self._readers_turn = True
+        self.read.condition.notify_all()
+
+    def _on_writer_abort(self):
+        if self.read.those_waiting > 0:
+            self._readers_turn = True
+            self.read.condition.notify_all()
+        else: 
+            self.write.condition.notify()
+
+    def _is_write_locked(self) -> bool:
+        return self._writer_active
+    
+    def _is_read_locked(self) -> bool:
+        return self._readers_active > 0
         
-class AsyncRWLockFairReentrantWriter(mixins._RWLockFairReentrantMixin, AsyncRWLockFair):
+class AsyncRWLockFairReentrantWriter(AsyncRWLockFair):
     """
     Fair (First-In-First-Out) Asynchronous Read-Write Lock with Task-Reentrancy.
     
@@ -575,6 +797,50 @@ class AsyncRWLockFairReentrantWriter(mixins._RWLockFairReentrantMixin, AsyncRWLo
     def _clear_current_writer(self) -> None:
         self._writer_id = None
 
+    def _can_read(self) -> bool:
+        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 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._set_current_writer()
+        self._write_count += 1
+        
+    def _release_write_core(self):
+        if not self._is_current_writer(): 
+            raise RuntimeError("Permission denied")
+        self._write_count -= 1
+        if self._write_count == 0:
+            self._clear_current_writer()
+            self._on_writer_abort()
+
+    def _downgrade_core(self):
+        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._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: 
+        return self._writer_id is not None
+
 # Standart Lock Adapter
 class AsyncLock(AsyncRWLockBase):
     """
@@ -632,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
@@ -934,7 +1200,7 @@ class AsyncRWConditionWriterProxy(AsyncRWConditionProxy):
         self._lock_proxy.downgrade()
 
 # Read Write Lock For Condition
-class AsyncRWCondition(mixins._RWConditionMixin, AsyncRWConditionWithProxyBase):
+class AsyncRWCondition(AsyncRWConditionWithProxyBase):
     """
     Standard implementation of an Asynchronous Read-Write Condition variable.
     
@@ -977,6 +1243,12 @@ class AsyncRWCondition(mixins._RWConditionMixin, AsyncRWConditionWithProxyBase):
         self._waiters: deque[asyncio.Future] = deque()
         super().__init__(lock)
     
+    def _is_owned_read(self) -> bool:
+        return self._lock._is_read_locked()
+
+    def _is_owned_write(self) -> bool:
+        return self._lock._is_write_locked()
+
     def _add_waiter(self) -> asyncio.Future:
         loop = asyncio.get_running_loop()
         waiter = loop.create_future()
@@ -1039,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.1 → rwlocker-3.2}/rwlocker/thread_rwlock.py

@@ -37,9 +37,7 @@ from abc import ABC, abstractmethod
 from typing import Callable, Protocol, Optional
 from types import TracebackType
 
-from . import mixins
-
-__version__ = '3.1'
+__version__ = '3.2'
 __all__ = (
     'Lockable', 'LockDowngradable', 'RWLockBase', 'RWLockWithProxyBase',
     'RWLockProxy', 'RWLockReaderProxy', 'RWLockWriterProxy',
@@ -306,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,
@@ -318,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):
         """
@@ -332,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):
         """
@@ -341,17 +339,14 @@ class RWLockWriterProxy(RWLockProxy):
         and routes the release to the reader core to prevent deadlocks.
         """
         with self._lock:
-            if self._downgraded_threads: 
-                try:
-                    self._downgraded_threads.remove(threading.get_ident())
-                    self._read_lock._release_core()
-                    return
-                except KeyError:
-                    pass
+            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
-class RWLockWrite(mixins._RWLockWriteMixin, RWLockWithProxyBase):
+class RWLockWrite(RWLockWithProxyBase):
     """
     Write-preferring Read-Write Lock.
     
@@ -387,8 +382,55 @@ class RWLockWrite(mixins._RWLockWriteMixin, RWLockWithProxyBase):
         super().__init__(lock)
         self._writer_active = False
         self._readers_active = 0
+
+    def _can_read(self) -> bool: 
+        return not self._writer_active and self.write.those_waiting == 0
+    
+    def _acquire_read_core(self): 
+        self._readers_active += 1
+
+    def _release_read_core(self):
+        if self._readers_active == 0: 
+            raise RuntimeError("Unacquired read lock")
+        self._readers_active -= 1
+        if self._readers_active == 0: 
+            self.write.condition.notify()
+
+    def _on_reader_abort(self):
+        pass
+
+    def _can_write(self) -> bool: 
+        return not self._writer_active and self._readers_active == 0
     
-class RWLockWriteReentrantWriter(mixins._RWLockWriteReentrantMixin, RWLockWrite):
+    def _acquire_write_core(self): 
+        self._writer_active = True
+
+    def _release_write_core(self):
+        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: 
+            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.write.those_waiting > 0: 
+            self.write.condition.notify()
+        else: 
+            self.read.condition.notify_all()
+
+    def _is_write_locked(self) -> bool: 
+        return self._writer_active
+    
+    def _is_read_locked(self) -> bool:
+        return self._readers_active > 0
+
+class RWLockWriteReentrantWriter(RWLockWrite):
     """
     Write-preferring Read-Write Lock with Write-Reentrancy support.
     
@@ -440,7 +482,42 @@ class RWLockWriteReentrantWriter(mixins._RWLockWriteReentrantMixin, RWLockWrite)
     def _clear_current_writer(self) -> None:
         self._writer_id = None
 
-class RWLockRead(mixins._RWLockReadMixin, RWLockWithProxyBase):
+    def _can_read(self) -> bool:
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self.write.those_waiting == 0
+
+    def _can_write(self) -> bool:
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return self._readers_active == 0
+    
+    def _acquire_write_core(self):
+        self._set_current_writer()
+        self._write_count += 1
+
+    def _release_write_core(self):
+        if not self._is_current_writer(): 
+            raise RuntimeError("Permission denied")
+        self._write_count -= 1
+        if self._write_count == 0:
+            self._clear_current_writer()
+            self._on_writer_abort()
+
+    def _downgrade_core(self):
+        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._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
+
+class RWLockRead(RWLockWithProxyBase):
     """
     Read-preferring Read-Write Lock.
     
@@ -478,7 +555,55 @@ class RWLockRead(mixins._RWLockReadMixin, RWLockWithProxyBase):
         self._writer_active = False
         self._readers_active = 0
 
-class RWLockReadReentrantWriter(mixins._RWLockReadReentrantMixin, RWLockRead):
+    def _can_read(self) -> bool: 
+        return not self._writer_active
+    
+    def _acquire_read_core(self): 
+        self._readers_active += 1
+
+    def _release_read_core(self):
+        if self._readers_active == 0: 
+            raise RuntimeError("Unacquired read lock")
+        self._readers_active -= 1
+        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: 
+            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): 
+        self._writer_active = True
+
+    def _release_write_core(self):
+        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: 
+            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: 
+            self.read.condition.notify_all()
+        else: 
+            self.write.condition.notify()
+
+    def _is_write_locked(self) -> bool: 
+        return self._writer_active
+    
+    def _is_read_locked(self) -> bool:
+        return self._readers_active > 0
+
+class RWLockReadReentrantWriter(RWLockRead):
     """
     Read-preferring Read-Write Lock with Write-Reentrancy support.
     
@@ -527,7 +652,42 @@ class RWLockReadReentrantWriter(mixins._RWLockReadReentrantMixin, RWLockRead):
     def _clear_current_writer(self) -> None:
         self._writer_id = None
 
-class RWLockFair(mixins._RWLockFairMixin, RWLockWithProxyBase):
+    def _can_read(self) -> bool:
+        if self._writer_id is not None:
+            return self._is_current_writer()
+        return True
+
+    def _can_write(self) -> bool:
+        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._set_current_writer()
+        self._write_count += 1
+
+    def _release_write_core(self):
+        if not self._is_current_writer(): 
+            raise RuntimeError("Permission denied")
+        self._write_count -= 1
+        if self._write_count == 0:
+            self._clear_current_writer()
+            self._on_writer_abort()
+
+    def _downgrade_core(self):
+        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._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
+
+class RWLockFair(RWLockWithProxyBase):
     """
     Fair (First-In-First-Out) Read-Write Lock.
     
@@ -564,8 +724,66 @@ class RWLockFair(mixins._RWLockFairMixin, RWLockWithProxyBase):
         self._writer_active = False
         self._readers_turn = False
         self._readers_active = 0
+
+    def _can_read(self) -> bool:
+        if self._writer_active: 
+            return False
+        return self._readers_turn or self.write.those_waiting == 0
+    
+    def _acquire_read_core(self): 
+        self._readers_active += 1
+
+    def _release_read_core(self):
+        if self._readers_active == 0: 
+            raise RuntimeError("Unacquired read lock")
+        self._readers_active -= 1
+        if self._readers_active == 0:
+            self._readers_turn = False
+            self.write.condition.notify()
+
+    def _on_reader_abort(self):
+        if self._readers_turn and self.read.those_waiting == 0 and self._readers_active == 0:
+            self._readers_turn = False
+            self.write.condition.notify()
+
+    def _can_write(self) -> bool:
+        if self._writer_active or 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_active = True
+
+    def _release_write_core(self):
+        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: 
+            raise RuntimeError("Cannot downgrade unlocked lock")
+        self._writer_active = False
+        self._readers_active += 1
+        self._readers_turn = True
+        self.read.condition.notify_all()
+
+    def _on_writer_abort(self):
+        if self.read.those_waiting > 0:
+            self._readers_turn = True
+            self.read.condition.notify_all()
+        else: 
+            self.write.condition.notify()
+
+    def _is_write_locked(self) -> bool:
+        return self._writer_active
+    
+    def _is_read_locked(self) -> bool:
+        return self._readers_active > 0
         
-class RWLockFairReentrantWriter(mixins._RWLockFairReentrantMixin, RWLockFair):
+class RWLockFairReentrantWriter(RWLockFair):
     """
     Fair (First-In-First-Out) Read-Write Lock with Write-Reentrancy support.
     
@@ -615,6 +833,50 @@ class RWLockFairReentrantWriter(mixins._RWLockFairReentrantMixin, RWLockFair):
     def _clear_current_writer(self) -> None:
         self._writer_id = None
 
+    def _can_read(self) -> bool:
+        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 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._set_current_writer()
+        self._write_count += 1
+        
+    def _release_write_core(self):
+        if not self._is_current_writer(): 
+            raise RuntimeError("Permission denied")
+        self._write_count -= 1
+        if self._write_count == 0:
+            self._clear_current_writer()
+            self._on_writer_abort()
+
+    def _downgrade_core(self):
+        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._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: 
+        return self._writer_id is not None
+
 # Standart Lock Adapter
 class Lock(RWLockBase):
     """
@@ -671,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
@@ -966,7 +1228,7 @@ class RWConditionWriterProxy(RWConditionProxy):
         self._lock_proxy.downgrade()
 
 # Read Write Lock For Condition
-class RWCondition(mixins._RWConditionMixin, RWConditionWithProxyBase):
+class RWCondition(RWConditionWithProxyBase):
     """
     Standard implementation of a Read-Write Condition variable.
     
@@ -1008,6 +1270,12 @@ class RWCondition(mixins._RWConditionMixin, RWConditionWithProxyBase):
         self._internal_lock = threading.Lock()
         super().__init__(lock)
 
+    def _is_owned_read(self) -> bool:
+        return self._lock._is_read_locked()
+
+    def _is_owned_write(self) -> bool:
+        return self._lock._is_write_locked()
+
     def _add_waiter(self) -> threading.Lock:
         waiter = threading.Lock()
         waiter.acquire()
@@ -1080,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.1 → rwlocker-3.2/rwlocker.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rwlocker
-Version: 3.1
+Version: 3.2
 Summary: Advanced, High-Performance, and State-Machine Based Synchronous/Asynchronous Read-Write Locks.
 Author-email: TahsinCr <TahsinCrs@gmail.com>
 License: MIT
@@ -486,13 +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
-
-[lang-ru-url]: https://github.com/TahsinCr/python-rwlocker/blob/main/README_ru.md

{rwlocker-3.1 → rwlocker-3.2}/rwlocker.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ README-pypi.md
 pyproject.toml
 rwlocker/__init__.py
 rwlocker/async_rwlock.py
-rwlocker/mixins.py
 rwlocker/thread_rwlock.py
 rwlocker.egg-info/PKG-INFO
 rwlocker.egg-info/SOURCES.txt

rwlocker-3.1/rwlocker/mixins.py

@@ -1,305 +0,0 @@
-"""
-Shared state-machine Mixins for both Thread and Async RWLock implementations.
-These mixins encapsulate the core scheduling algorithms (Write-Pref, Read-Pref, Fair)
-to eliminate code duplication across synchronous and asynchronous domains.
-"""
-
-class _RWLockWriteMixin:
-    __slots__ = ()
-
-    def _can_read(self) -> bool: 
-        return not self._writer_active and self.write.those_waiting == 0
-    
-    def _acquire_read_core(self): 
-        self._readers_active += 1
-
-    def _release_read_core(self):
-        if self._readers_active == 0: 
-            raise RuntimeError("Unacquired read lock")
-        self._readers_active -= 1
-        if self._readers_active == 0: 
-            self.write.condition.notify()
-
-    def _on_reader_abort(self):
-        pass
-
-    def _can_write(self) -> bool: 
-        return not self._writer_active and self._readers_active == 0
-    
-    def _acquire_write_core(self): 
-        self._writer_active = True
-
-    def _release_write_core(self):
-        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: 
-            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.write.those_waiting > 0: 
-            self.write.condition.notify()
-        else: 
-            self.read.condition.notify_all()
-
-    def _is_write_locked(self) -> bool: 
-        return self._writer_active
-    
-    def _is_read_locked(self) -> bool:
-        return self._readers_active > 0
-
-
-class _RWLockWriteReentrantMixin:
-    __slots__ = ()
-
-    def _can_read(self) -> bool:
-        if self._writer_id is not None:
-            return self._is_current_writer()
-        return self.write.those_waiting == 0
-
-    def _can_write(self) -> bool:
-        if self._writer_id is not None:
-            return self._is_current_writer()
-        return self._readers_active == 0
-    
-    def _acquire_write_core(self):
-        self._set_current_writer()
-        self._write_count += 1
-
-    def _release_write_core(self):
-        if not self._is_current_writer(): 
-            raise RuntimeError("Permission denied")
-        self._write_count -= 1
-        if self._write_count == 0:
-            self._clear_current_writer()
-            self._on_writer_abort()
-
-    def _downgrade_core(self):
-        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._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
-
-
-class _RWLockReadMixin:
-    __slots__ = ()
-
-    def _can_read(self) -> bool: 
-        return not self._writer_active
-    
-    def _acquire_read_core(self): 
-        self._readers_active += 1
-
-    def _release_read_core(self):
-        if self._readers_active == 0: 
-            raise RuntimeError("Unacquired read lock")
-        self._readers_active -= 1
-        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: 
-            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): 
-        self._writer_active = True
-
-    def _release_write_core(self):
-        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: 
-            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: 
-            self.read.condition.notify_all()
-        else: 
-            self.write.condition.notify()
-
-    def _is_write_locked(self) -> bool: 
-        return self._writer_active
-    
-    def _is_read_locked(self) -> bool:
-        return self._readers_active > 0
-
-
-class _RWLockReadReentrantMixin:
-    __slots__ = ()
-
-    def _can_read(self) -> bool:
-        if self._writer_id is not None:
-            return self._is_current_writer()
-        return True
-
-    def _can_write(self) -> bool:
-        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._set_current_writer()
-        self._write_count += 1
-
-    def _release_write_core(self):
-        if not self._is_current_writer(): 
-            raise RuntimeError("Permission denied")
-        self._write_count -= 1
-        if self._write_count == 0:
-            self._clear_current_writer()
-            self._on_writer_abort()
-
-    def _downgrade_core(self):
-        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._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
-
-
-class _RWLockFairMixin:
-    __slots__ = ()
-
-    def _can_read(self) -> bool:
-        if self._writer_active: 
-            return False
-        return self._readers_turn or self.write.those_waiting == 0
-    
-    def _acquire_read_core(self): 
-        self._readers_active += 1
-
-    def _release_read_core(self):
-        if self._readers_active == 0: 
-            raise RuntimeError("Unacquired read lock")
-        self._readers_active -= 1
-        if self._readers_active == 0:
-            self._readers_turn = False
-            self.write.condition.notify()
-
-    def _on_reader_abort(self):
-        if self._readers_turn and self.read.those_waiting == 0 and self._readers_active == 0:
-            self._readers_turn = False
-            self.write.condition.notify()
-
-    def _can_write(self) -> bool:
-        if self._writer_active or 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_active = True
-
-    def _release_write_core(self):
-        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: 
-            raise RuntimeError("Cannot downgrade unlocked lock")
-        self._writer_active = False
-        self._readers_active += 1
-        self._readers_turn = True
-        self.read.condition.notify_all()
-
-    def _on_writer_abort(self):
-        if self.read.those_waiting > 0:
-            self._readers_turn = True
-            self.read.condition.notify_all()
-        else: 
-            self.write.condition.notify()
-
-    def _is_write_locked(self) -> bool:
-        return self._writer_active
-    
-    def _is_read_locked(self) -> bool:
-        return self._readers_active > 0
-
-
-class _RWLockFairReentrantMixin:
-    __slots__ = ()
-
-    def _can_read(self) -> bool:
-        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 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._set_current_writer()
-        self._write_count += 1
-        
-    def _release_write_core(self):
-        if not self._is_current_writer(): 
-            raise RuntimeError("Permission denied")
-        self._write_count -= 1
-        if self._write_count == 0:
-            self._clear_current_writer()
-            self._on_writer_abort()
-
-    def _downgrade_core(self):
-        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._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: 
-        return self._writer_id is not None
-
-
-class _RWConditionMixin:
-    __slots__ = ()
-
-    def _is_owned_read(self) -> bool:
-        return self._lock._is_read_locked()
-
-    def _is_owned_write(self) -> bool:
-        return self._lock._is_write_locked()