locklib 0.0.23__tar.gz → 0.0.24__tar.gz

{locklib-0.0.23 → locklib-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locklib
-Version: 0.0.23
+Version: 0.0.24
 Summary: When there are not enough locks from the standard library
 Author-email: Evgeniy Blinov <zheni-b@yandex.ru>
 Project-URL: Source, https://github.com/mutating/locklib
@@ -100,13 +100,14 @@ from multiprocessing import Lock as MLock
 from threading import Lock as TLock, RLock as TRLock
 from asyncio import Lock as ALock
 
-from locklib import SmartLock, LockProtocol
+from locklib import SmartLock, SmartRLock, LockProtocol
 
 print(isinstance(MLock(), LockProtocol)) # True
 print(isinstance(TLock(), LockProtocol)) # True
 print(isinstance(TRLock(), LockProtocol)) # True
 print(isinstance(ALock(), LockProtocol)) # True
 print(isinstance(SmartLock(), LockProtocol)) # True
+print(isinstance(SmartRLock(), LockProtocol)) # True
 ```
 
 However, most idiomatic Python code uses locks as context managers. If your code does too, you can use one of the two protocols derived from the base `LockProtocol`: `ContextLockProtocol` or `AsyncContextLockProtocol`. Thus, the protocol hierarchy looks like this:
@@ -119,18 +120,19 @@ LockProtocol
 
 `ContextLockProtocol` describes objects that satisfy `LockProtocol` and also implement the [context manager protocol](https://docs.python.org/3/library/stdtypes.html#typecontextmanager). Similarly,`AsyncContextLockProtocol` describes objects that satisfy `LockProtocol` and implement the [asynchronous context manager](https://docs.python.org/3/reference/datamodel.html#async-context-managers) protocol.
 
-Almost all standard library locks, as well as `SmartLock`, satisfy `ContextLockProtocol`:
+Almost all standard library locks, as well as `SmartLock` and `SmartRLock`, satisfy `ContextLockProtocol`:
 
 ```python
 from multiprocessing import Lock as MLock
 from threading import Lock as TLock, RLock as TRLock
 
-from locklib import SmartLock, ContextLockProtocol
+from locklib import SmartLock, SmartRLock, ContextLockProtocol
 
 print(isinstance(MLock(), ContextLockProtocol)) # True
 print(isinstance(TLock(), ContextLockProtocol)) # True
 print(isinstance(TRLock(), ContextLockProtocol)) # True
 print(isinstance(SmartLock(), ContextLockProtocol)) # True
+print(isinstance(SmartRLock(), ContextLockProtocol)) # True
 ```
 
 However, the [`asyncio.Lock`](https://docs.python.org/3/library/asyncio-sync.html#asyncio.Lock) belongs to a separate category and `AsyncContextLockProtocol` is needed to describe it:
@@ -239,6 +241,29 @@ If you want to catch this exception, you can also import it from `locklib`:
 from locklib import DeadLockError
 ```
 
+`SmartLock` is deliberately not recursive: acquiring the same instance twice from the same thread raises `DeadLockError`. When recursive ownership is needed, use `SmartRLock` instead. It keeps the same deadlock detection for waits between threads, but lets the owning thread enter the same lock repeatedly:
+
+```python
+from locklib import SmartRLock
+
+lock = SmartRLock()
+
+with lock, lock:
+    pass
+```
+
+If you use explicit `acquire()` and `release()` calls, every successful acquire must have a matching release:
+
+```python
+from locklib import SmartRLock
+
+lock = SmartRLock()
+
+lock.acquire()
+lock.acquire()
+lock.release()
+lock.release()
+```
 
 ## Test your locks
 

{locklib-0.0.23 → locklib-0.0.24}/README.md

@@ -70,13 +70,14 @@ from multiprocessing import Lock as MLock
 from threading import Lock as TLock, RLock as TRLock
 from asyncio import Lock as ALock
 
-from locklib import SmartLock, LockProtocol
+from locklib import SmartLock, SmartRLock, LockProtocol
 
 print(isinstance(MLock(), LockProtocol)) # True
 print(isinstance(TLock(), LockProtocol)) # True
 print(isinstance(TRLock(), LockProtocol)) # True
 print(isinstance(ALock(), LockProtocol)) # True
 print(isinstance(SmartLock(), LockProtocol)) # True
+print(isinstance(SmartRLock(), LockProtocol)) # True
 ```
 
 However, most idiomatic Python code uses locks as context managers. If your code does too, you can use one of the two protocols derived from the base `LockProtocol`: `ContextLockProtocol` or `AsyncContextLockProtocol`. Thus, the protocol hierarchy looks like this:
@@ -89,18 +90,19 @@ LockProtocol
 
 `ContextLockProtocol` describes objects that satisfy `LockProtocol` and also implement the [context manager protocol](https://docs.python.org/3/library/stdtypes.html#typecontextmanager). Similarly,`AsyncContextLockProtocol` describes objects that satisfy `LockProtocol` and implement the [asynchronous context manager](https://docs.python.org/3/reference/datamodel.html#async-context-managers) protocol.
 
-Almost all standard library locks, as well as `SmartLock`, satisfy `ContextLockProtocol`:
+Almost all standard library locks, as well as `SmartLock` and `SmartRLock`, satisfy `ContextLockProtocol`:
 
 ```python
 from multiprocessing import Lock as MLock
 from threading import Lock as TLock, RLock as TRLock
 
-from locklib import SmartLock, ContextLockProtocol
+from locklib import SmartLock, SmartRLock, ContextLockProtocol
 
 print(isinstance(MLock(), ContextLockProtocol)) # True
 print(isinstance(TLock(), ContextLockProtocol)) # True
 print(isinstance(TRLock(), ContextLockProtocol)) # True
 print(isinstance(SmartLock(), ContextLockProtocol)) # True
+print(isinstance(SmartRLock(), ContextLockProtocol)) # True
 ```
 
 However, the [`asyncio.Lock`](https://docs.python.org/3/library/asyncio-sync.html#asyncio.Lock) belongs to a separate category and `AsyncContextLockProtocol` is needed to describe it:
@@ -209,6 +211,29 @@ If you want to catch this exception, you can also import it from `locklib`:
 from locklib import DeadLockError
 ```
 
+`SmartLock` is deliberately not recursive: acquiring the same instance twice from the same thread raises `DeadLockError`. When recursive ownership is needed, use `SmartRLock` instead. It keeps the same deadlock detection for waits between threads, but lets the owning thread enter the same lock repeatedly:
+
+```python
+from locklib import SmartRLock
+
+lock = SmartRLock()
+
+with lock, lock:
+    pass
+```
+
+If you use explicit `acquire()` and `release()` calls, every successful acquire must have a matching release:
+
+```python
+from locklib import SmartRLock
+
+lock = SmartRLock()
+
+lock.acquire()
+lock.acquire()
+lock.release()
+lock.release()
+```
 
 ## Test your locks
 

{locklib-0.0.23 → locklib-0.0.24}/locklib/__init__.py

@@ -10,6 +10,7 @@ from locklib.locks.empty.async_empty_lock import (
 )
 from locklib.locks.empty.empty_lock import EmptyLock as EmptyLock
 from locklib.locks.smart_lock.lock import SmartLock as SmartLock
+from locklib.locks.smart_lock.rlock import SmartRLock as SmartRLock
 from locklib.locks.tracer.tracer import (
     LockTraceWrapper as LockTraceWrapper,
 )

locklib-0.0.23/locklib/locks/smart_lock/lock.py → locklib-0.0.24/locklib/locks/smart_lock/abstract.py

@@ -7,20 +7,26 @@ except ImportError:  # pragma: no cover
     from threading import Lock  # get_native_id is available only since python 3.8
     from threading import get_ident as get_native_id
 
+from abc import ABC
 from collections import deque
 from types import TracebackType
-from typing import Deque, Dict, Optional, Type
+from typing import ClassVar, Deque, Dict, Optional, Type
 
+from locklib.errors import DeadLockError
 from locklib.locks.smart_lock.graph import LocksGraph
 
 graph = LocksGraph()
 
-class SmartLock:
+
+class AbstractSmartLock(ABC):  # noqa: B024
+    recursive: ClassVar[bool] = False
+
     def __init__(self, local_graph: LocksGraph = graph) -> None:
         self.graph: LocksGraph = local_graph
         self.lock: Lock = Lock()
         self.deque: Deque[int] = deque()
         self.local_locks: Dict[int, Lock] = {}
+        self.recursion_depths: Dict[int, int] = {}
 
     def __enter__(self) -> None:
         self.acquire()
@@ -33,16 +39,24 @@ class SmartLock:
         previous_element_lock = None
 
         with self.lock, self.graph.lock:
+            if self.deque and self.deque[-1] == thread_id:
+                if not self.recursive:
+                    raise DeadLockError(f'A cycle between {thread_id}th and {thread_id}th threads has been detected.')
+                self.recursion_depths[thread_id] += 1
+                return
+
             if not self.deque:
                 self.deque.appendleft(thread_id)
                 self.local_locks[thread_id] = Lock()
                 self.local_locks[thread_id].acquire()
+                self.recursion_depths[thread_id] = 1
             else:
                 previous_element = self.deque[0]
                 self.graph.add_link(thread_id, previous_element)
                 self.deque.appendleft(thread_id)
                 self.local_locks[thread_id] = Lock()
                 self.local_locks[thread_id].acquire()
+                self.recursion_depths[thread_id] = 1
                 previous_element_lock = self.local_locks[previous_element]
 
         if previous_element_lock is not None:
@@ -52,12 +66,17 @@ class SmartLock:
         thread_id = get_native_id()
 
         with self.lock, self.graph.lock:
-            if thread_id not in self.local_locks:
+            if not self.deque or self.deque[-1] != thread_id:
                 raise RuntimeError('Release unlocked lock.')
 
+            if self.recursive and self.recursion_depths[thread_id] > 1:
+                self.recursion_depths[thread_id] -= 1
+                return
+
             self.deque.pop()
             lock = self.local_locks[thread_id]
             del self.local_locks[thread_id]
+            del self.recursion_depths[thread_id]
 
             if len(self.deque) != 0:
                 next_element = self.deque[-1]

locklib-0.0.24/locklib/locks/smart_lock/lock.py

@@ -0,0 +1,5 @@
+from locklib.locks.smart_lock.abstract import AbstractSmartLock
+
+
+class SmartLock(AbstractSmartLock):
+    recursive = False

locklib-0.0.24/locklib/locks/smart_lock/rlock.py

@@ -0,0 +1,5 @@
+from locklib.locks.smart_lock.abstract import AbstractSmartLock
+
+
+class SmartRLock(AbstractSmartLock):
+    recursive = True

{locklib-0.0.23 → locklib-0.0.24}/locklib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locklib
-Version: 0.0.23
+Version: 0.0.24
 Summary: When there are not enough locks from the standard library
 Author-email: Evgeniy Blinov <zheni-b@yandex.ru>
 Project-URL: Source, https://github.com/mutating/locklib
@@ -100,13 +100,14 @@ from multiprocessing import Lock as MLock
 from threading import Lock as TLock, RLock as TRLock
 from asyncio import Lock as ALock
 
-from locklib import SmartLock, LockProtocol
+from locklib import SmartLock, SmartRLock, LockProtocol
 
 print(isinstance(MLock(), LockProtocol)) # True
 print(isinstance(TLock(), LockProtocol)) # True
 print(isinstance(TRLock(), LockProtocol)) # True
 print(isinstance(ALock(), LockProtocol)) # True
 print(isinstance(SmartLock(), LockProtocol)) # True
+print(isinstance(SmartRLock(), LockProtocol)) # True
 ```
 
 However, most idiomatic Python code uses locks as context managers. If your code does too, you can use one of the two protocols derived from the base `LockProtocol`: `ContextLockProtocol` or `AsyncContextLockProtocol`. Thus, the protocol hierarchy looks like this:
@@ -119,18 +120,19 @@ LockProtocol
 
 `ContextLockProtocol` describes objects that satisfy `LockProtocol` and also implement the [context manager protocol](https://docs.python.org/3/library/stdtypes.html#typecontextmanager). Similarly,`AsyncContextLockProtocol` describes objects that satisfy `LockProtocol` and implement the [asynchronous context manager](https://docs.python.org/3/reference/datamodel.html#async-context-managers) protocol.
 
-Almost all standard library locks, as well as `SmartLock`, satisfy `ContextLockProtocol`:
+Almost all standard library locks, as well as `SmartLock` and `SmartRLock`, satisfy `ContextLockProtocol`:
 
 ```python
 from multiprocessing import Lock as MLock
 from threading import Lock as TLock, RLock as TRLock
 
-from locklib import SmartLock, ContextLockProtocol
+from locklib import SmartLock, SmartRLock, ContextLockProtocol
 
 print(isinstance(MLock(), ContextLockProtocol)) # True
 print(isinstance(TLock(), ContextLockProtocol)) # True
 print(isinstance(TRLock(), ContextLockProtocol)) # True
 print(isinstance(SmartLock(), ContextLockProtocol)) # True
+print(isinstance(SmartRLock(), ContextLockProtocol)) # True
 ```
 
 However, the [`asyncio.Lock`](https://docs.python.org/3/library/asyncio-sync.html#asyncio.Lock) belongs to a separate category and `AsyncContextLockProtocol` is needed to describe it:
@@ -239,6 +241,29 @@ If you want to catch this exception, you can also import it from `locklib`:
 from locklib import DeadLockError
 ```
 
+`SmartLock` is deliberately not recursive: acquiring the same instance twice from the same thread raises `DeadLockError`. When recursive ownership is needed, use `SmartRLock` instead. It keeps the same deadlock detection for waits between threads, but lets the owning thread enter the same lock repeatedly:
+
+```python
+from locklib import SmartRLock
+
+lock = SmartRLock()
+
+with lock, lock:
+    pass
+```
+
+If you use explicit `acquire()` and `release()` calls, every successful acquire must have a matching release:
+
+```python
+from locklib import SmartRLock
+
+lock = SmartRLock()
+
+lock.acquire()
+lock.acquire()
+lock.release()
+lock.release()
+```
 
 ## Test your locks
 

{locklib-0.0.23 → locklib-0.0.24}/locklib.egg-info/SOURCES.txt

@@ -13,8 +13,10 @@ locklib/locks/empty/__init__.py
 locklib/locks/empty/async_empty_lock.py
 locklib/locks/empty/empty_lock.py
 locklib/locks/smart_lock/__init__.py
+locklib/locks/smart_lock/abstract.py
 locklib/locks/smart_lock/graph.py
 locklib/locks/smart_lock/lock.py
+locklib/locks/smart_lock/rlock.py
 locklib/locks/tracer/__init__.py
 locklib/locks/tracer/events.py
 locklib/locks/tracer/tracer.py

{locklib-0.0.23 → locklib-0.0.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'locklib'
-version = '0.0.23'
+version = '0.0.24'
 authors = [
   { name='Evgeniy Blinov', email='zheni-b@yandex.ru' },
 ]