robotcode-robot 0.93.0__py3-none-any.whl → 0.94.0__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "0.93.0"
+__version__ = "0.94.0"

robotcode/robot/diagnostics/document_cache_helper.py

@@ -118,8 +118,7 @@ class DocumentsCacheHelper:
             except ValueError as e:
                 ex = e
                 self._logger.exception(
-                    lambda: f"Language configuration is not valid: {ex}"
-                    "\nPlease check your 'robotcode.robot.language' configuration.",
+                    lambda: f"Language configuration is not valid: {ex}",
                     exc_info=ex,
                     level=CRITICAL,
                 )
@@ -410,7 +409,16 @@ class DocumentsCacheHelper:
         return document.get_cache(self.__get_namespace)
 
     def __get_namespace(self, document: TextDocument) -> Namespace:
-        return self.__get_namespace_for_document_type(document, None)
+        document_type = self.get_document_type(document)
+
+        if document_type == DocumentType.INIT:
+            return self.get_init_namespace(document)
+        if document_type == DocumentType.RESOURCE:
+            return self.get_resource_namespace(document)
+        if document_type == DocumentType.GENERAL:
+            return self.get_general_namespace(document)
+
+        return self.__get_namespace_for_document_type(document, document_type)
 
     def get_resource_namespace(self, document: TextDocument) -> Namespace:
         return document.get_cache(self.__get_resource_namespace)
@@ -448,9 +456,6 @@ class DocumentsCacheHelper:
 
     def __namespace_initialized(self, sender: Namespace) -> None:
         if sender.document is not None:
-            self._logger.debug(
-                lambda: f"Save initialized Namespace: {sender.document.uri if sender.document else None}"
-            )
             sender.document.set_data(self.INITIALIZED_NAMESPACE, sender)
             self.namespace_initialized(self, sender)
 

robotcode/robot/diagnostics/entities.py

@@ -246,7 +246,7 @@ class GlobalVariableDefinition(VariableDefinition):
 
 
 @dataclass
-class BuiltInVariableDefinition(VariableDefinition):
+class BuiltInVariableDefinition(GlobalVariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.BUILTIN_VARIABLE
     resolvable: bool = True
 
@@ -266,7 +266,7 @@ class CommandLineVariableDefinition(GlobalVariableDefinition):
 
 
 @dataclass
-class ArgumentDefinition(VariableDefinition):
+class ArgumentDefinition(LocalVariableDefinition):
     type: VariableDefinitionType = VariableDefinitionType.ARGUMENT
     keyword_doc: Optional["KeywordDoc"] = field(default=None, compare=False, metadata={"nosave": True})
 

robotcode/robot/diagnostics/errors.py

@@ -1,6 +1,6 @@
 from typing import final
 
-DIAGNOSTICS_SOURCE_NAME = "robotcode.namespace"
+DIAGNOSTICS_SOURCE_NAME = "robotcode"
 
 
 @final
@@ -35,3 +35,8 @@ class Error:
     CONFLICTING_LIBRARY_KEYWORDS = "ConflictingLibraryKeywords"
     INVALID_HEADER = "InvalidHeader"
     DEPRECATED_HEADER = "DeprecatedHeader"
+    OVERRIDDEN_BY_COMMANDLINE = "OverriddenByCommandLine"
+    VARIABLE_ALREADY_DEFINED = "VariableAlreadyDefined"
+    VARIABLE_OVERRIDDEN = "VariableOverridden"
+    MODEL_ERROR = "ModelError"
+    TOKEN_ERROR = "TokenError"

robotcode/robot/diagnostics/imports_manager.py

@@ -9,7 +9,7 @@ import weakref
 import zlib
 from abc import ABC, abstractmethod
 from collections import OrderedDict
-from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures import ProcessPoolExecutor, TimeoutError
 from dataclasses import dataclass
 from pathlib import Path
 from typing import (
@@ -25,6 +25,7 @@ from typing import (
     final,
 )
 
+from robot.utils.text import split_args_from_name_or_path
 from robotcode.core.concurrent import RLock, run_as_task
 from robotcode.core.documents_manager import DocumentsManager
 from robotcode.core.event import event
@@ -82,9 +83,8 @@ RESOURCE_EXTENSIONS = (
 REST_EXTENSIONS = (".rst", ".rest")
 
 
-LOAD_LIBRARY_TIME_OUT = 30
-FIND_FILE_TIME_OUT = 10
-COMPLETE_LIBRARY_IMPORT_TIME_OUT = COMPLETE_RESOURCE_IMPORT_TIME_OUT = COMPLETE_VARIABLES_IMPORT_TIME_OUT = 10
+LOAD_LIBRARY_TIME_OUT = 10
+COMPLETE_LIBRARY_IMPORT_TIME_OUT = COMPLETE_RESOURCE_IMPORT_TIME_OUT = COMPLETE_VARIABLES_IMPORT_TIME_OUT = 5
 
 
 class _EntryKey:
@@ -578,6 +578,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]]" = (
+            weakref.WeakKeyDictionary()
+        )
+
     def __del__(self) -> None:
         try:
             if self._executor is not None:
