robotcode-robot 0.95.0__py3-none-any.whl → 0.95.2__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "0.95.0"
+__version__ = "0.95.2"

robotcode/robot/diagnostics/entities.py

@@ -1,3 +1,4 @@
+import functools
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import (
@@ -142,19 +143,19 @@ class VariableMatcher:
 
         self.base = match.base
 
-        self.normalized_name = str(normalize(self.base))
+        self.normalized_name = normalize(self.base)
 
     def __eq__(self, o: object) -> bool:
-        if isinstance(o, VariableMatcher):
+        if type(o) is VariableMatcher:
             return o.normalized_name == self.normalized_name
 
-        if isinstance(o, str):
+        if type(o) is str:
             match = search_variable(o, "$@&%", ignore_errors=True)
             base = match.base
             if base is None:
                 return False
 
-            normalized = str(normalize(base))
+            normalized = normalize(base)
             return self.normalized_name == normalized
 
         return False
@@ -194,10 +195,9 @@ class VariableDefinition(SourceEntity):
     value: Any = field(default=None, compare=False)
     value_is_native: bool = field(default=False, compare=False)
 
-    matcher: VariableMatcher = field(init=False, compare=False)
-
-    def __post_init__(self) -> None:
-        self.matcher = VariableMatcher(self.name)
+    @functools.cached_property
+    def matcher(self) -> VariableMatcher:
+        return VariableMatcher(self.name)
 
     @single_call
     def __hash__(self) -> int:

robotcode/robot/diagnostics/imports_manager.py

@@ -573,12 +573,10 @@ class ImportsManager:
         self._resource_document_changed_timer_interval = 1
         self._resource_document_changed_documents: Set[TextDocument] = set()
 
-        self._resource_libdoc_cache: "weakref.WeakKeyDictionary[ast.AST, Dict[Tuple[str, bool], LibraryDoc]]" = (
+        self._resource_libdoc_cache: "weakref.WeakKeyDictionary[ast.AST, Dict[str, LibraryDoc]]" = (
             weakref.WeakKeyDictionary()
         )
 
-        self._process_pool_executor: Optional[ProcessPoolExecutor] = None
-
     def __del__(self) -> None:
         try:
             if self._executor is not None:
@@ -1302,9 +1300,8 @@ class ImportsManager:
         self,
         model: ast.AST,
         source: str,
-        append_model_errors: bool = True,
     ) -> LibraryDoc:
-        key = (source, append_model_errors)
+        key = source
 
         entry = None
         if model in self._resource_libdoc_cache:
@@ -1313,11 +1310,7 @@ class ImportsManager:
             if entry and key in entry:
                 return entry[key]
 
-        result = get_model_doc(
-            model=model,
-            source=source,
-            append_model_errors=append_model_errors,
-        )
+        result = get_model_doc(model=model, source=source)
         if entry is None:
             entry = {}
             self._resource_libdoc_cache[model] = entry

robotcode/robot/diagnostics/keyword_finder.py

@@ -39,9 +39,8 @@ DEFAULT_BDD_PREFIXES = {"Given ", "When ", "Then ", "And ", "But "}
 
 
 class KeywordFinder:
-    def __init__(self, namespace: "Namespace", library_doc: LibraryDoc) -> None:
-        self.namespace = namespace
-        self.self_library_doc = library_doc
+    def __init__(self, namespace: "Namespace") -> None:
+        self._namespace = namespace
 
         self.diagnostics: List[DiagnosticsEntry] = []
         self.result_bdd_prefix: Optional[str] = None
@@ -57,9 +56,9 @@ class KeywordFinder:
             ],
         ] = {}
 
-        self._all_keywords: Optional[List[LibraryEntry]] = None
-        self._resource_keywords: Optional[List[ResourceEntry]] = None
-        self._library_keywords: Optional[List[LibraryEntry]] = None
+    @functools.cached_property
+    def _library_doc(self) -> LibraryDoc:
+        return self._namespace.get_library_doc()
 
     def reset_diagnostics(self) -> None:
         self.diagnostics = []
@@ -162,7 +161,7 @@ class KeywordFinder:
     def _get_keyword_from_self(self, name: str) -> Optional[KeywordDoc]:
         if get_robot_version() >= (6, 0):
             found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
-                (None, v) for v in self.self_library_doc.keywords.iter_all(name)
+                (None, v) for v in self._library_doc.keywords.iter_all(name)
             ]
             if len(found) > 1:
                 found = self._select_best_matches(found)
@@ -183,7 +182,7 @@ class KeywordFinder:
             return None
 
         try:
-            return self.self_library_doc.keywords.get(name, None)
+            return self._library_doc.keywords.get(name, None)
         except KeywordError as e:
             self.diagnostics.append(DiagnosticsEntry(str(e), DiagnosticSeverity.ERROR, Error.KEYWORD_ERROR))
             raise CancelSearchError from e
@@ -213,15 +212,16 @@ class KeywordFinder:
 
         return found[0][1] if found else None
 
-    def find_keywords(self, owner_name: str, name: str) -> List[Tuple[LibraryEntry, KeywordDoc]]:
-        if self._all_keywords is None:
-            self._all_keywords = list(
-                chain(
-                    self.namespace._libraries.values(),
-                    self.namespace._resources.values(),
-                )
+    @functools.cached_property
+    def _all_keywords(self) -> List[LibraryEntry]:
+        return list(
+            chain(
+                self._namespace._libraries.values(),
+                self._namespace._resources.values(),
             )
+        )
 
+    def find_keywords(self, owner_name: str, name: str) -> List[Tuple[LibraryEntry, KeywordDoc]]:
         if get_robot_version() >= (6, 0):
             result: List[Tuple[LibraryEntry, KeywordDoc]] = []
             for v in self._all_keywords:
@@ -271,11 +271,11 @@ class KeywordFinder:
     def _prioritize_same_file_or_public(
         self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
     ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        matches = [h for h in entries if h[1].source == self.namespace.source]
+        matches = [h for h in entries if h[1].source == self._namespace.source]
         if matches:
             return matches
 
-        matches = [handler for handler in entries if not handler[1].is_private()]
+        matches = [handler for handler in entries if not handler[1].is_private]
 
         return matches or entries
 
@@ -312,23 +312,24 @@ class KeywordFinder:
         other: Tuple[Optional[LibraryEntry], KeywordDoc],
     ) -> bool:
         return (
-            other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
+            other[1].matcher.embedded_arguments is not None
+            and candidate[1].matcher.embedded_arguments is not None
+            and other[1].matcher.embedded_arguments.match(candidate[1].name) is not None
             and candidate[1].matcher.embedded_arguments.match(other[1].name) is None
         )
 
-    def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
-        if self._resource_keywords is None:
-            self._resource_keywords = list(chain(self.namespace._resources.values()))
+    @functools.cached_property
+    def _resource_imports(self) -> List[ResourceEntry]:
+        return list(chain(self._namespace._resources.values()))
 
+    def _get_keyword_from_resource_files(self, name: str) -> Optional[KeywordDoc]:
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._resource_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._resource_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
         else:
             found = []
-            for k in self._resource_keywords:
+            for k in self._resource_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))
@@ -365,27 +366,27 @@ class KeywordFinder:
     def _get_keyword_based_on_search_order(
         self, entries: List[Tuple[Optional[LibraryEntry], KeywordDoc]]
     ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        for libname in self.namespace.search_order:
+        for libname in self._namespace.search_order:
             for e in entries:
                 if e[0] is not None and eq_namespace(libname, e[0].alias or e[0].name):
                     return [e]
 
         return entries
 
-    def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
-        if self._library_keywords is None:
-            self._library_keywords = list(chain(self.namespace._libraries.values()))
+    @functools.cached_property
+    def _library_imports(self) -> List[LibraryEntry]:
+        return list(chain(self._namespace._libraries.values()))
 
+    def _get_keyword_from_libraries(self, name: str) -> Optional[KeywordDoc]:
         if get_robot_version() >= (6, 0):
-            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = []
-            for v in self._library_keywords:
-                r = v.library_doc.keywords.get_all(name)
-                if r:
-                    found.extend([(v, k) for k in r])
+            found: List[Tuple[Optional[LibraryEntry], KeywordDoc]] = [
+                (v, k) for v in self._library_imports for k in v.library_doc.keywords.iter_all(name)
+            ]
+
         else:
             found = []
 
-            for k in self._library_keywords:
+            for k in self._library_imports:
                 s = k.library_doc.keywords.get(name, None)
                 if s is not None:
                     found.append((k, s))
@@ -463,8 +464,8 @@ class KeywordFinder:
     def bdd_prefix_regexp(self) -> "re.Pattern[str]":
         prefixes = (
             "|".join(
-                self.namespace.languages.bdd_prefixes
-                if self.namespace.languages is not None
+                self._namespace.languages.bdd_prefixes
+                if self._namespace.languages is not None
                 else ["given", "when", "then", "and", "but"]
             )
             .replace(" ", r"\s")