robotcode-robot 0.75.0__py3-none-any.whl → 0.76.1__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "0.75.0"
+__version__ = "0.76.1"

robotcode/robot/diagnostics/document_cache_helper.py

@@ -22,7 +22,6 @@ from robot.parsing.lexer.tokens import Token
 from robotcode.core.documents_manager import DocumentsManager
 from robotcode.core.event import event
 from robotcode.core.filewatcher import FileWatcherManagerBase
-from robotcode.core.language import language_id_filter
 from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
@@ -32,6 +31,7 @@ from ..config.model import RobotBaseProfile
 from ..utils import get_robot_version
 from ..utils.stubs import Languages
 from .imports_manager import ImportsManager
+from .library_doc import LibraryDoc
 from .namespace import DocumentType, Namespace
 from .workspace_config import AnalysisRobotConfig, CacheConfig, RobotConfig
 
@@ -40,6 +40,10 @@ class UnknownFileTypeError(Exception):
     pass
 
 
+class _CacheEntry:
+    pass
+
+
 class DocumentsCacheHelper:
     _logger = LoggingDescriptor()
 
@@ -50,6 +54,8 @@ class DocumentsCacheHelper:
         file_watcher_manager: FileWatcherManagerBase,
         robot_profile: Optional[RobotBaseProfile],
     ) -> None:
+        self.INITIALIZED_NAMESPACE = _CacheEntry()
+
         self.workspace = workspace
         self.documents_manager = documents_manager
         self.file_watcher_manager = file_watcher_manager
@@ -415,15 +421,41 @@ class DocumentsCacheHelper:
     def __get_general_namespace(self, document: TextDocument) -> Namespace:
         return self.__get_namespace_for_document_type(document, DocumentType.GENERAL)
 
+    @event
+    def namespace_initialized(sender, namespace: Namespace) -> None: ...
+
     @event
     def namespace_invalidated(sender, namespace: Namespace) -> None: ...
 
     def __invalidate_namespace(self, sender: Namespace) -> None:
         document = sender.document
         if document is not None:
-            document.invalidate_cache()
+            document.remove_cache_entry(self.__get_general_namespace)
+            document.remove_cache_entry(self.__get_init_namespace)
+            document.remove_cache_entry(self.__get_resource_namespace)
+            document.remove_cache_entry(self.__get_namespace)
 
-            self.namespace_invalidated(self, sender, callback_filter=language_id_filter(document))
+            self.namespace_invalidated(self, sender)
+
+    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)
+
+    def get_initialized_namespace(self, document: TextDocument) -> Namespace:
+        result: Optional[Namespace] = document.get_data(self.INITIALIZED_NAMESPACE)
+        if result is None:
+            self._logger.debug(lambda: f"There is no initialized Namespace: {document.uri if document else None}")
+            result = self.get_namespace(document)
+        return result
+
+    def get_only_initialized_namespace(self, document: TextDocument) -> Optional[Namespace]:
+        result: Optional[Namespace] = document.get_data(self.INITIALIZED_NAMESPACE)
+
+        return result
 
     def __get_namespace_for_document_type(
         self, document: TextDocument, document_type: Optional[DocumentType]
@@ -451,6 +483,7 @@ class DocumentsCacheHelper:
             workspace_languages,
         )
         result.has_invalidated.add(self.__invalidate_namespace)
+        result.has_initialized.add(self.__namespace_initialized)
 
         return result
 
@@ -474,7 +507,7 @@ class DocumentsCacheHelper:
         ]
 
         analysis_config = self.workspace.get_configuration(AnalysisRobotConfig, root_uri)
-        return ImportsManager(
+        result = ImportsManager(
             self.documents_manager,
             self.file_watcher_manager,
             self,
@@ -484,10 +517,35 @@ class DocumentsCacheHelper:
             environment,
             cache_config.ignored_libraries,
             cache_config.ignored_variables,
+            cache_config.ignore_arguments_for_library,
             analysis_config.global_library_search_order,
             cache_base_path,
         )
 
+        result.libraries_changed.add(self._on_libraries_changed)
+        result.resources_changed.add(self._on_resources_changed)
+        result.variables_changed.add(self._on_variables_changed)
+
+        return result
+
+    @event
+    def libraries_changed(sender, libraries: List[LibraryDoc]) -> None: ...
+
+    @event
+    def resources_changed(sender, resources: List[LibraryDoc]) -> None: ...
+
+    @event
+    def variables_changed(sender, variables: List[LibraryDoc]) -> None: ...
+
+    def _on_libraries_changed(self, sender: ImportsManager, libraries: List[LibraryDoc]) -> None:
+        self.libraries_changed(self, libraries)
+
+    def _on_resources_changed(self, sender: ImportsManager, resources: List[LibraryDoc]) -> None:
+        self.resources_changed(self, resources)
+
+    def _on_variables_changed(self, sender: ImportsManager, variables: List[LibraryDoc]) -> None:
+        self.variables_changed(self, variables)
+
     def default_imports_manager(self) -> ImportsManager:
         with self._imports_managers_lock:
             if self._default_imports_manager is None:

robotcode/robot/diagnostics/entities.py

@@ -195,11 +195,10 @@ class VariableDefinition(SourceEntity):
     value: Any = field(default=None, compare=False)
     value_is_native: bool = field(default=False, compare=False)
 
-    @property
-    def matcher(self) -> VariableMatcher:
-        if not hasattr(self, "__matcher"):
-            self.__matcher = VariableMatcher(self.name)
-        return self.__matcher
+    matcher: VariableMatcher = field(init=False, compare=False)
+
+    def __post_init__(self) -> None:
+        self.matcher = VariableMatcher(self.name)
 
     @single_call
     def __hash__(self) -> int:

robotcode/robot/diagnostics/imports_manager.py

@@ -496,14 +496,15 @@ class ImportsManager:
         environment: Optional[Dict[str, str]],
         ignored_libraries: List[str],
         ignored_variables: List[str],
+        ignore_arguments_for_library: List[str],
         global_library_search_order: List[str],
         cache_base_path: Optional[Path],
     ) -> None:
         super().__init__()
 
         self.documents_manager = documents_manager
-        self.documents_manager.did_create_uri.add(self.possible_imports_modified)
-        self.documents_manager.did_change.add(self.possible_resource_document_modified)
+        self.documents_manager.did_create_uri.add(self._on_possible_imports_modified)
+        self.documents_manager.did_change.add(self._on_possible_resource_document_modified)
 
         self.file_watcher_manager: FileWatcherManagerBase = (
             file_watcher_manager if file_watcher_manager is not None else FileWatcherManagerDummy()
@@ -538,6 +539,7 @@ class ImportsManager:
 
         self.ignored_libraries_patters = [Pattern(s) for s in ignored_libraries]
         self.ignored_variables_patters = [Pattern(s) for s in ignored_variables]
+        self.ignore_arguments_for_library_patters = [Pattern(s) for s in ignore_arguments_for_library]
 
         self.global_library_search_order = global_library_search_order
 
@@ -561,9 +563,9 @@ class ImportsManager:
         if environment:
             self._environment.update(environment)
 
-        self._library_files_cache = SimpleLRUCache()
-        self._resource_files_cache = SimpleLRUCache()
-        self._variables_files_cache = SimpleLRUCache()
+        self._library_files_cache = SimpleLRUCache(1024)
+        self._resource_files_cache = SimpleLRUCache(1024)
+        self._variables_files_cache = SimpleLRUCache(1024)
 
         self._executor_lock = RLock(default_timeout=120, name="ImportsManager._executor_lock")
         self._executor: Optional[ProcessPoolExecutor] = None
@@ -683,12 +685,15 @@ class ImportsManager:
     @event
     def imports_changed(sender, uri: DocumentUri) -> None: ...
 
-    def possible_imports_modified(self, sender: Any, uri: DocumentUri) -> None:
+    def _on_possible_imports_modified(self, sender: Any, uri: DocumentUri) -> None:
         # TODO: do we really need this?
         self.imports_changed(self, uri)
 
     @language_id("robotframework")
-    def possible_resource_document_modified(self, sender: Any, document: TextDocument) -> None:
+    def _on_possible_resource_document_modified(self, sender: Any, document: TextDocument) -> None:
+        run_as_task(self.__on_possible_resource_document_modified, sender, document)
+
+    def __on_possible_resource_document_modified(self, sender: Any, document: TextDocument) -> None:
         with self._resource_document_changed_timer_lock:
             if document in self._resource_document_changed_documents:
                 return
@@ -712,7 +717,7 @@ class ImportsManager:
             self._resource_document_changed_documents = set()
 
         for document in documents:
-            run_as_task(self.__resource_document_changed, document).result()
+            self.__resource_document_changed(document)
 
     def __resource_document_changed(self, document: TextDocument) -> None:
         resource_changed: List[LibraryDoc] = []
@@ -864,7 +869,8 @@ class ImportsManager:
         name: str,
         base_dir: str = ".",
         variables: Optional[Dict[str, Optional[Any]]] = None,
-    ) -> Tuple[Optional[LibraryMetaData], str]:
+    ) -> Tuple[Optional[LibraryMetaData], str, bool]:
+        ignore_arguments = False
         try:
             import_name = self.find_library(name, base_dir=base_dir, variables=variables)
 
