datashare-python 0.12.7__tar.gz → 0.12.9__tar.gz

{datashare_python-0.12.7 → datashare_python-0.12.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: datashare-python
-Version: 0.12.7
+Version: 0.12.9
 Summary: Manage Python tasks and local resources in Datashare
 Project-URL: Homepage, https://icij.github.io/datashare-python/
 Project-URL: Documentation, https://icij.github.io/datashare-python/

{datashare_python-0.12.7 → datashare_python-0.12.9}/datashare_python/config.py

@@ -114,6 +114,7 @@ class LoggingConfig(BaseModel):
 
 class ResourceCacheConfig(BaseModel):
     size: int = 1
+    refresh_interval: int | None = None
     exit_context_managers: bool = True
 
     def to_resource_cache(self) -> "SharedResources":
@@ -123,7 +124,9 @@ class ResourceCacheConfig(BaseModel):
         if self.exit_context_managers:
             eviction_callback = close_cm_callback
         return SharedResources(
-            cache_size=self.size, eviction_callback=eviction_callback
+            cache_size=self.size,
+            eviction_callback=eviction_callback,
+            refresh_interval=self.refresh_interval,
         )
 
 

{datashare_python-0.12.7 → datashare_python-0.12.9}/datashare_python/utils.py

@@ -822,9 +822,11 @@ class SharedResources:
         self,
         cache_size: int = 1,
         eviction_callback: Callable[[Any, Any], None] | None = None,
+        refresh_interval: int | None = None,
     ) -> None:
         self._eviction_callback = eviction_callback
         self._cache = LRU(cache_size, self._on_evict)
+        self._refresh_interval = refresh_interval
         self._sentinel = object()
         # Leased resources are tracked by id, evicting a leased resource defers the
         # eviction callback until its last lease is released
@@ -854,6 +856,14 @@ class SharedResources:
         """
         value = self._get_and_acquire(key)
         if value is self._sentinel:
+            # The factory can be long to complete (that's one of the reason we want to
+            # cache its results). Because we don't lock the factory call, together with
+            # the cache update, in case of concurrent access, quicker factories will
+            # complete first and will stay longer in the cache. This is fine, the
+            # alternative is to lock factory + cache update to avoid concurrent access
+            # but this will mean waiting for the first factory call to complete, this
+            # can potentially imply longer waits than no getting the value from the
+            # cache
             value = default_factory()
             self._cache_and_acquire(key, value)
         try:
@@ -873,6 +883,14 @@ class SharedResources:
         """
         value = self._get_and_acquire(key)
         if value is self._sentinel:
+            # The factory can be long to complete (that's one of the reason we want to
+            # cache its results). Because we don't lock the factory call, together with
+            # the cache update, in case of concurrent access, quicker factories will
+            # complete first and will stay longer in the cache. This is fine, the
+            # alternative is to lock factory + cache update to avoid concurrent access
+            # but this will mean waiting for the first factory call to complete, this
+            # can potentially imply longer waits than no getting the value from the
+            # cache
             value = await default_factory()
             self._cache_and_acquire(key, value)
         try:
@@ -884,28 +902,33 @@ class SharedResources:
         with self._lock:
             value = self._cache.get(key, self._sentinel)
             if value is not self._sentinel:
-                self._acquire(value)
+                # If refresh needs to happen, we set the value to the sentinel.
+                # The old value will be release with the last user call to _release.
+                # Returning the sentinel will trigger the call to the factory
+                refresh = (
+                    self._refresh_interval is not None
+                    and self._n_leases.get(self._vkey(value), 0)
+                    >= self._refresh_interval
+                )
+                if refresh:
+                    self._pending_evictions[self._vkey(value)] = (key, value)
+                    value = self._sentinel
+                else:
+                    self._acquire(value)
         return value
 
     def _cache_and_acquire(self, key: str, value: Any) -> None:
-        # The factory can be long to complete (that's one of the reason we want to
-        # cache its results). Because we don't lock the factory call, together with
-        # the cache update, in case of concurrent access, quicker factories will
-        # complete first and will stay longer in the cache. This is fine, the
-        # alternative is to lock factory + cache update to avoid concurrent access but
-        # this will mean waiting for the first factory call to complete, this can
-        # potentially imply longer waits than no getting the value from the cache
         with self._lock:
             self._acquire(value)
         # Can evict other resources, must be called without holding the lock
         self._cache[key] = value
 
     def _acquire(self, value: Any) -> None:
-        value_id = id(value)
+        value_id = self._vkey(value)
         self._n_leases[value_id] = self._n_leases.get(value_id, 0) + 1
 
     def _release(self, value: Any) -> None:
-        value_id = id(value)
+        value_id = self._vkey(value)
         with self._lock:
             self._n_leases[value_id] -= 1
             if self._n_leases[value_id]:
@@ -917,8 +940,8 @@ class SharedResources:
 
     def _on_evict(self, key: Any, value: Any) -> None:
         with self._lock:
-            if id(value) in self._n_leases:
-                self._pending_evictions[id(value)] = (key, value)
+            if self._vkey(value) in self._n_leases:
+                self._pending_evictions[self._vkey(value)] = (key, value)
                 return
         self._evict(key, value)
 
@@ -926,6 +949,9 @@ class SharedResources:
         if self._eviction_callback is not None:
             self._eviction_callback(key, value)
 
+    def _vkey(self, value: Any) -> int:
+        return id(value)
+
 
 def close_cm_callback(key: str, value: Any) -> None:  # noqa: ARG001
     if hasattr(value, "__exit__"):

{datashare_python-0.12.7 → datashare_python-0.12.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datashare-python"
-version = "0.12.7"
+version = "0.12.9"
 description = "Manage Python tasks and local resources in Datashare"
 authors = [
   { name = "Clément Doumouro", email = "cdoumouro@icij.org" },