py2docfx 0.1.22.dev2258230__py3-none-any.whl → 0.1.22.dev2270449__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/cachetools/__init__.py

@@ -5,7 +5,6 @@ __all__ = (
     "FIFOCache",
     "LFUCache",
     "LRUCache",
-    "MRUCache",
     "RRCache",
     "TLRUCache",
     "TTLCache",
@@ -13,7 +12,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "5.5.2"
+__version__ = "6.2.0"
 
 import collections
 import collections.abc
@@ -23,7 +22,6 @@ import random
 import time
 
 from . import keys
-from ._decorators import _cached_wrapper
 
 
 class _DefaultSize:
@@ -172,32 +170,78 @@ class FIFOCache(Cache):
 class LFUCache(Cache):
     """Least Frequently Used (LFU) cache implementation."""
 
+    class _Link:
+        __slots__ = ("count", "keys", "next", "prev")
+
+        def __init__(self, count):
+            self.count = count
+            self.keys = set()
+
+        def unlink(self):
+            next = self.next
+            prev = self.prev
+            prev.next = next
+            next.prev = prev
+
     def __init__(self, maxsize, getsizeof=None):
         Cache.__init__(self, maxsize, getsizeof)
-        self.__counter = collections.Counter()
+        self.__root = root = LFUCache._Link(0)  # sentinel
+        root.prev = root.next = root
+        self.__links = {}
 
     def __getitem__(self, key, cache_getitem=Cache.__getitem__):
         value = cache_getitem(self, key)
         if key in self:  # __missing__ may not store item
-            self.__counter[key] -= 1
+            self.__touch(key)
         return value
 
     def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
         cache_setitem(self, key, value)
-        self.__counter[key] -= 1
+        if key in self.__links:
+            return self.__touch(key)
+        root = self.__root
+        link = root.next
+        if link.count != 1:
+            link = LFUCache._Link(1)
+            link.next = root.next
+            root.next = link.next.prev = link
+            link.prev = root
+        link.keys.add(key)
+        self.__links[key] = link
 
     def __delitem__(self, key, cache_delitem=Cache.__delitem__):
         cache_delitem(self, key)
-        del self.__counter[key]
+        link = self.__links.pop(key)
+        link.keys.remove(key)
+        if not link.keys:
+            link.unlink()
 
     def popitem(self):
         """Remove and return the `(key, value)` pair least frequently used."""
-        try:
-            ((key, _),) = self.__counter.most_common(1)
-        except ValueError:
+        root = self.__root
+        curr = root.next
+        if curr is root:
             raise KeyError("%s is empty" % type(self).__name__) from None
-        else:
-            return (key, self.pop(key))
+        key = next(iter(curr.keys))  # remove an arbitrary element
+        return (key, self.pop(key))
+
+    def __touch(self, key):
+        """Increment use count"""
+        link = self.__links[key]
+        curr = link.next
+        if curr.count != link.count + 1:
+            if len(link.keys) == 1:
+                link.count += 1
+                return
+            curr = LFUCache._Link(link.count + 1)
+            curr.next = link.next
+            link.next = curr.next.prev = curr
+            curr.prev = link
+        curr.keys.add(key)
+        link.keys.remove(key)
+        if not link.keys:
+            link.unlink()
+        self.__links[key] = curr
 
 
 class LRUCache(Cache):
@@ -210,12 +254,12 @@ class LRUCache(Cache):
     def __getitem__(self, key, cache_getitem=Cache.__getitem__):
         value = cache_getitem(self, key)
         if key in self:  # __missing__ may not store item
-            self.__update(key)
+            self.__touch(key)
         return value
 
     def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
         cache_setitem(self, key, value)
-        self.__update(key)
+        self.__touch(key)
 
     def __delitem__(self, key, cache_delitem=Cache.__delitem__):
         cache_delitem(self, key)
@@ -230,70 +274,47 @@ class LRUCache(Cache):
         else:
             return (key, self.pop(key))
 
-    def __update(self, key):
+    def __touch(self, key):
+        """Mark as recently used"""
         try:
             self.__order.move_to_end(key)
         except KeyError:
             self.__order[key] = None
 
 
-class MRUCache(Cache):
-    """Most Recently Used (MRU) cache implementation."""
-
-    def __init__(self, maxsize, getsizeof=None):
-        from warnings import warn
-
-        warn("MRUCache is deprecated", DeprecationWarning, stacklevel=2)
-
-        Cache.__init__(self, maxsize, getsizeof)
-        self.__order = collections.OrderedDict()
-
-    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
-        value = cache_getitem(self, key)
-        if key in self:  # __missing__ may not store item
-            self.__update(key)
-        return value
-
-    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
-        cache_setitem(self, key, value)
-        self.__update(key)
-
-    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
-        cache_delitem(self, key)
-        del self.__order[key]
-
-    def popitem(self):
-        """Remove and return the `(key, value)` pair most recently used."""
-        try:
-            key = next(iter(self.__order))
-        except StopIteration:
-            raise KeyError("%s is empty" % type(self).__name__) from None
-        else:
-            return (key, self.pop(key))
-
-    def __update(self, key):
-        try:
-            self.__order.move_to_end(key, last=False)
-        except KeyError:
-            self.__order[key] = None
-
-
 class RRCache(Cache):
     """Random Replacement (RR) cache implementation."""
 
     def __init__(self, maxsize, choice=random.choice, getsizeof=None):
         Cache.__init__(self, maxsize, getsizeof)
         self.__choice = choice
+        self.__index = {}
+        self.__keys = []
 
     @property
     def choice(self):
         """The `choice` function used by the cache."""
         return self.__choice
 
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        cache_setitem(self, key, value)
+        if key not in self.__index:
+            self.__index[key] = len(self.__keys)
+            self.__keys.append(key)
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        cache_delitem(self, key)
+        index = self.__index.pop(key)
+        if index != len(self.__keys) - 1:
+            last = self.__keys[-1]
+            self.__keys[index] = last
+            self.__index[last] = index
+        self.__keys.pop()
+
     def popitem(self):
         """Remove and return a random `(key, value)` pair."""
         try:
-            key = self.__choice(list(self))
+            key = self.__choice(self.__keys)
         except IndexError:
             raise KeyError("%s is empty" % type(self).__name__) from None
         else:
@@ -636,11 +657,23 @@ _CacheInfo = collections.namedtuple(
 )
 
 
-def cached(cache, key=keys.hashkey, lock=None, info=False):
+def cached(cache, key=keys.hashkey, lock=None, condition=None, info=False):
     """Decorator to wrap a function with a memoizing callable that saves
     results in a cache.
 
     """
+    from ._cached import _wrapper
+
+    if isinstance(condition, bool):
+        from warnings import warn
+
+        warn(
+            "passing `info` as positional parameter is deprecated",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        info = condition
+        condition = None
 
     def decorator(func):
         if info:
@@ -659,80 +692,21 @@ def cached(cache, key=keys.hashkey, lock=None, info=False):
                 def make_info(hits, misses):
                     return _CacheInfo(hits, misses, 0, 0)
 
-            wrapper = _cached_wrapper(func, cache, key, lock, make_info)
+            return _wrapper(func, cache, key, lock, condition, info=make_info)
         else:
-            wrapper = _cached_wrapper(func, cache, key, lock, None)
-
-        wrapper.cache = cache
-        wrapper.cache_key = key
-        wrapper.cache_lock = lock
-
-        return functools.update_wrapper(wrapper, func)
+            return _wrapper(func, cache, key, lock, condition)
 
     return decorator
 
 
-def cachedmethod(cache, key=keys.methodkey, lock=None):
+def cachedmethod(cache, key=keys.methodkey, lock=None, condition=None):
     """Decorator to wrap a class or instance method with a memoizing
     callable that saves results in a cache.
 
     """
+    from ._cachedmethod import _wrapper
 
     def decorator(method):
-        if lock is None:
-
-            def wrapper(self, *args, **kwargs):
-                c = cache(self)
-                if c is None:
-                    return method(self, *args, **kwargs)
-                k = key(self, *args, **kwargs)
-                try:
-                    return c[k]
-                except KeyError:
-                    pass  # key not found
-                v = method(self, *args, **kwargs)
-                try:
-                    c[k] = v
-                except ValueError:
-                    pass  # value too large
-                return v
-
-            def clear(self):
-                c = cache(self)
-                if c is not None:
-                    c.clear()
-
-        else:
-
-            def wrapper(self, *args, **kwargs):
-                c = cache(self)
-                if c is None:
-                    return method(self, *args, **kwargs)
-                k = key(self, *args, **kwargs)
-                try:
-                    with lock(self):
-                        return c[k]
-                except KeyError:
-                    pass  # key not found
-                v = method(self, *args, **kwargs)
-                # in case of a race, prefer the item already in the cache
-                try:
-                    with lock(self):
-                        return c.setdefault(k, v)
-                except ValueError:
-                    return v  # value too large
-
-            def clear(self):
-                c = cache(self)
-                if c is not None:
-                    with lock(self):
-                        c.clear()
-
-        wrapper.cache = cache
-        wrapper.cache_key = key
-        wrapper.cache_lock = lock
-        wrapper.cache_clear = clear
-
-        return functools.update_wrapper(wrapper, method)
+        return _wrapper(method, cache, key, lock, condition)
 
     return decorator

py2docfx/venv/venv1/Lib/site-packages/cachetools/{_decorators.py → _cached.py}

@@ -1,7 +1,53 @@
-"""Extensible memoizing decorator helpers."""
+"""Function decorator helpers."""
 
+import functools
 
-def _cached_locked_info(func, cache, key, lock, info):
+
+def _condition_info(func, cache, key, lock, cond, info):
+    hits = misses = 0
+    pending = set()
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        with lock:
+            cond.wait_for(lambda: k not in pending)
+            try:
+                result = cache[k]
+                hits += 1
+                return result
+            except KeyError:
+                pending.add(k)
+                misses += 1
+        try:
+            v = func(*args, **kwargs)
+            with lock:
+                try:
+                    cache[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock:
+                pending.remove(k)
+                cond.notify_all()
+
+    def cache_clear():
+        nonlocal hits, misses
+        with lock:
+            cache.clear()
+            hits = misses = 0
+
+    def cache_info():
+        with lock:
+            return info(hits, misses)
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = cache_info
+    return wrapper
+
+
+def _locked_info(func, cache, key, lock, info):
     hits = misses = 0
 
     def wrapper(*args, **kwargs):
@@ -37,7 +83,7 @@ def _cached_locked_info(func, cache, key, lock, info):
     return wrapper
 
 
-def _cached_unlocked_info(func, cache, key, info):
+def _unlocked_info(func, cache, key, info):
     hits = misses = 0
 
     def wrapper(*args, **kwargs):
@@ -83,7 +129,40 @@ def _uncached_info(func, info):
     return wrapper
 
 
-def _cached_locked(func, cache, key, lock):
+def _condition(func, cache, key, lock, cond):
+    pending = set()
+
+    def wrapper(*args, **kwargs):
+        k = key(*args, **kwargs)
+        with lock:
+            cond.wait_for(lambda: k not in pending)
+            try:
+                result = cache[k]
+                return result
+            except KeyError:
+                pending.add(k)
+        try:
+            v = func(*args, **kwargs)
+            with lock:
+                try:
+                    cache[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock:
+                pending.remove(k)
+                cond.notify_all()
+
+    def cache_clear():
+        with lock:
+            cache.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _locked(func, cache, key, lock):
     def wrapper(*args, **kwargs):
         k = key(*args, **kwargs)
         with lock:
@@ -107,7 +186,7 @@ def _cached_locked(func, cache, key, lock):
     return wrapper
 
 
-def _cached_unlocked(func, cache, key):
+def _unlocked(func, cache, key):
     def wrapper(*args, **kwargs):
         k = key(*args, **kwargs)
         try:
@@ -133,20 +212,34 @@ def _uncached(func):
     return wrapper
 
 
-def _cached_wrapper(func, cache, key, lock, info):
+def _wrapper(func, cache, key, lock=None, cond=None, info=None):
     if info is not None:
         if cache is None:
             wrapper = _uncached_info(func, info)
-        elif lock is None:
-            wrapper = _cached_unlocked_info(func, cache, key, info)
+        elif cond is not None and lock is not None:
+            wrapper = _condition_info(func, cache, key, lock, cond, info)
+        elif cond is not None:
+            wrapper = _condition_info(func, cache, key, cond, cond, info)
+        elif lock is not None:
+            wrapper = _locked_info(func, cache, key, lock, info)
         else:
-            wrapper = _cached_locked_info(func, cache, key, lock, info)
+            wrapper = _unlocked_info(func, cache, key, info)
     else:
         if cache is None:
             wrapper = _uncached(func)
-        elif lock is None:
-            wrapper = _cached_unlocked(func, cache, key)
+        elif cond is not None and lock is not None:
+            wrapper = _condition(func, cache, key, lock, cond)
+        elif cond is not None:
+            wrapper = _condition(func, cache, key, cond, cond)
+        elif lock is not None:
+            wrapper = _locked(func, cache, key, lock)
         else:
-            wrapper = _cached_locked(func, cache, key, lock)
+            wrapper = _unlocked(func, cache, key)
         wrapper.cache_info = None
-    return wrapper
+
+    wrapper.cache = cache
+    wrapper.cache_key = key
+    wrapper.cache_lock = lock if lock is not None else cond
+    wrapper.cache_condition = cond
+
+    return functools.update_wrapper(wrapper, func)

py2docfx/venv/venv1/Lib/site-packages/cachetools/_cachedmethod.py

@@ -0,0 +1,128 @@
+"""Method decorator helpers."""
+
+import functools
+import weakref
+
+
+def warn_cache_none():
+    from warnings import warn
+
+    warn(
+        "returning `None` from `cache(self)` is deprecated",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+
+def _condition(method, cache, key, lock, cond):
+    pending = weakref.WeakKeyDictionary()
+
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            warn_cache_none()
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        with lock(self):
+            p = pending.setdefault(self, set())
+            cond(self).wait_for(lambda: k not in p)
+            try:
+                return c[k]
+            except KeyError:
+                p.add(k)
+        try:
+            v = method(self, *args, **kwargs)
+            with lock(self):
+                try:
+                    c[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock(self):
+                pending[self].remove(k)
+                cond(self).notify_all()
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            with lock(self):
+                c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _locked(method, cache, key, lock):
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            warn_cache_none()
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        with lock(self):
+            try:
+                return c[k]
+            except KeyError:
+                pass  # key not found
+        v = method(self, *args, **kwargs)
+        # in case of a race, prefer the item already in the cache
+        with lock(self):
+            try:
+                return c.setdefault(k, v)
+            except ValueError:
+                return v  # value too large
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            with lock(self):
+                c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _unlocked(method, cache, key):
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            warn_cache_none()
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        try:
+            return c[k]
+        except KeyError:
+            pass  # key not found
+        v = method(self, *args, **kwargs)
+        try:
+            c[k] = v
+        except ValueError:
+            pass  # value too large
+        return v
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _wrapper(method, cache, key, lock=None, cond=None):
+    if cond is not None and lock is not None:
+        wrapper = _condition(method, cache, key, lock, cond)
+    elif cond is not None:
+        wrapper = _condition(method, cache, key, cond, cond)
+    elif lock is not None:
+        wrapper = _locked(method, cache, key, lock)
+    else:
+        wrapper = _unlocked(method, cache, key)
+
+    wrapper.cache = cache
+    wrapper.cache_key = key
+    wrapper.cache_lock = lock if lock is not None else cond
+    wrapper.cache_condition = cond
+
+    return functools.update_wrapper(wrapper, method)

py2docfx/venv/venv1/Lib/site-packages/cachetools/func.py

@@ -1,17 +1,14 @@
 """`functools.lru_cache` compatible memoizing function decorators."""
 
-__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "mru_cache", "rr_cache", "ttl_cache")
+__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "rr_cache", "ttl_cache")
 
+import functools
 import math
 import random
 import time
+from threading import Condition
 
-try:
-    from threading import RLock
-except ImportError:  # pragma: no cover
-    from dummy_threading import RLock
-
-from . import FIFOCache, LFUCache, LRUCache, MRUCache, RRCache, TTLCache
+from . import FIFOCache, LFUCache, LRUCache, RRCache, TTLCache
 from . import cached
 from . import keys
 
@@ -28,7 +25,7 @@ class _UnboundTTLCache(TTLCache):
 def _cache(cache, maxsize, typed):
     def decorator(func):
         key = keys.typedkey if typed else keys.hashkey
-        wrapper = cached(cache=cache, key=key, lock=RLock(), info=True)(func)
+        wrapper = cached(cache=cache, key=key, condition=Condition(), info=True)(func)
         wrapper.cache_parameters = lambda: {"maxsize": maxsize, "typed": typed}
         return wrapper
 
@@ -77,23 +74,6 @@ def lru_cache(maxsize=128, typed=False):
         return _cache(LRUCache(maxsize), maxsize, typed)
 
 
-def mru_cache(maxsize=128, typed=False):
-    """Decorator to wrap a function with a memoizing callable that saves
-    up to `maxsize` results based on a Most Recently Used (MRU)
-    algorithm.
-    """
-    from warnings import warn
-
-    warn("@mru_cache is deprecated", DeprecationWarning, stacklevel=2)
-
-    if maxsize is None:
-        return _cache({}, None, typed)
-    elif callable(maxsize):
-        return _cache(MRUCache(128), 128, typed)(maxsize)
-    else:
-        return _cache(MRUCache(maxsize), maxsize, typed)
-
-
 def rr_cache(maxsize=128, choice=random.choice, typed=False):
     """Decorator to wrap a function with a memoizing callable that saves
     up to `maxsize` results based on a Random Replacement (RR)

py2docfx/venv/venv1/Lib/site-packages/certifi/__init__.py

@@ -1,4 +1,4 @@
 from .core import contents, where
 
 __all__ = ["contents", "where"]
-__version__ = "2025.08.03"
+__version__ = "2025.10.05"

py2docfx/venv/venv1/Lib/site-packages/cryptography/__about__.py

@@ -10,7 +10,7 @@ __all__ = [
     "__version__",
 ]
 
-__version__ = "46.0.1"
+__version__ = "46.0.2"
 
 
 __author__ = "The Python Cryptographic Authority and individual contributors"