robotcode-robot 0.91.0__py3-none-any.whl → 0.92.0__py3-none-any.whl

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "0.91.0"
+__version__ = "0.92.0"

robotcode/robot/config/loader.py

@@ -1,7 +1,8 @@
 import sys
+from dataclasses import fields, is_dataclass
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional, Sequence, Tuple, Type, TypeVar, Union
+from typing import Any, Callable, Dict, Optional, Sequence, Tuple, Type, TypeVar, Union
 
 from robotcode.core.utils.dataclasses import from_dict
 
@@ -58,9 +59,9 @@ def load_robot_config_from_robot_toml_str(__s: str) -> RobotConfig:
 
 
 def load_config_from_robot_toml_str(
-    config_type: Type[_ConfigType], __s: str, tool_name: Optional[str] = None
+    config_type: Type[_ConfigType], data: Union[str, Dict[str, Any]], tool_name: Optional[str] = None
 ) -> _ConfigType:
-    dict_data = tomllib.loads(__s)
+    dict_data = tomllib.loads(data) if isinstance(data, str) else data
 
     if tool_name:
         try:
@@ -73,34 +74,39 @@ def load_config_from_robot_toml_str(
     return from_dict(dict_data, config_type)
 
 
-def load_config_from_pyproject_toml_str(config_type: Type[_ConfigType], tool_name: str, __s: str) -> _ConfigType:
-    dict_data = tomllib.loads(__s)
+def load_config_from_pyproject_toml_str(
+    config_type: Type[_ConfigType], tool_name: str, data: Union[str, Dict[str, Any]]
+) -> _ConfigType:
+    dict_data = tomllib.loads(data) if isinstance(data, str) else data
 
     return from_dict(dict_data.get("tool", {}).get(tool_name, {}), config_type)
 
 
 def _load_config_data_from_path(
     config_type: Type[_ConfigType],
-    tool_name: str,
+    pyproject_toml_tool_name: str,
     robot_toml_tool_name: Optional[str],
-    __path: Path,
+    path: Path,
+    data: Optional[Dict[str, Any]] = None,
 ) -> _ConfigType:
     try:
-        if __path.name == PYPROJECT_TOML:
-            return load_config_from_pyproject_toml_str(config_type, tool_name, __path.read_text("utf-8"))
+        if path.name == PYPROJECT_TOML:
+            return load_config_from_pyproject_toml_str(
+                config_type, pyproject_toml_tool_name, path.read_text("utf-8") if data is None else data
+            )
 
-        if __path.name == ROBOT_TOML or __path.name == LOCAL_ROBOT_TOML or __path.suffix == ".toml":
+        if path.name == ROBOT_TOML or path.name == LOCAL_ROBOT_TOML or path.suffix == ".toml":
             return load_config_from_robot_toml_str(
                 config_type,
-                __path.read_text("utf-8"),
+                path.read_text("utf-8") if data is None else data,
                 tool_name=robot_toml_tool_name,
             )
         raise TypeError("Unknown config file type.")
 
     except ValueError as e:
-        raise ConfigValueError(__path, f'Parsing "{__path}" failed: {e}') from e
+        raise ConfigValueError(path, f'Parsing "{path}" failed: {e}') from e
     except TypeError as e:
-        raise ConfigTypeError(__path, f'Parsing "{__path}" failed: {e}') from e
+        raise ConfigTypeError(path, f'Parsing "{path}" failed: {e}') from e
 
 
 def get_default_config() -> RobotConfig:
@@ -113,34 +119,74 @@ def get_default_config() -> RobotConfig:
 def load_config_from_path(
     config_type: Type[_ConfigType],
     *__paths: Union[Path, Tuple[Path, ConfigType]],
-    tool_name: str,
+    pyproject_toml_tool_name: str,
     robot_toml_tool_name: Optional[str] = None,
+    extra_tools: Optional[Dict[str, Type[Any]]] = None,
+    verbose_callback: Optional[Callable[[str], None]] = None,
 ) -> _ConfigType:
     result = config_type()
+    tools: Optional[Dict[str, Any]] = (
+        {} if extra_tools and is_dataclass(result) and any(f for f in fields(result) if f.name == "tool") else None
+    )
 
     for __path in __paths:
         if isinstance(__path, tuple):
             path, c_type = __path
             if path.name == "__no_user_config__.toml" and c_type == ConfigType.DEFAULT_CONFIG_TOML:
+                if verbose_callback:
+                    verbose_callback("Load default configuration.")
                 result.add_options(get_default_config())
                 continue
 
+        if verbose_callback:
+            verbose_callback(f"Load configuration from {__path if isinstance(__path, Path) else __path[0]}")
+
+        p = __path if isinstance(__path, Path) else __path[0]
+        data = tomllib.loads(p.read_text("utf-8"))
+
         result.add_options(
             _load_config_data_from_path(
                 config_type,
-                tool_name,
+                pyproject_toml_tool_name,
                 robot_toml_tool_name,
-                __path if isinstance(__path, Path) else __path[0],
+                p,
+                data,
             )
         )
 
+        if tools is not None and extra_tools:
+            for tool_name, tool_config in extra_tools.items():
+                if tool_name not in tools:
+                    tools[tool_name] = tool_config()
+
+                tool = tools[tool_name]
+                tool.add_options(
+                    _load_config_data_from_path(
+                        tool_config,
+                        tool_name,
+                        tool_name,
+                        p,
+                        data,
+                    )
+                )
+    if tools is not None:
+        setattr(result, "tool", tools)
+
     return result
 
 
 def load_robot_config_from_path(
     *__paths: Union[Path, Tuple[Path, ConfigType]],
+    extra_tools: Optional[Dict[str, Type[Any]]] = None,
+    verbose_callback: Optional[Callable[[str], None]] = None,
 ) -> RobotConfig:
-    return load_config_from_path(RobotConfig, *__paths, tool_name="robot")
+    return load_config_from_path(
+        RobotConfig,
+        *__paths,
+        pyproject_toml_tool_name="robot",
+        extra_tools=extra_tools,
+        verbose_callback=verbose_callback,
+    )
 
 
 def find_project_root(

robotcode/robot/config/model.py

@@ -245,65 +245,6 @@ class BaseOptions(ValidateMixin):
     def _decode_case(cls, s: str) -> str:
         return s.replace("-", "_")
 
-    """Base class for all options."""
-
-    def build_command_line(self) -> List[str]:
-        """Build the arguments to pass to Robot Framework."""
-        result = []
-
-        sorted_fields = sorted(
-            (f for f in dataclasses.fields(self) if f.metadata.get("robot_priority", -1) > -1),
-            key=lambda f: f.metadata.get("robot_priority", 0),
-        )
-
-        def append_name(field: "dataclasses.Field[Any]", add_flag: Optional[str] = None) -> None:
-            if "robot_short_name" in field.metadata:
-                result.append(f"-{field.metadata['robot_short_name']}")
-            elif "robot_name" in field.metadata:
-                result.append(f"--{'no' if add_flag else ''}{field.metadata['robot_name']}")
-
-        for field in sorted_fields:
-            try:
-                value = getattr(self, field.name)
-                if value is None:
-                    continue
-
-                if field.metadata.get("robot_is_flag", False):
-                    if value is None or value == Flag.DEFAULT:
-                        continue
-
-                    append_name(
-                        field,
-                        bool(value) != field.metadata.get("robot_flag_default", True),
-                    )
-
-                    continue
-
-                if isinstance(value, list):
-                    for item in value:
-                        append_name(field)
-                        if isinstance(item, dict):
-                            for k, v in item.items():
-                                result.append(f"{k}:{v}")
-                        else:
-                            result.append(str(item))
-                elif isinstance(value, dict):
-                    for key, item in value.items():
-                        append_name(field)
-                        if isinstance(item, list):
-                            str_item = [str(i) for i in item]
-                            separator = ";" if any(True for s in str_item if ":" in s) else ":"
-                            result.append(f"{key}{separator if item else ''}{separator.join(str_item)}")
-                        else:
-                            result.append(f"{key}:{item}")
-                else:
-                    append_name(field)
-                    result.append(str(value))
-            except EvaluationError as e:
-                raise ValueError(f"Evaluation of '{field.name}' failed: {e!s}") from e
-
-        return result
-
     @staticmethod
     def _verified_value(name: str, value: Any, types: Union[type, Tuple[type, ...]], target: Any) -> Any:
         errors = validate_types(types, value)
@@ -315,6 +256,44 @@ class BaseOptions(ValidateMixin):
             )
         return value
 
+    def evaluated(
+        self,
+        verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+        error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
+    ) -> Self:
+        if verbose_callback is not None:
+            verbose_callback("Evaluating options")
+
+        result = dataclasses.replace(self)
+        for f in dataclasses.fields(result):
+            try:
+                if isinstance(getattr(result, f.name), Condition):
+                    setattr(result, f.name, getattr(result, f.name).evaluate())
+                elif isinstance(getattr(result, f.name), Expression):
+                    setattr(result, f.name, getattr(result, f.name).evaluate())
+                elif isinstance(getattr(result, f.name), list):
+                    setattr(
+                        result,
+                        f.name,
+                        [e.evaluate() if isinstance(e, Expression) else e for e in getattr(result, f.name)],
+                    )
+                elif isinstance(getattr(result, f.name), dict):
+                    setattr(
+                        result,
+                        f.name,
+                        {
+                            k: e.evaluate() if isinstance(e, Expression) else e
+                            for k, e in getattr(result, f.name).items()
+                        },
+                    )
+            except EvaluationError as e:
+                message = f"Evaluation of '{f.name}' failed: {type(e).__name__}: {e}"
+                if error_callback is None:
+                    raise ValueError(message) from e
+                error_callback(message)
+
+        return result
+
     def add_options(self, config: "BaseOptions", combine_extends: bool = False) -> None:
         type_hints = get_type_hints(type(self))
         base_field_names = [f.name for f in dataclasses.fields(self)]
@@ -352,6 +331,8 @@ class BaseOptions(ValidateMixin):
                         setattr(self, old_field_name, [*old, *new])
                     elif isinstance(old, tuple):
                         setattr(self, old_field_name, (*old, *new))
+                    elif isinstance(old, BaseOptions):
+                        old.add_options(new)
                     else:
                         setattr(self, old_field_name, new)
                 continue
@@ -370,41 +351,65 @@ class BaseOptions(ValidateMixin):
             if new is not None:
                 setattr(self, f.name, new)
 
-    def evaluated(
-        self,
-        verbose_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
-        error_callback: Optional[Callable[[Union[str, Callable[[], Any]]], None]] = None,
-    ) -> Self:
-        if verbose_callback is not None:
-            verbose_callback("Evaluating options")
 
-        result = dataclasses.replace(self)
-        for f in dataclasses.fields(result):
+@dataclass
+class RobotBaseOptions(BaseOptions):
+    """Base class for all options."""
+
+    def build_command_line(self) -> List[str]:
+        """Build the arguments to pass to Robot Framework."""
+        result = []
+
+        sorted_fields = sorted(
+            (f for f in dataclasses.fields(self) if f.metadata.get("robot_priority", -1) > -1),
+            key=lambda f: f.metadata.get("robot_priority", 0),
+        )
+
+        def append_name(field: "dataclasses.Field[Any]", add_flag: Optional[str] = None) -> None:
+            if "robot_short_name" in field.metadata:
+                result.append(f"-{field.metadata['robot_short_name']}")
+            elif "robot_name" in field.metadata:
+                result.append(f"--{'no' if add_flag else ''}{field.metadata['robot_name']}")
+
+        for field in sorted_fields:
             try:
-                if isinstance(getattr(result, f.name), Condition):
-                    setattr(result, f.name, getattr(result, f.name).evaluate())
-                elif isinstance(getattr(result, f.name), Expression):
-                    setattr(result, f.name, getattr(result, f.name).evaluate())
-                elif isinstance(getattr(result, f.name), list):
-                    setattr(
-                        result,
-                        f.name,
-                        [e.evaluate() if isinstance(e, Expression) else e for e in getattr(result, f.name)],
-                    )
-                elif isinstance(getattr(result, f.name), dict):
-                    setattr(
-                        result,
-                        f.name,
-                        {
-                            k: e.evaluate() if isinstance(e, Expression) else e
-                            for k, e in getattr(result, f.name).items()
-                        },
+                value = getattr(self, field.name)
+                if value is None:
+                    continue
+
+                if field.metadata.get("robot_is_flag", False):
+                    if value is None or value == Flag.DEFAULT:
+                        continue
+
+                    append_name(
+                        field,
+                        bool(value) != field.metadata.get("robot_flag_default", True),
                     )
+
+                    continue
+
+                if isinstance(value, list):
+                    for item in value:
+                        append_name(field)
+                        if isinstance(item, dict):
+                            for k, v in item.items():
+                                result.append(f"{k}:{v}")
+                        else:
+                            result.append(str(item))
+                elif isinstance(value, dict):
+                    for key, item in value.items():
+                        append_name(field)
+                        if isinstance(item, list):
+                            str_item = [str(i) for i in item]
+                            separator = ";" if any(True for s in str_item if ":" in s) else ":"
+                            result.append(f"{key}{separator if item else ''}{separator.join(str_item)}")
+                        else:
+                            result.append(f"{key}:{item}")
+                else:
+                    append_name(field)
+                    result.append(str(value))
             except EvaluationError as e:
-                message = f"Evaluation of '{f.name}' failed: {type(e).__name__}: {e}"
-                if error_callback is None:
-                    raise ValueError(message) from e
-                error_callback(message)
+                raise ValueError(f"Evaluation of '{field.name}' failed: {e!s}") from e
 
         return result
 
@@ -413,7 +418,7 @@ class BaseOptions(ValidateMixin):
 
 
 @dataclass
-class CommonOptions(BaseOptions):
+class CommonOptions(RobotBaseOptions):
     """Common options for all _robot_ commands."""
 
     console_colors: Optional[Literal["auto", "on", "ansi", "off"]] = field(
@@ -972,7 +977,7 @@ class CommonOptions(BaseOptions):
 
 
 @dataclass
-class CommonExtendOptions(BaseOptions):
+class CommonExtendOptions(RobotBaseOptions):
     """Extra common options for all _robot_ commands."""
 
     extend_excludes: Optional[List[Union[str, StringExpression]]] = field(
@@ -1297,7 +1302,7 @@ class CommonExtendOptions(BaseOptions):
 
 
 @dataclass
-class RobotOptions(BaseOptions):
+class RobotOptions(RobotBaseOptions):
     """Options for _robot_ command."""
 
     console: Optional[Literal["verbose", "dotted", "skipped", "quiet", "none"]] = field(
@@ -1674,7 +1679,7 @@ class RobotOptions(BaseOptions):
 
 
 @dataclass
-class RobotExtendOptions(BaseOptions):
+class RobotExtendOptions(RobotBaseOptions):
     """Extra options for _robot_ command."""
 
     extend_languages: Optional[List[Union[str, StringExpression]]] = field(
@@ -1789,7 +1794,7 @@ class RobotExtendOptions(BaseOptions):
 
 
 @dataclass
-class RebotOptions(BaseOptions):
+class RebotOptions(RobotBaseOptions):
     """Options for _rebot_ command."""
 
     end_time: Optional[Union[str, StringExpression]] = field(
@@ -1884,7 +1889,7 @@ class RebotOptions(BaseOptions):
 
 
 @dataclass
-class LibDocOptions(BaseOptions):
+class LibDocOptions(RobotBaseOptions):
     """Options for _libdoc_ command."""
 
     doc_format: Optional[Literal["ROBOT", "HTML", "TEXT", "REST"]] = field(
@@ -1976,7 +1981,7 @@ class LibDocOptions(BaseOptions):
 
 
 @dataclass
-class LibDocExtendOptions(BaseOptions):
+class LibDocExtendOptions(RobotBaseOptions):
     """Extra options for _libdoc_ command."""
 
     extend_python_path: Optional[List[Union[str, StringExpression]]] = field(
@@ -1992,7 +1997,7 @@ class LibDocExtendOptions(BaseOptions):
 
 
 @dataclass
-class TestDocOptions(BaseOptions):
+class TestDocOptions(RobotBaseOptions):
     """Options for _testdoc_ command."""
 
     doc: Optional[Union[str, StringExpression]] = field(
@@ -2090,7 +2095,7 @@ class TestDocOptions(BaseOptions):
 
 
 @dataclass
-class TestDocExtendOptions(BaseOptions):
+class TestDocExtendOptions(RobotBaseOptions):
     """Extra options for _testdoc_ command."""
 
     extend_excludes: Optional[List[Union[str, StringExpression]]] = field(
@@ -2378,7 +2383,7 @@ class RobotConfig(RobotExtendBaseProfile):
 
     extend_profiles: Optional[Dict[str, RobotProfile]] = field(description="Extra execution profiles.")
 
-    tool: Any = field(description="Tool configurations.")
+    tool: Optional[Dict[str, Any]] = field(description="Tool configurations.")
 
     def _select_profiles(
         self,

robotcode/robot/diagnostics/diagnostics_modifier.py

@@ -2,7 +2,8 @@ import functools
 import re as re
 from ast import AST
 from collections import defaultdict
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from enum import Enum
 from typing import Dict, List, Optional, Set, Union
 
 from robot.parsing.lexer.tokens import Token
@@ -12,15 +13,32 @@ from robotcode.core.lsp.types import Diagnostic, DiagnosticSeverity
 
 from ..utils.visitor import Visitor
 
-ACTIONS = ["ignore", "error", "warn", "information", "hint", "reset"]
+ACTIONS = ["ignore", "error", "warn", "warning", "info", "information", "hint", "reset"]
 
 ROBOTCODE_ACTION_AND_CODES_PATTERN = re.compile(rf"(?P<action>{'|'.join(ACTIONS)})(\[(?P<codes>[^\]]*?)\])?")
 
 
+class ModifierAction(Enum):
+    IGNORE = "ignore"
+    ERROR = "error"
+    WARNING = "warning"
+    INFORMATION = "information"
+    HINT = "hint"
+    RESET = "reset"
+
+    @classmethod
+    def from_str(cls, value: str) -> "ModifierAction":
+        if value == "warn":
+            value = "warning"
+        elif value == "info":
+            value = "information"
+        return cls(value)
+
+
 @dataclass
 class RulesAndCodes:
     codes: Dict[Union[str, int], Set[int]]
-    actions: Dict[int, Dict[Union[str, int], str]]
+    actions: Dict[int, Dict[Union[str, int], ModifierAction]]
 
 
 _translation_table = str.maketrans("", "", "_- ")
@@ -28,7 +46,7 @@ _translation_table = str.maketrans("", "", "_- ")
 ROBOTCODE_MARKER = "robotcode:"
 
 
-class DisablersVisitor(Visitor):
+class ModifiersVisitor(Visitor):
 
     def __init__(self) -> None:
         super().__init__()
@@ -65,8 +83,8 @@ class DisablersVisitor(Visitor):
         self._handle_statement_comments(node)
         self.generic_visit(node)
 
-    def _parse_robotcode_disabler(self, comment: str) -> Dict[str, List[str]]:
-        result: Dict[str, List[str]] = {}
+    def _parse_robotcode_disabler(self, comment: str) -> Dict[ModifierAction, List[str]]:
+        result: Dict[ModifierAction, List[str]] = {}
 
         comment = comment.strip()
         m = ROBOTCODE_ACTION_AND_CODES_PATTERN.match(comment)
@@ -74,7 +92,8 @@ class DisablersVisitor(Visitor):
             return result
 
         for m in ROBOTCODE_ACTION_AND_CODES_PATTERN.finditer(comment):
-            action = m.group("action")
+            action_str = m.group("action")
+            action = ModifierAction.from_str(action_str)
             messages = m.group("codes")
             result[action] = (
                 [m.strip().translate(_translation_table).lower() for m in messages.split(",")]
@@ -153,19 +172,36 @@ class DisablersVisitor(Visitor):
                             self.rules_and_codes.actions[i][code] = action
 
 
+@dataclass
+class DiagnosticModifiersConfig:
+    ignore: List[str] = field(default_factory=list)
+    error: List[str] = field(default_factory=list)
+    warning: List[str] = field(default_factory=list)
+    information: List[str] = field(default_factory=list)
+    hint: List[str] = field(default_factory=list)
+
+
 class DiagnosticsModifier:
-    def __init__(self, model: AST) -> None:
+    def __init__(self, model: AST, config: Optional[DiagnosticModifiersConfig] = None) -> None:
+        self.config = config or DiagnosticModifiersConfig()
+
+        self.config.ignore = [i.translate(_translation_table).lower() for i in self.config.ignore]
+        self.config.error = [i.translate(_translation_table).lower() for i in self.config.error]
+        self.config.warning = [i.translate(_translation_table).lower() for i in self.config.warning]
+        self.config.information = [i.translate(_translation_table).lower() for i in self.config.information]
+        self.config.hint = [i.translate(_translation_table).lower() for i in self.config.hint]
+
         self.model = model
 
     @functools.cached_property
     def rules_and_codes(self) -> RulesAndCodes:
-        visitor = DisablersVisitor()
+        visitor = ModifiersVisitor()
         visitor.visit(self.model)
         return visitor.rules_and_codes
 
     def modify_diagnostic(self, diagnostic: Diagnostic) -> Optional[Diagnostic]:
         if diagnostic.code is not None:
-            code = (
+            code = orig_code = (
                 str(diagnostic.code).translate(_translation_table).lower()
                 if diagnostic.code is not None
                 else "unknowncode"
@@ -177,24 +213,51 @@ class DiagnosticsModifier:
                 code = "*"
                 lines = self.rules_and_codes.codes.get(code)
 
+            modified = False
             if lines is not None and diagnostic.range.start.line in lines:
                 actions = self.rules_and_codes.actions.get(diagnostic.range.start.line)
                 if actions is not None:
                     action = actions.get(code)
                     if action is not None:
-                        if action == "ignore":
+                        if action == ModifierAction.IGNORE:
                             return None
-                        if action == "reset":
-                            pass  # do nothing
-                        elif action == "error":
+                        if action == ModifierAction.RESET:
+                            pass
+                        elif action == ModifierAction.ERROR:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.ERROR
-                        elif action == "warn":
+                        elif action == ModifierAction.WARNING:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.WARNING
-                        elif action == "information":
+                        elif action == ModifierAction.INFORMATION:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.INFORMATION
-                        elif action == "hint":
+                        elif action == ModifierAction.HINT:
+                            modified = True
                             diagnostic.severity = DiagnosticSeverity.HINT
 
+            if not modified:
+                if orig_code in self.config.ignore:
+                    return None
+                if orig_code in self.config.error:
+                    diagnostic.severity = DiagnosticSeverity.ERROR
+                elif orig_code in self.config.warning:
+                    diagnostic.severity = DiagnosticSeverity.WARNING
+                elif orig_code in self.config.information:
+                    diagnostic.severity = DiagnosticSeverity.INFORMATION
+                elif orig_code in self.config.hint:
+                    diagnostic.severity = DiagnosticSeverity.HINT
+                elif "*" in self.config.hint:
+                    diagnostic.severity = DiagnosticSeverity.HINT
+                elif "*" in self.config.information:
+                    diagnostic.severity = DiagnosticSeverity.INFORMATION
+                elif "*" in self.config.warning:
+                    diagnostic.severity = DiagnosticSeverity.WARNING
+                elif "*" in self.config.error:
+                    diagnostic.severity = DiagnosticSeverity.ERROR
+                elif "*" in self.config.ignore:
+                    return None
+
         return diagnostic
 
     def modify_diagnostics(self, diagnostics: List[Diagnostic]) -> List[Diagnostic]:

robotcode/robot/diagnostics/document_cache_helper.py

@@ -26,7 +26,7 @@ from robotcode.core.text_document import TextDocument
 from robotcode.core.uri import Uri
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.core.workspace import Workspace, WorkspaceFolder
-from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticsModifier
+from robotcode.robot.diagnostics.diagnostics_modifier import DiagnosticModifiersConfig, DiagnosticsModifier
 
 from ..config.model import RobotBaseProfile
 from ..utils import get_robot_version
@@ -34,7 +34,13 @@ 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
+from .workspace_config import (
+    AnalysisDiagnosticModifiersConfig,
+    AnalysisRobotConfig,
+    CacheConfig,
+    RobotConfig,
+    WorkspaceAnalysisConfig,
+)
 
 
 class UnknownFileTypeError(Exception):
@@ -54,6 +60,7 @@ class DocumentsCacheHelper:
         documents_manager: DocumentsManager,
         file_watcher_manager: FileWatcherManagerBase,
         robot_profile: Optional[RobotBaseProfile],
+        analysis_config: Optional[WorkspaceAnalysisConfig],
     ) -> None:
         self.INITIALIZED_NAMESPACE = _CacheEntry()
 
@@ -62,6 +69,7 @@ class DocumentsCacheHelper:
         self.file_watcher_manager = file_watcher_manager
 
         self.robot_profile = robot_profile or RobotBaseProfile()
+        self.analysis_config = analysis_config or WorkspaceAnalysisConfig()
 
         self._imports_managers_lock = threading.RLock()
         self._imports_managers: weakref.WeakKeyDictionary[WorkspaceFolder, ImportsManager] = weakref.WeakKeyDictionary()
@@ -514,10 +522,10 @@ class DocumentsCacheHelper:
             variables,
             variable_files,
             environment,
-            cache_config.ignored_libraries,
-            cache_config.ignored_variables,
-            cache_config.ignore_arguments_for_library,
-            analysis_config.global_library_search_order,
+            self.analysis_config.cache.ignored_libraries + cache_config.ignored_libraries,
+            self.analysis_config.cache.ignored_variables + cache_config.ignored_variables,
+            self.analysis_config.cache.ignore_arguments_for_library + cache_config.ignore_arguments_for_library,
+            self.analysis_config.robot.global_library_search_order + analysis_config.global_library_search_order,
             cache_base_path,
         )
 
@@ -583,4 +591,14 @@ class DocumentsCacheHelper:
         return document.get_cache(self.__get_diagnostic_modifier)
 
     def __get_diagnostic_modifier(self, document: TextDocument) -> DiagnosticsModifier:
-        return DiagnosticsModifier(self.get_model(document, False))
+        modifiers_config = self.workspace.get_configuration(AnalysisDiagnosticModifiersConfig, document.uri)
+        return DiagnosticsModifier(
+            self.get_model(document, False),
+            DiagnosticModifiersConfig(
+                ignore=self.analysis_config.modifiers.ignore + modifiers_config.ignore,
+                error=self.analysis_config.modifiers.error + modifiers_config.error,
+                warning=self.analysis_config.modifiers.warning + modifiers_config.warning,
+                information=self.analysis_config.modifiers.information + modifiers_config.information,
+                hint=self.analysis_config.modifiers.hint + modifiers_config.hint,
+            ),
+        )

robotcode/robot/diagnostics/workspace_config.py

@@ -55,3 +55,20 @@ class CacheConfig(ConfigBase):
 @dataclass
 class AnalysisRobotConfig(ConfigBase):
     global_library_search_order: List[str] = field(default_factory=list)
+
+
+@config_section("robotcode.analysis.diagnosticModifiers")
+@dataclass
+class AnalysisDiagnosticModifiersConfig(ConfigBase):
+    ignore: List[str] = field(default_factory=list)
+    error: List[str] = field(default_factory=list)
+    warning: List[str] = field(default_factory=list)
+    information: List[str] = field(default_factory=list)
+    hint: List[str] = field(default_factory=list)
+
+
+@dataclass
+class WorkspaceAnalysisConfig:
+    cache: CacheConfig = field(default_factory=CacheConfig)
+    robot: AnalysisRobotConfig = field(default_factory=AnalysisRobotConfig)
+    modifiers: AnalysisDiagnosticModifiersConfig = field(default_factory=AnalysisDiagnosticModifiersConfig)

{robotcode_robot-0.91.0.dist-info → robotcode_robot-0.92.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotcode-robot
-Version: 0.91.0
+Version: 0.92.0
 Summary: Support classes for RobotCode for handling Robot Framework projects.
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -26,7 +26,7 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
 Requires-Dist: platformdirs<4.2.0,>=3.2.0
-Requires-Dist: robotcode-core==0.91.0
+Requires-Dist: robotcode-core==0.92.0
 Requires-Dist: robotframework>=4.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Description-Content-Type: text/markdown

{robotcode_robot-0.91.0.dist-info → robotcode_robot-0.92.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 robotcode/robot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/__version__.py,sha256=RBon26SFk4Bs08h0XAmTYW8lrYs3N9ihifF9r6VT4Vc,23
+robotcode/robot/__version__.py,sha256=4oQqdZ-jW338RGQfLxI7hoQNb8tTR6y4hzWoJRPdI3o,23
 robotcode/robot/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
 robotcode/robot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/config/loader.py,sha256=LpGqJAdysvVSZpccW-Il52xn9RMBBb9X94emlBY7zCc,6077
-robotcode/robot/config/model.py,sha256=w2qqxPwuv-N3GEZsCaaxFxU5iPfQr3oS1mqMkZFkRPU,88891
+robotcode/robot/config/loader.py,sha256=5PQTWDn1vYFN0VmLVhEYdu12Foq1AwRtDFvjU44QQvw,7878
+robotcode/robot/config/model.py,sha256=sgr6-4_E06g-yIXW41Z-NtIXZ_7JMmR5WvUD7kTUqu4,89106
 robotcode/robot/config/utils.py,sha256=c_WZg39DJgM6kXcAH_h-v68qhf1eStJ0TslTawaJoZw,2827
 robotcode/robot/diagnostics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=9AFptQsdw_TvgBkKqutpvI8WKsOUXipXQDOExarJJy4,6903
-robotcode/robot/diagnostics/document_cache_helper.py,sha256=pa9AdSbEFZJ6VSdZluGyfzyZPjzBfNFAv5pXJEM-7fc,22664
+robotcode/robot/diagnostics/diagnostics_modifier.py,sha256=3dDsu8-ET6weIvv7Sk3IQaPYFNxnXUs8Y7gpGTjfOBs,9796
+robotcode/robot/diagnostics/document_cache_helper.py,sha256=MlOPXC3mUVjNB2rHn5UJK7NnUPa8S4mE3qojILOi_Mk,23756
 robotcode/robot/diagnostics/entities.py,sha256=AtrqPAS3XUC-8VpFmqMXfMKjQHmfxXZlyGWWFaEBpQA,10979
 robotcode/robot/diagnostics/errors.py,sha256=HCE0h0_ui1tx-6pJHs0r4s09ZHmArYwKUo-_lBl9K-4,1600
 robotcode/robot/diagnostics/imports_manager.py,sha256=qE__lm0Hsj3R0gUauXRmbWJPYihNjk3O-c5hcICGQjc,56251
@@ -15,7 +15,7 @@ robotcode/robot/diagnostics/library_doc.py,sha256=CHgyC9GMRQFP3fGTxWa139rIcGIk8Y
 robotcode/robot/diagnostics/model_helper.py,sha256=_5ixKKMrb-nY-uvV8_WjJ1rlNlz7gT7kHM5NYi_hjVg,30232
 robotcode/robot/diagnostics/namespace.py,sha256=jCUb5GmMDA6KTr2BnwHD_0Mp_gTg1XGskUvRYPL7XQ0,89543
 robotcode/robot/diagnostics/namespace_analyzer.py,sha256=3eC1xEBm_foCnqoHk8Cj6O11UXOHcHxWnfuKP8M5KIQ,51369
-robotcode/robot/diagnostics/workspace_config.py,sha256=lWNq1KmGGJ9cHFNHn0QTCBHHzgz4AewTw0l-W4TKrj0,1803
+robotcode/robot/diagnostics/workspace_config.py,sha256=3SoewUj_LZB1Ki5hXM8oxQpJr6vyiog66SUw-ibODSA,2478
 robotcode/robot/utils/__init__.py,sha256=OjNPMn_XSnfaMCyKd8Kmq6vlRt6mIGlzW4qiiD3ykUg,447
 robotcode/robot/utils/ast.py,sha256=ynxvXv1SHkAcF07m76ey9_zaGCYXhlPOnny7km-XWSQ,10479
 robotcode/robot/utils/markdownformatter.py,sha256=0XZZ5wDU2yfzIuShjG7h79PgzMaQJ501WH4YRFcG1VM,11615
@@ -24,7 +24,7 @@ robotcode/robot/utils/robot_path.py,sha256=qKBh1cEnReBBLKkWu4gB9EzM-scAwE4xJc1m6
 robotcode/robot/utils/stubs.py,sha256=6-DMI_CQVJHDgG13t-zINKGCRb_Q7MQPm0_AkfhAEvE,748
 robotcode/robot/utils/variables.py,sha256=fEl8S37lb_mD4hn2MZRAlkiuLGBjAOeZVK0r2o2CfPw,742
 robotcode/robot/utils/visitor.py,sha256=uYLqEhGPmzWKWI3SSrmCaYMwtKvNShvbiPZ4b3FavX8,3241
-robotcode_robot-0.91.0.dist-info/METADATA,sha256=Cl7XlzEEn_Q5xmyv7C6R09JliQm1pL45DGuC-M4cSrY,2240
-robotcode_robot-0.91.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-robotcode_robot-0.91.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-robotcode_robot-0.91.0.dist-info/RECORD,,
+robotcode_robot-0.92.0.dist-info/METADATA,sha256=H_aQghUcVbx_6vUwIw0DTqVSUhN1ewvzGjinWv-MEX0,2240
+robotcode_robot-0.92.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+robotcode_robot-0.92.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+robotcode_robot-0.92.0.dist-info/RECORD,,