fix: keep WtSite deep-copyable after adding the session lock

- threading.RLock is not copyable; the WtPage deepcopy in
  OSW._apply_overwrite_policy reached it through page.wtSite
- broke every store_entity() call with cannot pickle '_thread.RLock'
- __getstate__ drops the lock; _get_session_lock() recreates it lazily
- regression test deep-copies a WtPage carrying a locked WtSite
- drop unused noqa: BLE001 directives that failed ruff in CI

Author: LukasGold

src/osw/core.py

@@ -1610,7 +1610,7 @@ class StoreEntityPartialError(Exception):
         (``failed`` / ``result.failed``) without a separate existence query.
         """
 
-        def __init__(self, result: "OSW.StoreEntityResult"):
+        def __init__(self, result: OSW.StoreEntityResult):
             self.result = result
             self.stored = list(result.pages.keys())
             self.failed = result.failed
@@ -1852,7 +1852,7 @@ def failure_title_(upload_object: UploadObject) -> str:
                 try:
                     handle_upload_object_(upload_object)
                     results.append(None)
-                except Exception as e:  # noqa: BLE001 - collected below
+                except Exception as e:
                     results.append(e)
 
         failed: Dict[str, Exception] = {}

src/osw/utils/util.py

@@ -338,7 +338,7 @@ async def _run_tasks():
                 async def _capture(task):
                     try:
                         return await task
-                    except Exception as exc:  # noqa: BLE001 - returned to caller
+                    except Exception as exc:
                         return exc
 
                 tasks = [_capture(task) for task in tasks]

src/osw/wtsite.py

@@ -175,6 +175,18 @@ def _get_session_lock(self) -> threading.RLock:
             self._session_lock = lock
         return lock
 
+    def __getstate__(self):
+        """Drop the session lock when copying or pickling.
+
+        A WtSite is deep-copied as a side effect of copying a WtPage, which
+        happens on every store_entity() call (OSW._apply_overwrite_policy).
+        threading.RLock cannot be copied, so exclude it here; the copy gets a
+        fresh lock from _get_session_lock() on first use.
+        """
+        state = self.__dict__.copy()
+        state.pop("_session_lock", None)
+        return state
+
     def _relogin(self):
         """Re-login to the wiki site using stored credentials.
 
@@ -1759,7 +1771,7 @@ def edit(self, comment: str = None, mode="action-multislot", bot_edit: bool = Tr
         for attempt in range(max_retry):
             try:
                 return self._edit(comment, mode, bot_edit)
-            except Exception as e:  # noqa: BLE001 - re-raised below after retries
+            except Exception as e:
                 last_exc = e
                 print(f"Page edit failed: {e}. Retry ({attempt + 1}/{max_retry})")
                 if attempt + 1 < max_retry:

tests/test_wtsite_session_lock.py

@@ -7,10 +7,11 @@
 
 import threading
 import types
+from copy import deepcopy
 
 import requests.cookies as rc
 
-from osw.wtsite import WtSite
+from osw.wtsite import WtPage, WtSite
 
 
 def _make_wtsite_with_jar():
@@ -61,14 +62,14 @@ def clearer():
                             path="/",
                         )
                 ws._clear_cookies()
-        except Exception as exc:  # noqa: BLE001 - collected and asserted below
+        except Exception as exc:
             errors.append(exc)
 
     def reader():
         try:
             while not stop.is_set():
                 _ = [c.name for c in list(jar)]
-        except Exception as exc:  # noqa: BLE001 - collected and asserted below
+        except Exception as exc:
             errors.append(exc)
 
     clearers = [threading.Thread(target=clearer) for _ in range(4)]
@@ -86,3 +87,24 @@ def reader():
     assert errors == []
     # the non-PostEditRevision cookie must survive every clear
     assert "sessionToken" in {c.name for c in jar}
+
+
+def test_wtsite_survives_deepcopy_of_a_page():
+    """store_entity deep-copies the page, reaching WtSite through page.wtSite.
+
+    Without WtSite.__getstate__ dropping the lock this raises
+    TypeError: cannot pickle '_thread.RLock' object.
+    """
+    ws, jar = _make_wtsite_with_jar()
+    _populate(jar)
+    page = WtPage.__new__(WtPage)
+    page.wtSite = ws
+    page._slots = {"jsondata": {"uuid": "abc"}}
+
+    copied = deepcopy(page)
+
+    assert copied._slots == page._slots
+    assert copied._slots is not page._slots
+    # the copy has no lock until something asks for one
+    assert "_session_lock" not in copied.wtSite.__dict__
+    assert copied.wtSite._get_session_lock() is not ws._session_lock