cache finding libraries, recources, variables files

Author: d-biehl

CHANGELOG.md

@@ -4,6 +4,8 @@ All notable changes to the "robotcode" extension will be documented in this file
 
 ## [Unreleased]
 
+### added
+
 - Information about possible circular imports
   - if one resource file imports another resource file and vice versa an information message is shown in source code and problems list
 

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -23,6 +23,7 @@
     final,
 )
 
+from ....utils.async_cache import AsyncSimpleCache
 from ....utils.async_tools import Lock, async_tasking_event, create_sub_task
 from ....utils.logging import LoggingDescriptor
 from ....utils.path import path_is_relative_to
@@ -471,6 +472,10 @@ def __init__(self, parent_protocol: RobotLanguageServerProtocol, folder: Uri, co
         self._python_path: Optional[List[str]] = None
         self._environment: Optional[Mapping[str, str]] = None
 
+        self._library_files_cache = AsyncSimpleCache()
+        self._resource_files_cache = AsyncSimpleCache()
+        self._variables_files_cache = AsyncSimpleCache()
+
     @property
     def environment(self) -> Mapping[str, str]:
         if self._environment is None:
@@ -691,8 +696,10 @@ async def remove(k: _VariablesEntryKey, e: _VariablesEntry) -> None:
         except RuntimeError:
             pass
 
-    @_logger.call
     async def find_library(self, name: str, base_dir: str, variables: Optional[Dict[str, Any]] = None) -> str:
+        return await self._library_files_cache.get(self._find_library, name, base_dir, variables)
+
+    async def _find_library(self, name: str, base_dir: str, variables: Optional[Dict[str, Any]] = None) -> str:
         from robot.libraries import STDLIBS
         from robot.variables.search import contains_variable
 
@@ -722,8 +729,41 @@ async def find_library(self, name: str, base_dir: str, variables: Optional[Dict[
 
         return result
 
+    async def find_resource(
+        self, name: str, base_dir: str, file_type: str = "Resource", variables: Optional[Dict[str, Any]] = None
+    ) -> str:
+        return await self._resource_files_cache.get(self.__find_resource, name, base_dir, file_type, variables)
+
     @_logger.call
+    async def __find_resource(
+        self, name: str, base_dir: str, file_type: str = "Resource", variables: Optional[Dict[str, Any]] = None
+    ) -> str:
+        from robot.variables.search import contains_variable
+
+        if contains_variable(name, "$@&%"):
+            return await asyncio.wait_for(
+                asyncio.get_running_loop().run_in_executor(
+                    self.process_pool,
+                    find_file,
+                    name,
+                    str(self.folder.to_path()),
+                    base_dir,
+                    self.config.python_path if self.config is not None else None,
+                    self.config.env if self.config is not None else None,
+                    self.config.variables if self.config is not None else None,
+                    variables,
+                    file_type,
+                ),
+                FIND_FILE_TIME_OUT,
+            )
+
+        return str(find_file_ex(name, base_dir, self.python_path, file_type))
+
     async def find_variables(self, name: str, base_dir: str, variables: Optional[Dict[str, Any]] = None) -> str:
+        return await self._variables_files_cache.get(self._find_variables, name, base_dir, variables)
+
+    @_logger.call
+    async def _find_variables(self, name: str, base_dir: str, variables: Optional[Dict[str, Any]] = None) -> str:
         from robot.variables.search import contains_variable
 
         if contains_variable(name, "$@&%"):
@@ -970,34 +1010,6 @@ async def _get_libdoc() -> VariablesDoc:
 
         return await entry.get_libdoc()
 
-    @_logger.call
-    async def find_resource(
-        self, name: str, base_dir: str, file_type: str = "Resource", variables: Optional[Dict[str, Any]] = None
-    ) -> str:
-        from robot.variables.search import contains_variable
-
-        # if contains_variable(name, "$@&%"):
-        #     name = name.replace("%{CI_PROJECT_DIR}", self.environment["CI_PROJECT_DIR"])
-
-        if contains_variable(name, "$@&%"):
-            return await asyncio.wait_for(
-                asyncio.get_running_loop().run_in_executor(
-                    self.process_pool,
-                    find_file,
-                    name,
-                    str(self.folder.to_path()),
-                    base_dir,
-                    self.config.python_path if self.config is not None else None,
-                    self.config.env if self.config is not None else None,
-                    self.config.variables if self.config is not None else None,
-                    variables,
-                    file_type,
-                ),
-                FIND_FILE_TIME_OUT,
-            )
-
-        return str(find_file_ex(name, base_dir, self.python_path, file_type))
-
     @_logger.call
     async def _get_entry_for_resource_import(
         self, name: str, base_dir: str, sentinel: Any = None, variables: Optional[Dict[str, Any]] = None

robotcode/utils/async_cache.py

@@ -0,0 +1,43 @@
+from typing import Any, Awaitable, Callable, Dict, List, Tuple, TypeVar, cast
+
+from .async_tools import Lock
+
+_T = TypeVar("_T")
+
+
+def _freeze(v: Any) -> Any:
+    if isinstance(v, dict):
+        return frozenset(v.items())
+    return v
+
+
+class AsyncSimpleCache:
+    def __init__(self, max_items: int = 128) -> None:
+        self.max_items = max_items
+
+        self._cache: Dict[Tuple[Any, ...], Any] = {}
+        self._order: List[Tuple[Any, ...]] = []
+        self._lock = Lock()
+
+    async def get(self, func: Callable[..., Awaitable[_T]], *args: Any, **kwargs: Any) -> _T:
+        key = self._make_key(*args, **kwargs)
+
+        async with self._lock:
+            try:
+                return cast(_T, self._cache[key])
+            except KeyError:
+                pass
+
+            res = await func(*args, **kwargs)
+
+            self._cache[key] = res
+            self._order.insert(0, key)
+
+            if len(self._order) > self.max_items:
+                del self._cache[self._order.pop()]
+
+            return res
+
+    @staticmethod
+    def _make_key(*args: Any, **kwargs: Any) -> Tuple[Any, ...]:
+        return (tuple(_freeze(v) for v in args), frozenset({k: _freeze(v) for k, v in kwargs.items()}))