@@ -91,20 +91,43 @@ def data(self) -> list[Entry[K, V]]:
9191 self ._threadlocal .data = []
9292 return self ._threadlocal .data
9393
94+ def _repair_if_interrupted (self ) -> None :
95+ """An exception raised partway through a mutation - most plausibly a
96+ RecursionError below a deeply recursive strategy - can leave the heap
97+ property or the key index broken. We note the interruption and
98+ rebuild both here, on the next operation, from the surviving entries
99+ (a sorted list is heap-ordered), rather than attempting a repair at
100+ the moment the stack overflowed.
101+ """
102+ if getattr (self ._threadlocal , "interrupted" , False ):
103+ self .data .sort (key = lambda e : e .sort_key )
104+ self .keys_to_indices .clear ()
105+ for i , e in enumerate (self .data ):
106+ self .keys_to_indices [e .key ] = i
107+ self ._threadlocal .interrupted = False
108+
94109 def __len__ (self ) -> int :
110+ self ._repair_if_interrupted ()
95111 assert len (self .keys_to_indices ) == len (self .data )
96112 return len (self .data )
97113
98114 def __contains__ (self , key : K ) -> bool :
115+ self ._repair_if_interrupted ()
99116 return key in self .keys_to_indices
100117
101118 def __getitem__ (self , key : K ) -> V :
119+ self ._repair_if_interrupted ()
102120 i = self .keys_to_indices [key ]
103121 result = self .data [i ]
104- self .__entry_was_accessed (i )
122+ try :
123+ self .__entry_was_accessed (i )
124+ except BaseException :
125+ self ._threadlocal .interrupted = True
126+ raise
105127 return result .value
106128
107129 def __setitem__ (self , key : K , value : V ) -> None :
130+ self ._repair_if_interrupted ()
108131 evicted = None
109132 try :
110133 i = self .keys_to_indices [key ]
@@ -122,13 +145,21 @@ def __setitem__(self, key: K, value: V) -> None:
122145 else :
123146 i = len (self .data )
124147 self .data .append (entry )
125- self .keys_to_indices [key ] = i
126- self .__balance (i )
148+ try :
149+ self .keys_to_indices [key ] = i
150+ self .__balance (i )
151+ except BaseException :
152+ self ._threadlocal .interrupted = True
153+ raise
127154 else :
128155 entry = self .data [i ]
129156 assert entry .key == key
130157 entry .value = value
131- self .__entry_was_accessed (i )
158+ try :
159+ self .__entry_was_accessed (i )
160+ except BaseException :
161+ self ._threadlocal .interrupted = True
162+ raise
132163
133164 if evicted is not None :
134165 if self .data [0 ] is not entry :
@@ -150,18 +181,27 @@ def pin(self, key: K, value: V) -> None:
150181 entry = self .data [i ]
151182 entry .pins += 1
152183 if entry .pins == 1 :
153- self .__balance (i )
184+ try :
185+ self .__balance (i )
186+ except BaseException :
187+ self ._threadlocal .interrupted = True
188+ raise
154189
155190 def unpin (self , key : K ) -> None :
156191 """Undo one previous call to ``pin(key)``. The value stays the same.
157192 Once all calls are undone this key may be evicted as normal."""
193+ self ._repair_if_interrupted ()
158194 i = self .keys_to_indices [key ]
159195 entry = self .data [i ]
160196 if entry .pins == 0 :
161197 raise ValueError (f"Key { key !r} has not been pinned" )
162198 entry .pins -= 1
163199 if entry .pins == 0 :
164- self .__balance (i )
200+ try :
201+ self .__balance (i )
202+ except BaseException :
203+ self ._threadlocal .interrupted = True
204+ raise
165205
166206 def is_pinned (self , key : K ) -> bool :
167207 """Returns True if the key is currently pinned."""
0 commit comments