Fix FSEvents RuntimeError on concurrent cache access (#321)

* Initial plan

* Fix RuntimeError: Cannot add watch on FSEvents

- Catch RuntimeError when observer.schedule() fails with "Cannot add watch"
- Fall back to polling mode when this error occurs (common on macOS FSEvents)
- Add tests for RuntimeError handling in wait_on_entry_calc
- Ensures graceful degradation when multiple observers watch same path

Co-authored-by: Borda <6035284+Borda@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Borda <6035284+Borda@users.noreply.github.com>

Author: Copilot

src/cachier/cores/pickle.py

@@ -300,6 +300,16 @@ def wait_on_entry_calc(self, key: str) -> Any:
                 return self._wait_with_polling(key)
             else:
                 raise
+        except RuntimeError as e:
+            if "Cannot add watch" in str(e):
+                # Fall back to polling if watch already scheduled (FSEvents)
+                logging.debug(
+                    "Watch already scheduled for %s, falling back to polling",
+                    self.cache_dir,
+                )
+                return self._wait_with_polling(key)
+            else:
+                raise
 
     def _wait_with_inotify(self, key: str, filename: str) -> Any:  # type: ignore[valid-type]
         """Wait for calculation using inotify with proper cleanup."""

tests/test_pickle_core.py

@@ -902,6 +902,75 @@ def mock_wait_inotify(key, filename):
         core.wait_on_entry_calc("test_key")
 
 
+@pytest.mark.pickle
+def test_wait_on_entry_calc_runtime_error_watch_scheduled(tmp_path):
+    """Test wait_on_entry_calc fallback when RuntimeError occurs (FSEvents)."""
+    # Test RuntimeError handling for "Cannot add watch" on macOS FSEvents
+    core = _PickleCore(
+        hash_func=None,
+        cache_dir=tmp_path,
+        pickle_reload=False,
+        wait_for_calc_timeout=10,
+        separate_files=False,
+    )
+
+    # Set a mock function
+    def mock_func():
+        pass
+
+    core.set_func(mock_func)
+
+    # Create a cache entry that's being calculated
+    cache_entry = CacheEntry(
+        value="test_value",
+        time=datetime.now(),
+        stale=False,
+        _processing=True,  # Should be processing
+    )
+    core._save_cache({"test_key": cache_entry})
+
+    # Mock _wait_with_inotify to raise RuntimeError with FSEvents message
+    def mock_wait_inotify(key, filename):
+        raise RuntimeError("Cannot add watch")
+
+    core._wait_with_inotify = mock_wait_inotify
+
+    # Mock _wait_with_polling to return a value
+    core._wait_with_polling = Mock(return_value="polling_result")
+
+    result = core.wait_on_entry_calc("test_key")
+    assert result == "polling_result"
+    core._wait_with_polling.assert_called_once_with("test_key")
+
+
+@pytest.mark.pickle
+def test_wait_on_entry_calc_other_runtime_error(tmp_path):
+    """Test wait_on_entry_calc re-raises non-watch RuntimeErrors."""
+    # Test that other RuntimeErrors are re-raised
+    core = _PickleCore(
+        hash_func=None,
+        cache_dir=tmp_path,
+        pickle_reload=False,
+        wait_for_calc_timeout=10,
+        separate_files=False,
+    )
+
+    # Set a mock function
+    def mock_func():
+        pass
+
+    core.set_func(mock_func)
+
+    # Mock _wait_with_inotify to raise different RuntimeError
+    def mock_wait_inotify(key, filename):
+        raise RuntimeError("Different runtime error")
+
+    core._wait_with_inotify = mock_wait_inotify
+
+    with pytest.raises(RuntimeError, match="Different runtime error"):
+        core.wait_on_entry_calc("test_key")
+
+
 @pytest.mark.pickle
 def test_wait_with_polling_file_errors(tmp_path):
     """Test _wait_with_polling handles file errors gracefully."""