@@ -886,6 +892,12 @@ class ImportsManager:
                     )
 
             if result is not None:
+                ignore_arguments = any(
+                    (p.matches(result.name) if result.name is not None else False)
+                    or (p.matches(result.origin) if result.origin is not None else False)
+                    for p in self.ignore_arguments_for_library_patters
+                )
+
                 if any(
                     (p.matches(result.name) if result.name is not None else False)
                     or (p.matches(result.origin) if result.origin is not None else False)
@@ -895,7 +907,7 @@ class ImportsManager:
                         lambda: f"Ignore library {result.name or '' if result is not None else ''}"
                         f" {result.origin or '' if result is not None else ''} for caching."
                     )
-                    return None, import_name
+                    return None, import_name, ignore_arguments
 
                 if result.origin is not None:
                     result.mtimes = {result.origin: Path(result.origin).stat().st_mtime_ns}
@@ -912,13 +924,13 @@ class ImportsManager:
                         }
                     )
 
-            return result, import_name
+            return result, import_name, ignore_arguments
         except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException:
             pass
 
-        return None, import_name
+        return None, import_name, ignore_arguments
 
     def get_variables_meta(
         self,
@@ -1131,7 +1143,7 @@ class ImportsManager:
         base_dir: str,
         variables: Optional[Dict[str, Any]] = None,
     ) -> LibraryDoc:
-        meta, source = self.get_library_meta(name, base_dir, variables)
+        meta, source, ignore_arguments = self.get_library_meta(name, base_dir, variables)
 
         self._logger.debug(lambda: f"Load Library {source}{args!r}")
 
@@ -1171,7 +1183,7 @@ class ImportsManager:
             result = executor.submit(
                 get_library_doc,
                 name,
-                args,
+                args if not ignore_arguments else (),
                 working_dir,
                 base_dir,
                 self.get_resolvable_command_line_variables(),
@@ -1400,13 +1412,17 @@ class ImportsManager:
     ) -> VariablesDoc:
         source = self.find_variables(name, base_dir, variables, resolve_variables, resolve_command_line_vars)
 
-        resolved_args = resolve_args(
-            args,
-            str(self.root_folder),
-            base_dir,
-            self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
-            variables,
-        )
+        if args:
+            resolved_args = resolve_args(
+                args,
+                str(self.root_folder),
+                base_dir,
+                self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
+                variables,
+            )
+        else:
+            resolved_args = ()
+
         entry_key = _VariablesEntryKey(source, resolved_args)
 
         with self._variables_lock:

robotcode/robot/diagnostics/library_doc.py

@@ -33,7 +33,38 @@ from typing import (
     cast,
 )
 
+import robot.running.testlibraries
+from robot.errors import DataError, VariableError
+from robot.libdocpkg import LibraryDocumentation
+from robot.libdocpkg.htmlwriter import LibdocHtmlWriter
+from robot.libdocpkg.robotbuilder import KeywordDocBuilder
+from robot.libraries import STDLIBS
+from robot.output.logger import LOGGER
+from robot.output.loggerhelper import AbstractLogger
 from robot.parsing.lexer.tokens import Token
