Videre

linedance-app/venv/lib/python3.12/site-packages/librosa/_cache.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Function caching"""
+
+import os
+from typing import Any, Callable, TypeVar
+from joblib import Memory
+from decorator import FunctionMaker
+
+
+def _decorator_apply(dec, func):
+    return FunctionMaker.create(
+        func,
+        "return decfunc(%(shortsignature)s)",
+        dict(decfunc=dec(func)),
+        __wrapped__=func,
+    )
+
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+
+class CacheManager(object):
+    """The librosa cache manager class wraps joblib.Memory
+    with a __call__ attribute, so that it may act as a function.
+
+    Additionally, it provides a caching level filter, so that
+    different functions can be cached or not depending on the user's
+    preference for speed vs. storage usage.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        level = kwargs.pop("level", 10)
+
+        # Initialize the memory object
+        self.memory: Memory = Memory(*args, **kwargs)
+        # The level parameter controls which data we cache
+        # smaller numbers mean less caching
+        self.level: int = level
+
+    def __call__(self, level: int) -> Callable[[_F], _F]:
+        """
+        Cache with an explicitly defined level.
+
+        Example usage:
+
+        @cache(level=2)
+        def semi_important_function(some_arguments):
+            ...
+        """
+
+        def wrapper(function):
+            """Add an input/output cache to the specified function."""
+            if self.memory.location is not None and self.level >= level:
+                return _decorator_apply(self.memory.cache, function)
+
+            else:
+                return function
+
+        return wrapper
+
+    def clear(self, *args: Any, **kwargs: Any) -> None:
+        """Clear the cache"""
+        self.memory.clear(*args, **kwargs)
+
+    def eval(self, *args: Any, **kwargs: Any) -> Any:
+        """Evaluate a function"""
+        return self.memory.eval(*args, **kwargs)
+
+    def format(self, *args: Any, **kwargs: Any) -> Any:
+        """Return the formatted representation of an object"""
+        return self.memory.format(*args, **kwargs)
+
+    def reduce_size(self, *args: Any, **kwargs: Any) -> None:
+        """Reduce the size of the cache"""
+        self.memory.reduce_size(*args, **kwargs)  # pragma: no cover
+
+    def warn(self, *args: Any, **kwargs: Any) -> None:
+        """Raise a warning"""
+        self.memory.warn(*args, **kwargs)  # pragma: no cover
+
+
+# Instantiate the cache from the environment
+cache: CacheManager = CacheManager(
+    os.environ.get("LIBROSA_CACHE_DIR", None),
+    mmap_mode=os.environ.get("LIBROSA_CACHE_MMAP", None),
+    compress=os.environ.get("LIBROSA_CACHE_COMPRESS", False),
+    verbose=int(os.environ.get("LIBROSA_CACHE_VERBOSE", 0)),
+    level=int(os.environ.get("LIBROSA_CACHE_LEVEL", 10)),
+)