@@ -599,8 +603,6 @@ class ImportsManager:
 
     @_logger.call
     def get_command_line_variables(self) -> List[VariableDefinition]:
-        from robot.utils.text import split_args_from_name_or_path
-
         with self._command_line_variables_lock:
             if self._command_line_variables is None:
                 command_line_vars: List[VariableDefinition] = []
@@ -659,7 +661,11 @@ class ImportsManager:
                         raise
                     except BaseException as e:
                         # TODO add diagnostics
-                        self._logger.exception(e)
+                        ex = e
+                        self._logger.exception(
+                            lambda: f"Error getting command line variables: {ex}",
+                            exc_info=ex,
+                        )
 
                 self._command_line_variables = command_line_vars
 
@@ -854,7 +860,7 @@ class ImportsManager:
     ) -> None:
         try:
             if len(entry.references) == 0 or now:
-                self._logger.debug(lambda: f"Remove Va riables Entry {entry_key}")
+                self._logger.debug(lambda: f"Remove Variables Entry {entry_key}")
                 with self._variables_lock:
                     if len(entry.references) == 0:
                         e1 = self._variables.get(entry_key, None)
@@ -1148,6 +1154,7 @@ class ImportsManager:
         meta, _source, ignore_arguments = self.get_library_meta(name, base_dir, variables)
 
         if meta is not None and not meta.has_errors:
+
             meta_file = Path(self.lib_doc_cache_path, meta.filepath_base + ".meta.json")
             if meta_file.exists():
                 try:
@@ -1157,7 +1164,8 @@ class ImportsManager:
                         if saved_meta.has_errors:
                             self._logger.debug(
                                 lambda: "Saved library spec for {name}{args!r} is not used "
-                                "due to errors in meta data"
+                                "due to errors in meta data",
+                                context_name="import",
                             )
 
                         if not saved_meta.has_errors and saved_meta == meta:
@@ -1165,6 +1173,10 @@ class ImportsManager:
                                 self.lib_doc_cache_path,
                                 meta.filepath_base + ".spec.json",
                             )
+
+                            self._logger.debug(
+                                lambda: f"Use cached library meta data for {name}", context_name="import"
+                            )
                             return from_json(spec_path.read_text("utf-8"), LibraryDoc)
 
                     except (SystemExit, KeyboardInterrupt):
@@ -1178,17 +1190,22 @@ class ImportsManager:
                 except BaseException as e:
                     self._logger.exception(e)
 
+        self._logger.debug(lambda: f"Load library in process {name}{args!r}", context_name="import")
         executor = ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn"))
         try:
-            result = executor.submit(
-                get_library_doc,
-                name,
-                args if not ignore_arguments else (),
-                working_dir,
-                base_dir,
-                self.get_resolvable_command_line_variables(),
-                variables,
-            ).result(LOAD_LIBRARY_TIME_OUT)
+            try:
+                result = executor.submit(
+                    get_library_doc,
+                    name,
+                    args if not ignore_arguments else (),
+                    working_dir,
+                    base_dir,
+                    self.get_resolvable_command_line_variables(),
+                    variables,
+                ).result(LOAD_LIBRARY_TIME_OUT)
+
+            except TimeoutError as e:
+                raise RuntimeError(f"Timeout loading library {name}({args!r})") from e
 
         except (SystemExit, KeyboardInterrupt):
             raise