+from robot.parsing.lexer.tokens import Token as RobotToken
+from robot.parsing.model.blocks import Keyword
+from robot.parsing.model.statements import Arguments, KeywordName
+from robot.running.arguments.argumentresolver import (
+    ArgumentResolver,
+    DictToKwargs,
+    NamedArgumentResolver,
+    VariableReplacer,
+)
+from robot.running.arguments.argumentspec import ArgInfo
+from robot.running.arguments.argumentspec import (
+    ArgumentSpec as RobotArgumentSpec,
+)
+from robot.running.arguments.embedded import EmbeddedArguments
+from robot.running.builder.transformers import ResourceBuilder
+from robot.running.outputcapture import OutputCapturer
+from robot.running.runkwregister import RUN_KW_REGISTER
+from robot.utils.importer import Importer
+from robot.utils.robotpath import find_file as robot_find_file
+from robot.variables import Variables
+from robot.variables.filesetter import PythonImporter, YamlImporter
+from robot.variables.finders import VariableFinder
+from robot.variables.search import contains_variable
 from robotcode.core.lsp.types import Position, Range
 from robotcode.robot.diagnostics.entities import (
     ArgumentDefinition,
@@ -53,6 +84,30 @@ from robotcode.robot.utils.markdownformatter import MarkDownFormatter
 from robotcode.robot.utils.match import normalize, normalize_namespace
 from robotcode.robot.utils.stubs import HasError, HasErrors
 
+if get_robot_version() < (7, 0):
+    from robot.running.handlers import _PythonHandler, _PythonInitHandler
+    from robot.running.model import ResourceFile
+    from robot.running.usererrorhandler import UserErrorHandler
+    from robot.running.userkeyword import UserLibrary
+
+    robot_notset = ArgInfo.NOTSET
+
+if get_robot_version() >= (6, 1):
+    from robot.libdocpkg.datatypes import (
+        TypeDoc as RobotTypeDoc,
+    )
+    from robot.running.arguments.argumentspec import TypeInfo
+    from robot.variables.filesetter import JsonImporter
+
+if get_robot_version() >= (7, 0):
+    from robot.running.invalidkeyword import InvalidKeyword
+    from robot.running.invalidkeyword import (
+        InvalidKeyword as UserErrorHandler,
+    )
+    from robot.running.resourcemodel import ResourceFile
+    from robot.utils import NOT_SET as robot_notset  # type: ignore[no-redef] # noqa: N811
+
+
 RUN_KEYWORD_NAMES = [
     "Run Keyword",
     "Run Keyword And Continue On Failure",
@@ -144,9 +199,6 @@ def convert_from_rest(text: str) -> str:
 
 
 def is_embedded_keyword(name: str) -> bool:
-    from robot.errors import DataError, VariableError
-    from robot.running.arguments.embedded import EmbeddedArguments
-
     try:
         if get_robot_version() >= (6, 0):
             if EmbeddedArguments.from_name(name):
@@ -182,9 +234,6 @@ class KeywordMatcher:
 
     @property
     def embedded_arguments(self) -> Any:
-        from robot.errors import DataError, VariableError
-        from robot.running.arguments.embedded import EmbeddedArguments
-
         if self._embedded_arguments is None:
             if self._can_have_embedded:
                 try:
@@ -351,13 +400,6 @@ class KeywordArgumentKind(Enum):
 
 
 def robot_arg_repr(arg: Any) -> Optional[str]:
-    from robot.running.arguments.argumentspec import ArgInfo
-
-    if get_robot_version() >= (7, 0):
-        from robot.utils import NOT_SET as robot_notset  # noqa: N811
-    else:
-        robot_notset = ArgInfo.NOTSET
-
     robot_arg = cast(ArgInfo, arg)
 
     if robot_arg.default is robot_notset:
@@ -389,8 +431,6 @@ class ArgumentInfo:
 
     @staticmethod
     def from_robot(arg: Any) -> ArgumentInfo:
-        from robot.running.arguments.argumentspec import ArgInfo
-
         robot_arg = cast(ArgInfo, arg)
 
         return ArgumentInfo(
@@ -484,16 +524,6 @@ class ArgumentSpec:
         dict_to_kwargs: bool = False,
         validate: bool = True,
     ) -> Tuple[List[Any], List[Tuple[str, Any]]]:
-        from robot.running.arguments.argumentresolver import (
-            ArgumentResolver,
-            DictToKwargs,
-            NamedArgumentResolver,
-            VariableReplacer,
-        )
-        from robot.running.arguments.argumentspec import (
-            ArgumentSpec as RobotArgumentSpec,
-        )
-
         if not hasattr(self, "__robot_arguments"):
             if get_robot_version() < (7, 0):
                 self.__robot_arguments = RobotArgumentSpec(
@@ -1352,16 +1382,17 @@ class KeywordWrapper:
         except BaseException:
             return ""
 
-    @property
-    def is_error_handler(self) -> bool:
-        if get_robot_version() < (7, 0):
-            from robot.running.usererrorhandler import UserErrorHandler
+    if get_robot_version() < (7, 0):
 
+        @property
+        def is_error_handler(self) -> bool:
             return isinstance(self.kw, UserErrorHandler)
 
-        from robot.running.invalidkeyword import InvalidKeyword
+    else:
 
-        return isinstance(self.kw, InvalidKeyword)
+        @property
+        def is_error_handler(self) -> bool:
+            return isinstance(self.kw, InvalidKeyword)
 
     @property
     def error_handler_message(self) -> Optional[str]:
@@ -1454,7 +1485,6 @@ __default_variables: Any = None
 
 
 def _get_default_variables() -> Any:
-    from robot.variables import Variables
 
     global __default_variables
     if __default_variables is None:
@@ -1464,6 +1494,7 @@ def _get_default_variables() -> Any:
             "${/}": os.sep,
             "${:}": os.pathsep,
             "${\\n}": os.linesep,
+            "${EMPTY}": "",
             "${SPACE}": " ",
             "${True}": True,
             "${False}": False,
@@ -1504,7 +1535,6 @@ def resolve_robot_variables(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> Any:
-    from robot.variables import Variables
 
     result: Variables = _get_default_variables().copy()
 
@@ -1541,15 +1571,17 @@ def resolve_variable(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> Any:
-    from robot.variables.finders import VariableFinder
 
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-    if get_robot_version() >= (6, 1):
-        return VariableFinder(robot_variables).find(name.replace("\\", "\\\\"))
+    if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+        if get_robot_version() >= (6, 1):
+            return VariableFinder(robot_variables).find(name.replace("\\", "\\\\"))
+
+        return VariableFinder(robot_variables.store).find(name.replace("\\", "\\\\"))
 
-    return VariableFinder(robot_variables.store).find(name.replace("\\", "\\\\"))
+    return name.replace("\\", "\\\\")
 
 
 @contextmanager
@@ -1581,18 +1613,18 @@ def _find_library_internal(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> Tuple[str, Any]:
-    from robot.errors import DataError
-    from robot.libraries import STDLIBS
-    from robot.utils.robotpath import find_file as robot_find_file
 
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    robot_variables = None
 
-    try:
-        name = robot_variables.replace_string(name, ignore_errors=False)
-    except DataError as error:
-        raise DataError(f"Replacing variables from setting 'Library' failed: {error}")
+    if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+
+        try:
+            name = robot_variables.replace_string(name, ignore_errors=False)
+        except DataError as error:
+            raise DataError(f"Replacing variables from setting 'Library' failed: {error}")
 
     if name in STDLIBS:
         result = ROBOT_LIBRARY_PACKAGE + "." + name
@@ -1622,9 +1654,6 @@ def get_robot_library_html_doc_str(
     base_dir: str = ".",
     theme: Optional[str] = None,
 ) -> str:
-    from robot.libdocpkg import LibraryDocumentation
-    from robot.libdocpkg.htmlwriter import LibdocHtmlWriter
-
     _update_env(working_dir)
 
     if Path(name).suffix.lower() in ALLOWED_RESOURCE_FILE_EXTENSIONS:
@@ -1652,15 +1681,6 @@ def get_library_doc(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> LibraryDoc:
-    import robot.running.testlibraries
-    from robot.libdocpkg.robotbuilder import KeywordDocBuilder
-    from robot.libraries import STDLIBS
-    from robot.output import LOGGER
-    from robot.output.loggerhelper import AbstractLogger
-    from robot.running.outputcapture import OutputCapturer
-    from robot.running.runkwregister import RUN_KW_REGISTER
-    from robot.utils import Importer
-
     class Logger(AbstractLogger):
         def __init__(self) -> None:
             super().__init__()
@@ -1951,10 +1971,6 @@ def get_library_doc(
                 )
 
                 if get_robot_version() >= (6, 1):
-                    from robot.libdocpkg.datatypes import (
-                        TypeDoc as RobotTypeDoc,
-                    )
-                    from robot.running.arguments.argumentspec import TypeInfo
 
                     def _yield_type_info(info: TypeInfo) -> Iterable[TypeInfo]:
                         if not info.is_union:
@@ -2028,25 +2044,24 @@ def _find_variables_internal(
     base_dir: str = ".",
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
-) -> Tuple[str, Any]:
-    from robot.errors import DataError
-    from robot.utils.robotpath import find_file as robot_find_file
+) -> str:
 
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+    if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
 
-    try:
-        name = robot_variables.replace_string(name, ignore_errors=False)
-    except DataError as error:
-        raise DataError(f"Replacing variables from setting 'Variables' failed: {error}")
+        try:
+            name = robot_variables.replace_string(name, ignore_errors=False)
+        except DataError as error:
+            raise DataError(f"Replacing variables from setting 'Variables' failed: {error}")
 
     result = name
 
     if is_variables_by_path(result):
         result = robot_find_file(result, base_dir or ".", "Variables")
 
-    return (result, robot_variables)
+    return result
 
 
 def resolve_args(
@@ -2076,7 +2091,7 @@ def find_variables(
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> str:
     if get_robot_version() >= (5, 0):
-        return _find_variables_internal(name, working_dir, base_dir, command_line_variables, variables)[0]
+        return _find_variables_internal(name, working_dir, base_dir, command_line_variables, variables)
 
     return find_file(
         name,
@@ -2096,13 +2111,6 @@ def get_variables_doc(
     command_line_variables: Optional[Dict[str, Optional[Any]]] = None,
     variables: Optional[Dict[str, Optional[Any]]] = None,
 ) -> VariablesDoc:
-    from robot.libdocpkg.robotbuilder import KeywordDocBuilder
-    from robot.output import LOGGER
-    from robot.utils.importer import Importer
-    from robot.variables.filesetter import PythonImporter, YamlImporter
-
-    if get_robot_version() >= (6, 1):
-        from robot.variables.filesetter import JsonImporter
 
     import_name: str = name
     stem = Path(name).stem
@@ -2183,7 +2191,6 @@ def get_variables_doc(
                         #         super().__init__(name, library)
                         pass
                     else:
-                        from robot.running.handlers import _PythonHandler
 
                         class VarHandler(_PythonHandler):
                             def _get_name(self, handler_name: Any, handler_method: Any) -> Any:
@@ -2229,8 +2236,6 @@ def get_variables_doc(
 
                         pass
                     else:
-                        from robot.running.handlers import _PythonInitHandler
-
                         get_variables = getattr(libcode, "__init__", None) or getattr(libcode, "__init__", None)
 
                         class InitVarHandler(_PythonInitHandler):
@@ -2344,16 +2349,14 @@ def find_file(
     variables: Optional[Dict[str, Optional[Any]]] = None,
     file_type: str = "Resource",
 ) -> str:
-    from robot.errors import DataError
-    from robot.utils.robotpath import find_file as robot_find_file
-
     _update_env(working_dir)
 
-    robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
-    try:
-        name = robot_variables.replace_string(name, ignore_errors=False)
-    except DataError as error:
-        raise DataError(f"Replacing variables from setting '{file_type}' failed: {error}")
+    if contains_variable(name, "$@&%"):
+        robot_variables = resolve_robot_variables(working_dir, base_dir, command_line_variables, variables)
+        try:
+            name = robot_variables.replace_string(name, ignore_errors=False)
+        except DataError as error:
+            raise DataError(f"Replacing variables from setting '{file_type}' failed: {error}")
 
     return cast(str, robot_find_file(name, base_dir or ".", file_type))
 
@@ -2616,24 +2619,6 @@ def get_model_doc(
     scope: str = "GLOBAL",
     append_model_errors: bool = True,
 ) -> LibraryDoc:
-    from robot.errors import DataError, VariableError
-    from robot.libdocpkg.robotbuilder import KeywordDocBuilder
-    from robot.output.logger import LOGGER
-    from robot.parsing.lexer.tokens import Token as RobotToken
-    from robot.parsing.model.blocks import Keyword
-    from robot.parsing.model.statements import Arguments, KeywordName
-    from robot.running.builder.transformers import ResourceBuilder
-
-    if get_robot_version() < (7, 0):
-        from robot.running.model import ResourceFile
-        from robot.running.usererrorhandler import UserErrorHandler
-        from robot.running.userkeyword import UserLibrary
-    else:
-        from robot.running.invalidkeyword import (
-            InvalidKeyword as UserErrorHandler,
-        )
-        from robot.running.resourcemodel import ResourceFile
-
     errors: List[Error] = []
     keyword_name_nodes: List[KeywordName] = []
     keywords_nodes: List[Keyword] = []