laixintao-prometheus-http-sd-39

diff --git a/prometheus_http_sd/decroator.py b/prometheus_http_sd/decroator.py
new file mode 100644
index 0000000..a132df4
--- /dev/null
+++ b/prometheus_http_sd/decroator.py
@@ -0,0 +1,180 @@
+"""Timeout and result caching decorator.
+
+The module name is intentionally ``decroator`` for compatibility with the
+original public interface.
+"""
+
+import functools
+import threading
+import time
+
+
+__all__ = ["TimeoutDecorator", "TimeoutException"]
+
+
+class TimeoutException(Exception):
+    """Raised when a decorated call does not finish in time."""
+
+
+class _CacheEntry:
+    def __init__(self):
+        self.done = threading.Event()
+        self.result = None
+        self.error = None
+        self.completed_at = None
+
+
+class TimeoutDecorator:
+    """Run decorated calls in the background and cache completed results.
+
+    A timed out call does not cancel the work (Python cannot safely cancel an
+    arbitrary thread).  The worker is daemonised, so it also cannot prevent
+    the process from exiting.  There is only one worker for a cache key; calls
+    arriving while it is running wait for that same worker.
+    """
+
+    def __init__(
+        self,
+        timeout,
+        cache_time=0,
+        garbage_collection_interval=60,
+        garbage_collection_count=100,
+    ):
+        self.timeout = timeout
+        self.cache_time = cache_time
+        self.garbage_collection_interval = garbage_collection_interval
+        self.garbage_collection_count = garbage_collection_count
+        self.thread_cache = {}
+        self._lock = threading.RLock()
+        self._last_garbage_collection = time.monotonic()
+        self._call_count = 0
+        self._calls_since_collection = 0
+        self._function = None
+
+    @staticmethod
+    def _freeze(value):
+        """Turn common unhashable argument values into stable cache keys."""
+        if isinstance(value, dict):
+            return tuple(sorted((TimeoutDecorator._freeze(k),
+                                 TimeoutDecorator._freeze(v))
+                                for k, v in value.items()))
+        if isinstance(value, (list, tuple)):
+            return tuple(TimeoutDecorator._freeze(v) for v in value)
+        if isinstance(value, set):
+            return frozenset(TimeoutDecorator._freeze(v) for v in value)
+        try:
+            hash(value)
+        except TypeError:
+            return repr(value)
+        return value
+
+    def _cal_cache_key(self, arg):
+        """Return the cache key for the (usual) single argument call."""
+        return self._freeze(arg)
+
+    def _call_key(self, args, kwargs):
+        if len(args) == 1 and not kwargs:
+            return self._cal_cache_key(args[0])
+        return self._freeze((args, kwargs))
+
+    def __call__(self, function):
+        self._function = function
+
+        @functools.wraps(function)
+        def wrapped(*args, **kwargs):
+            return self._invoke(function, args, kwargs)
+
+        # This makes either the decorator instance or the wrapped callable
+        # useful to code which needs to inspect or manually collect the cache.
+        wrapped.thread_cache = self.thread_cache
+        wrapped._cache_garbage_collection = self._cache_garbage_collection
+        wrapped._cal_cache_key = self._cal_cache_key
+        wrapped.timeout_decorator = self
+        return wrapped
+
+    def _invoke(self, function, args, kwargs):
+        key = self._call_key(args, kwargs)
+        now = time.monotonic()
+        start_worker = False
+        with self._lock:
+            self._call_count += 1
+            self._calls_since_collection += 1
+            self._maybe_collect(now)
+            entry = self.thread_cache.get(key)
+            if entry is not None and entry.done.is_set():
+                # Expiration is measured from completion, rather than from
+                # when the possibly slow computation was started.
+                if (entry.completed_at is not None and
+                        now - entry.completed_at >= self.cache_time):
+                    del self.thread_cache[key]
+                    entry = None
+                elif entry.error is not None:
+                    del self.thread_cache[key]
+                    entry = None
+                else:
+                    return entry.result
+
+            if entry is None:
+                entry = _CacheEntry()
+                self.thread_cache[key] = entry
+                start_worker = True
+
+        if start_worker:
+            worker = threading.Thread(
+                target=self._run,
+                args=(function, args, kwargs, key, entry),
+                daemon=True,
+            )
+            worker.start()
+
+        if entry.done.wait(self.timeout):
+            if entry.error is not None:
+                raise entry.error
+            return entry.result
+        raise TimeoutException(
+            "function {!r} exceeded timeout of {} seconds".format(
+                function.__name__, self.timeout
+            )
+        )
+
+    def _run(self, function, args, kwargs, key, entry):
+        try:
+            entry.result = function(*args, **kwargs)
+        except BaseException as error:
+            entry.error = error
+        finally:
+            entry.completed_at = time.monotonic()
+            entry.done.set()
+            # Failed computations are not useful cache entries.  Remove them
+            # only after notifying waiters, and only if this is still our
+            # entry (a future call may already have replaced it).
+            if entry.error is not None:
+                with self._lock:
+                    if self.thread_cache.get(key) is entry:
+                        del self.thread_cache[key]
+
+    def _maybe_collect(self, now=None):
+        if now is None:
+            now = time.monotonic()
+        interval = self.garbage_collection_interval
+        interval_due = (interval is not None and interval >= 0 and
+         
… [962 more characters]

diff --git a/prometheus_http_sd/decroator.py b/prometheus_http_sd/decroator.py
new file mode 100644
index 0000000..398d97a
--- /dev/null
+++ b/prometheus_http_sd/decroator.py
@@ -0,0 +1,181 @@
+"""Timeout and short-lived caching decorator.
+
+The name of this module is intentionally ``decroator`` for compatibility with
+older users of the project.
+"""
+
+import functools
+import threading
+import time
+
+
+class TimeoutException(Exception):
+    """Raised when a decorated call does not finish within its timeout."""
+
+
+class _CacheEntry:
+    def __init__(self):
+        self.event = threading.Event()
+        self.result = None
+        self.error = None
+        self.completed_at = None
+
+
+class TimeoutDecorator:
+    """Run calls in background threads, with a timeout and result cache.
+
+    A timed-out call is deliberately not cancelled: Python cannot safely stop
+    an arbitrary thread.  Its result is consequently still made available to
+    later calls once the worker finishes.
+    """
+
+    def __init__(
+        self,
+        timeout,
+        cache_time=0,
+        garbage_collection_interval=60,
+        garbage_collection_count=100,
+    ):
+        self.timeout = timeout
+        self.cache_time = cache_time
+        self.garbage_collection_interval = garbage_collection_interval
+        self.garbage_collection_count = garbage_collection_count
+        self.thread_cache = {}
+        self._lock = threading.RLock()
+        self._calls_since_gc = 0
+        self._last_gc = time.monotonic()
+
+    @staticmethod
+    def _hashable(value):
+        """Return a stable, hashable representation of common call values."""
+        try:
+            hash(value)
+            return value
+        except TypeError:
+            if isinstance(value, dict):
+                # A frozenset avoids relying on keys being mutually
+                # orderable (for example, an int and a string).
+                return frozenset((
+                    TimeoutDecorator._hashable(k),
+                    TimeoutDecorator._hashable(v),
+                ) for k, v in value.items())
+            if isinstance(value, (list, tuple)):
+                return tuple(TimeoutDecorator._hashable(v) for v in value)
+            if isinstance(value, set):
+                return frozenset(TimeoutDecorator._hashable(v) for v in value)
+            return repr(value)
+
+    def _cal_cache_key(self, arg):
+        """Calculate the cache key used for an argument.
+
+        This public-ish method is retained with its historical spelling; it is
+        also useful to callers inspecting ``thread_cache``.
+        """
+        return self._hashable(arg)
+
+    def _call_key(self, args, kwargs):
+        if len(args) == 1 and not kwargs:
+            return self._cal_cache_key(args[0])
+        return self._cal_cache_key((args, tuple(sorted(kwargs.items()))))
+
+    def __call__(self, function):
+        @functools.wraps(function)
+        def wrapped(*args, **kwargs):
+            key = self._call_key(args, kwargs)
+            now = time.monotonic()
+            with self._lock:
+                self._maybe_collect(now)
+                entry = self.thread_cache.get(key)
+                if entry is None:
+                    entry = _CacheEntry()
+                    self.thread_cache[key] = entry
+                    worker = threading.Thread(
+                        target=self._run,
+                        args=(function, args, kwargs, key, entry),
+                        daemon=True,
+                    )
+                    worker.start()
+                elif entry.completed_at is not None:
+                    if now - entry.completed_at >= self.cache_time:
+                        # Remove this exact entry.  A worker from an older
+                        # generation can never replace a newer one.
+                        del self.thread_cache[key]
+                        entry = _CacheEntry()
+                        self.thread_cache[key] = entry
+                        worker = threading.Thread(
+                            target=self._run,
+                            args=(function, args, kwargs, key, entry),
+                            daemon=True,
+                        )
+                        worker.start()
+                    else:
+                        worker = None
+                else:
+                    worker = None
+
+            # Waiting outside the lock is important both for prompt timeouts
+            # and so another caller can inspect/cache the completed result.
+            if not entry.event.wait(self.timeout):
+                raise TimeoutException(
+                    "function call exceeded timeout of {} seconds".format(
+                        self.timeout
+                    )
+                )
+            if entry.error is not None:
+                raise entry.error
+            return entry.result
+
+        return wrapped
+
+    def _run(self, function, args, kwargs, key, entry):
+        try:
+            result = function(*args, **kwargs)
+        except BaseException as error:
+            with self._lock:
+                entry.error = error
+                if self.thread_cache.get(key) is entry:
+                    # Failed calls are not useful cache entries.
+                    del self.thread_cache[key]
+                entry.event.set()
+            return
+
+        with self._lock:
+            entry.result = result
+            entry.completed_at = time.monotonic()
+            # Identity check prevents a late, timed-out computation from
+            # overwriting a fresh computation started after expiration.
+            if self.thread_cache.get(key) is not entry:
+                entry.event.set()
+                return
+            entry.event.set()
+
+    def _maybe_collect(self, now=None):
+        self._calls_since_gc += 1
+        now = time.monotonic() if now is None else now
+        due_to_count = (
+            s
… [1180 more characters]

diff --git a/prometheus_http_sd/decroator.py b/prometheus_http_sd/decroator.py
new file mode 100644
index 0000000..e097c9b
--- /dev/null
+++ b/prometheus_http_sd/decroator.py
@@ -0,0 +1,160 @@
+"""Timeouting and caching decorator.
+
+The module name is intentionally ``decroator`` for backwards compatibility
+with the public interface of the project.
+"""
+
+import functools
+import threading
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+from dataclasses import dataclass
+from time import monotonic
+
+
+class TimeoutException(Exception):
+    """Raised when a decorated call does not finish in time."""
+
+
+@dataclass
+class _CacheEntry:
+    future: object
+    completed_at: object = None
+
+
+class TimeoutDecorator:
+    """Decorate a function with a timeout and a result cache.
+
+    A timed out invocation is deliberately not cancelled: the worker is
+    allowed to finish and its result is then put in the cache.  This is useful
+    for expensive, non-idempotent operations and also means that a later call
+    can use the result of work which the original caller stopped waiting for.
+    """
+
+    def __init__(
+        self,
+        timeout=1,
+        cache_time=60,
+        garbage_collection_interval=60,
+        garbage_collection_count=100,
+    ):
+        self.timeout = timeout
+        self.cache_time = cache_time
+        self.garbage_collection_interval = garbage_collection_interval
+        self.garbage_collection_count = garbage_collection_count
+        self.thread_cache = {}
+        self._lock = threading.RLock()
+        self._executor = ThreadPoolExecutor()
+        self._completed_calls = 0
+        self._last_gc = monotonic()
+
+    def _cal_cache_key(self, arg):
+        """Return the cache key for the (usual) single argument call."""
+        try:
+            hash(arg)
+        except TypeError:
+            return self._freeze(arg)
+        return arg
+
+    @classmethod
+    def _freeze(cls, value):
+        """Make common unhashable argument types usable as cache keys."""
+        if isinstance(value, dict):
+            return tuple(
+                sorted(
+                    (cls._freeze(k), cls._freeze(v))
+                    for k, v in value.items()
+                )
+            )
+        if isinstance(value, (list, tuple)):
+            return tuple(cls._freeze(item) for item in value)
+        if isinstance(value, (set, frozenset)):
+            return frozenset(cls._freeze(item) for item in value)
+        try:
+            hash(value)
+        except TypeError:
+            return repr(value)
+        return value
+
+    def _key_for_call(self, args, kwargs):
+        if len(args) == 1 and not kwargs:
+            return self._cal_cache_key(args[0])
+        return self._cal_cache_key((args, tuple(sorted(kwargs.items()))))
+
+    def _is_expired(self, entry, now=None):
+        if entry.completed_at is None:
+            return False
+        if self.cache_time is None:
+            return False
+        if now is None:
+            now = monotonic()
+        return now - entry.completed_at >= self.cache_time
+
+    def _finished(self, key, entry, future):
+        """Store a successful result, but never overwrite a newer call."""
+        with self._lock:
+            current = self.thread_cache.get(key)
+            if current is not entry or current.future is not future:
+                return
+            if future.cancelled() or future.exception() is not None:
+                # Exceptions are not cached; the next call gets a chance to
+                # retry.  (The waiting caller still receives the exception.)
+                self.thread_cache.pop(key, None)
+                return
+            entry.completed_at = monotonic()
+            self._completed_calls += 1
+            # This is intentionally opportunistic.  Explicit callers can
+            # always invoke _cache_garbage_collection themselves.
+            if self.garbage_collection_count and (
+                self._completed_calls % self.garbage_collection_count == 0
+            ):
+                self._cache_garbage_collection_locked()
+
+    def _cache_garbage_collection_locked(self):
+        now = monotonic()
+        self._last_gc = now
+        expired = [
+            key for key, entry in self.thread_cache.items()
+            if self._is_expired(entry, now)
+        ]
+        for key in expired:
+            self.thread_cache.pop(key, None)
+
+    def _cache_garbage_collection(self):
+        """Remove completed entries whose own lifetime has elapsed."""
+        with self._lock:
+            self._cache_garbage_collection_locked()
+
+    def __call__(self, function):
+        @functools.wraps(function)
+        def wrapped(*args, **kwargs):
+            key = self._key_for_call(args, kwargs)
+            with self._lock:
+                if (
+                    self.garbage_collection_interval
+                    and monotonic() - self._last_gc
+                    >= self.garbage_collection_interval
+                ):
+                    self._cache_garbage_collection_locked()
+                entry = self.thread_cache.get(key)
+                if entry is not None and self._is_expired(entry):
+                    self.thread_cache.pop(key, None)
+                    entry = None
+                if entry is None:
+                    future = self._executor.submit(function, *args, **kwargs)
+                    entry = _CacheEntry(future)
+                    self.thread_cache[key] = entry
+                    future.add_done_callback(
+                        lambda completed: self._finished(key, entry, completed)
+                    )
+                future = entry.future
+
+            try:
+                return future.result(timeout=self.timeout)
+            except TimeoutError:
+                raise TimeoutException(
+                    "function {} exceeded timeout of {} seconds".format(
+                        functi
… [103 more characters]

diff --git a/prometheus_http_sd/decroator.py b/prometheus_http_sd/decroator.py
new file mode 100644
index 0000000..8d3efc5
--- /dev/null
+++ b/prometheus_http_sd/decroator.py
@@ -0,0 +1,148 @@
+"""A timeout decorator with a small, time-limited result cache.
+
+The module name is intentionally ``decroator`` for compatibility with the
+public interface used by this project.
+"""
+
+import functools
+import threading
+import time
+from concurrent.futures import (
+    ThreadPoolExecutor,
+    TimeoutError as FutureTimeoutError,
+)
+
+
+class TimeoutException(Exception):
+    """Raised when a decorated call does not finish within its timeout."""
+
+
+class _CacheEntry:
+    def __init__(self, future):
+        self.future = future
+        self.completed_at = None
+        self.result = None
+
+
+class TimeoutDecorator:
+    """Decorate functions with a timeout and cache successful results.
+
+    A timed-out function is deliberately not cancelled: Python cannot safely
+    stop an arbitrary running thread.  Its future is retained, allowing the
+    result to be cached when the work eventually finishes.
+    """
+
+    def __init__(
+        self,
+        timeout,
+        cache_time,
+        garbage_collection_interval=60,
+        garbage_collection_count=100,
+    ):
+        self.timeout = timeout
+        self.cache_time = cache_time
+        self.garbage_collection_interval = garbage_collection_interval
+        self.garbage_collection_count = garbage_collection_count
+        self.thread_cache = {}
+        self._lock = threading.RLock()
+        self._executor = ThreadPoolExecutor()
+        self._last_garbage_collection = time.monotonic()
+        self._calls_since_garbage_collection = 0
+
+    def _cal_cache_key(self, *args, **kwargs):
+        """Return the key used by the cache for a call.
+
+        The common one-argument case intentionally uses the argument itself;
+        this also makes the cache easy to inspect through ``thread_cache``.
+        Multiple arguments and keyword arguments are represented as a tuple.
+        """
+        if len(args) == 1 and not kwargs:
+            key = args[0]
+        else:
+            key = (args, tuple(sorted(kwargs.items())))
+        try:
+            hash(key)
+        except TypeError:
+            # Keep the decorator useful for ordinary unhashable arguments.
+            # repr is stable for the usual list/dict argument values and is
+            # preferable to making the call fail merely because caching is on.
+            key = ("__unhashable__", repr(key))
+        return key
+
+    def _cache_garbage_collection(self):
+        """Remove every completed entry whose cache lifetime has elapsed."""
+        now = time.monotonic()
+        with self._lock:
+            for key, entry in list(self.thread_cache.items()):
+                if (
+                    entry.completed_at is not None
+                    and now - entry.completed_at >= self.cache_time
+                ):
+                    # Do not remove a newer computation that replaced this
+                    # entry while an old worker was finishing.
+                    self.thread_cache.pop(key, None)
+            self._last_garbage_collection = now
+            self._calls_since_garbage_collection = 0
+
+    def _maybe_collect(self):
+        self._calls_since_garbage_collection += 1
+        interval = self.garbage_collection_interval
+        count = self.garbage_collection_count
+        due_to_time = (
+            interval is not None
+            and time.monotonic() - self._last_garbage_collection >= interval
+        )
+        due_to_count = count is not None and count > 0 and (
+            self._calls_since_garbage_collection >= count
+        )
+        if due_to_time or due_to_count:
+            self._cache_garbage_collection()
+
+    def __call__(self, function):
+        @functools.wraps(function)
+        def wrapped(*args, **kwargs):
+            key = self._cal_cache_key(*args, **kwargs)
+            self._maybe_collect()
+
+            with self._lock:
+                entry = self.thread_cache.get(key)
+                now = time.monotonic()
+                if entry is not None and entry.completed_at is not None:
+                    if now - entry.completed_at < self.cache_time:
+                        return entry.result
+                    self.thread_cache.pop(key, None)
+                    entry = None
+
+                if entry is None:
+                    future = self._executor.submit(function, *args, **kwargs)
+                    entry = _CacheEntry(future)
+                    self.thread_cache[key] = entry
+                    future.add_done_callback(
+                        lambda done, k=key, e=entry: self._finished(k, e, done)
+                    )
+                future = entry.future
+
+            try:
+                return future.result(timeout=self.timeout)
+            except FutureTimeoutError:
+                raise TimeoutException(
+                    "function did not finish within {} seconds".format(
+                        self.timeout
+                    )
+                )
+
+        return wrapped
+
+    def _finished(self, key, entry, future):
+        """Publish a successful worker result, without clobbering replacements."""
+        if future.cancelled() or future.exception() is not None:
+            with self._lock:
+                if self.thread_cache.get(key) is entry:
+                    self.thread_cache.pop(key, None)
+            return
+
+        result = future.result()
+        with self._lock:
+            if self.thread_cache.get(key) is entry:
+                entry.result = result
+                entry.completed_at = time.monotonic()

diff --git a/prometheus_http_sd/decroator.py b/prometheus_http_sd/decroator.py
new file mode 100644
index 0000000..7028df8
--- /dev/null
+++ b/prometheus_http_sd/decroator.py
@@ -0,0 +1,172 @@
+"""Timeout decorator with per-argument result caching and garbage collection."""
+
+import functools
+import threading
+import time
+
+__all__ = ["TimeoutDecorator", "TimeoutException"]
+
+
+class TimeoutException(Exception):
+    """Raised when a decorated call does not finish within the timeout."""
+
+
+_PENDING = object()  # sentinel: work started but no result yet
+
+
+class TimeoutDecorator:
+    """Decorator factory that enforces a timeout and caches results.
+
+    Calls that exceed ``timeout`` seconds raise :class:`TimeoutException`
+    while the work keeps running in a background thread.  Once the work
+    finishes, its result is cached for ``cache_time`` seconds so later
+    calls can return it without recomputing.
+    """
+
+    def __init__(
+        self,
+        timeout=5,
+        cache_time=60,
+        garbage_collection_interval=60,
+        garbage_collection_count=100,
+    ):
+        self.timeout = timeout
+        self.cache_time = cache_time
+        self.garbage_collection_interval = garbage_collection_interval
+        self.garbage_collection_count = garbage_collection_count
+        self.thread_cache = {}
+        self._lock = threading.Lock()
+        self._call_count = 0
+        self._last_gc = time.monotonic()
+
+    # ------------------------------------------------------------------ #
+    # cache key handling
+    # ------------------------------------------------------------------ #
+    def _cal_cache_key(self, *args, **kwargs):
+        """Build a hashable cache key from the call arguments."""
+        if kwargs:
+            return (args, tuple(sorted(kwargs.items())))
+        if len(args) == 1:
+            return args[0]
+        return args
+
+    # ------------------------------------------------------------------ #
+    # garbage collection
+    # ------------------------------------------------------------------ #
+    def _cache_garbage_collection(self):
+        """Remove expired cache entries, keeping fresh ones."""
+        now = time.monotonic()
+        with self._lock:
+            for key in list(self.thread_cache):
+                entry = self.thread_cache[key]
+                result = entry.get("result", _PENDING)
+                if result is _PENDING:
+                    # Still-running work: drop it only if the thread died
+                    # without producing a result.
+                    thread = entry.get("thread")
+                    if thread is not None and not thread.is_alive():
+                        del self.thread_cache[key]
+                    continue
+                if now - entry.get("time", now) >= self.cache_time:
+                    del self.thread_cache[key]
+        self._last_gc = time.monotonic()
+        self._call_count = 0
+
+    def _maybe_garbage_collection(self):
+        """Run garbage collection when the interval or count is reached."""
+        now = time.monotonic()
+        if (
+            now - self._last_gc >= self.garbage_collection_interval
+            or self._call_count >= self.garbage_collection_count
+        ):
+            self._cache_garbage_collection()
+
+    # ------------------------------------------------------------------ #
+    # main logic
+    # ------------------------------------------------------------------ #
+    def __call__(self, func):
+        decorator = self
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return decorator._execute(func, args, kwargs)
+
+        wrapper.timeout_decorator = self
+        return wrapper
+
+    def _execute(self, func, args, kwargs):
+        key = self._cal_cache_key(*args, **kwargs)
+        with self._lock:
+            self._call_count += 1
+        self._maybe_garbage_collection()
+
+        now = time.monotonic()
+        running_thread = None
+        with self._lock:
+            entry = self.thread_cache.get(key)
+            if entry is not None:
+                result = entry.get("result", _PENDING)
+                if result is _PENDING:
+                    thread = entry.get("thread")
+                    if thread is not None and thread.is_alive():
+                        running_thread = thread
+                    else:
+                        del self.thread_cache[key]
+                elif now - entry.get("time", now) < self.cache_time:
+                    return result
+                else:
+                    del self.thread_cache[key]
+
+        if running_thread is not None:
+            # Previous call timed out but is still working; wait for it.
+            running_thread.join(self.timeout)
+            if running_thread.is_alive():
+                raise TimeoutException(
+                    "function call timed out after %s seconds" % self.timeout
+                )
+            return self._finished_result(key)
+
+        return self._start_and_wait(func, args, kwargs, key)
+
+    def _start_and_wait(self, func, args, kwargs, key):
+        thread = threading.Thread(
+            target=self._worker, args=(func, args, kwargs, key), daemon=True
+        )
+        with self._lock:
+            self.thread_cache[key] = {"thread": thread, "result": _PENDING}
+        thread.start()
+        thread.join(self.timeout)
+        if thread.is_alive():
+            raise TimeoutException(
+                "function call timed out after %s seconds" % self.timeout
+            )
+        return self._finished_result(key)
+
+    def _worker(self, func, args, kwargs, key):
+        thread = threading.current_thread()
+        try:
+            result = func(*args, **kwargs)
+        except Exception as exc:  # noqa: BLE001 - propagate to the caller
+            result = exc
+        with self._lock:
+            current = self.thread_cache.get(key)
+            # Only
… [797 more characters]