@@ -1273,17 +1290,29 @@ class ImportsManager:
         self,
         model: ast.AST,
         source: str,
-        model_type: str = "RESOURCE",
-        scope: str = "GLOBAL",
         append_model_errors: bool = True,
     ) -> LibraryDoc:
-        return get_model_doc(
+        key = (source, append_model_errors)
+
+        entry = None
+        if model in self._resource_libdoc_cache:
+            entry = self._resource_libdoc_cache.get(model, None)
+
+            if entry and key in entry:
+                return entry[key]
+
+        result = get_model_doc(
             model=model,
             source=source,
-            model_type=model_type,
-            scope=scope,
             append_model_errors=append_model_errors,
         )
+        if entry is None:
+            entry = {}
+            self._resource_libdoc_cache[model] = entry
+
+        entry[key] = result
+
+        return result
 
     def _get_variables_libdoc_handler(
         self,
@@ -1350,15 +1379,20 @@ class ImportsManager:
 
         executor = ProcessPoolExecutor(max_workers=1, mp_context=mp.get_context("spawn"))
         try:
-            result = executor.submit(
-                get_variables_doc,
-                name,
-                args,
-                working_dir,
-                base_dir,
-                self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
-                variables,
-            ).result(LOAD_LIBRARY_TIME_OUT)
+            try:
+                result = executor.submit(
+                    get_variables_doc,
+                    name,
+                    args,
+                    working_dir,
+                    base_dir,
+                    self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
+                    variables,
+                ).result(LOAD_LIBRARY_TIME_OUT)
+
+            except TimeoutError as e:
+                raise RuntimeError(f"Timeout loading library {name}({args!r})") from e
+
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -1489,9 +1523,15 @@ class ImportsManager:
         variables: Optional[Dict[str, Any]] = None,
     ) -> Tuple["Namespace", LibraryDoc]:
         with self._logger.measure_time(lambda: f"getting namespace and libdoc for {name}", context_name="import"):
-            entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables)
+            with self._logger.measure_time(lambda: f"getting resource entry {name}", context_name="import"):
+                entry = self._get_entry_for_resource_import(name, base_dir, sentinel, variables)
+
+            with self._logger.measure_time(lambda: f"getting namespace {name}", context_name="import"):
+                namespace = entry.get_namespace()
+            with self._logger.measure_time(lambda: f"getting libdoc {name}", context_name="import"):
+                libdoc = entry.get_libdoc()
 
-            return entry.get_namespace(), entry.get_libdoc()
+            return namespace, libdoc
 
     def get_namespace_for_resource_import(
         self,
@@ -1528,7 +1568,7 @@ class ImportsManager:
             base_dir,
             self.get_resolvable_command_line_variables(),
             variables,
-        ).result(LOAD_LIBRARY_TIME_OUT)
+        ).result(COMPLETE_LIBRARY_IMPORT_TIME_OUT)
 
     def complete_resource_import(
         self,
@@ -1543,7 +1583,7 @@ class ImportsManager:
             base_dir,
             self.get_resolvable_command_line_variables(),
             variables,
-        ).result(LOAD_LIBRARY_TIME_OUT)
+        ).result(COMPLETE_RESOURCE_IMPORT_TIME_OUT)
 
     def complete_variables_import(
         self,
@@ -1558,7 +1598,7 @@ class ImportsManager:
             base_dir,
             self.get_resolvable_command_line_variables(),
             variables,
-        ).result(LOAD_LIBRARY_TIME_OUT)
+        ).result(COMPLETE_VARIABLES_IMPORT_TIME_OUT)
 
     def resolve_variable(
         self,
@@ -1579,6 +1619,7 @@ class ImportsManager:
         scalar: str,
         base_dir: str = ".",
         variables: Optional[Dict[str, Any]] = None,
+        ignore_errors: bool = False,
     ) -> Any:
         return replace_variables_scalar(
             scalar,
@@ -1586,4 +1627,5 @@ class ImportsManager:
             base_dir,
             self.get_resolvable_command_line_variables(),
             variables,
+            ignore_errors=ignore_errors,
         )