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

robotcode/robot/__version__.py

@@ -1 +1 @@
-__version__ = "0.91.0"
+__version__ = "0.93.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
 
@@ -27,6 +28,7 @@ class DiscoverdBy(str, Enum):
     LOCAL_ROBOT_TOML = ".robot.toml (local file)"
     USER_DEFAULT_CONFIG_TOML = "robot.toml (user default config)"
     NOT_FOUND = "not found"
+    COMMAND_LINE = "command line"
 
 
 class ConfigType(str, Enum):
@@ -58,9 +60,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 +75,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,39 +120,85 @@ 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(
     *sources: Union[str, Path],
+    root_folder: Optional[Path] = None,
+    no_vcs: bool = False,
 ) -> Tuple[Optional[Path], DiscoverdBy]:
+
+    if root_folder:
+        return root_folder.absolute(), DiscoverdBy.COMMAND_LINE
+
     if not sources:
         sources = (str(Path.cwd().absolute()),)
 
@@ -168,11 +221,12 @@ def find_project_root(
         if (directory / PYPROJECT_TOML).is_file():
             return directory, DiscoverdBy.PYPROJECT_TOML
 
-        if (directory / ".git").exists():
-            return directory, DiscoverdBy.GIT
+        if not no_vcs:
+            if (directory / ".git").exists():
+                return directory, DiscoverdBy.GIT
 
-        if (directory / ".hg").is_dir():
-            return directory, DiscoverdBy.HG
+            if (directory / ".hg").is_dir():
+                return directory, DiscoverdBy.HG
 
     return None, DiscoverdBy.NOT_FOUND
 

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/config/utils.py

@@ -43,10 +43,12 @@ def get_user_config_file(
 def get_config_files(
     paths: Optional[Sequence[Union[str, Path]]] = None,
     config_files: Optional[Sequence[Path]] = None,
+    root_folder: Optional[Path] = None,
+    no_vcs: bool = False,
     *,
     verbose_callback: Optional[Callable[[str], None]] = None,
 ) -> Tuple[Sequence[Tuple[Path, ConfigType]], Optional[Path], DiscoverdBy]:
-    root_folder, discovered_by = find_project_root(*(paths or []))
+    root_folder, discovered_by = find_project_root(*(paths or []), root_folder=root_folder, no_vcs=no_vcs)
 
     if root_folder is None:
         root_folder = Path.cwd()
@@ -54,7 +56,7 @@ def get_config_files(
             verbose_callback(f"Cannot detect root folder. Use current folder '{root_folder}' as root.")
 
     if verbose_callback:
-        verbose_callback(f"Found root at:\n    {root_folder} ({discovered_by.value})")
+        verbose_callback(f"Use root at:\n    {root_folder} ({discovered_by.value})")
 
     if config_files:
         if verbose_callback: