refactor: fix some ruff warnings

d-biehl · d-biehl · commit 11614517b922 · 2023-05-13T21:26:36.000+02:00
diff --git a/packages/core/src/robotcode/core/async_tools.py b/packages/core/src/robotcode/core/async_tools.py
@@ -523,7 +523,7 @@ def set_result(w: asyncio.Future[Any], ev: threading.Event) -> None:
 
                         time.sleep(0.001)
         else:
-            warnings.warn(f"Future {repr(fut)} loop is closed")
+            warnings.warn(f"Future {fut!r} loop is closed")
             self._waiters.remove(fut)
             self._wake_up_first()
 
diff --git a/packages/core/src/robotcode/core/dataclasses.py b/packages/core/src/robotcode/core/dataclasses.py
@@ -172,7 +172,7 @@ def __default(o: Any) -> Any:
     if isinstance(o, Set):
         return list(o)
 
-    raise TypeError(f"Cant' get default value for {type(o)} with value {repr(o)}")
+    raise TypeError(f"Cant' get default value for {type(o)} with value {o!r}")
 
 
 def as_json(obj: Any, indent: Optional[bool] = None, compact: Optional[bool] = None) -> str:
@@ -298,7 +298,7 @@ def from_dict(
                 match_type_hints = type_hints
             elif match_same_keys is not None and len(match_same_keys) == len(same_keys):
                 raise TypeError(
-                    f"Value {repr(value)} matches to more then one types of "
+                    f"Value {value!r} matches to more then one types of "
                     f"{repr(types[0].__name__) if len(types)==1 else ' | '.join(repr(e.__name__) for e in types)}."
                 )
 
@@ -317,7 +317,7 @@ def from_dict(
             try:
                 return match_(**params)
             except TypeError as ex:
-                raise TypeError(f"Can't initialize class {repr(match_)} with parameters {repr(params)}.") from ex
+                raise TypeError(f"Can't initialize class {match_!r} with parameters {params!r}.") from ex
 
     for t in types:
         args = get_args(t)
@@ -332,7 +332,7 @@ def from_dict(
                     return cast(_T, v)
 
     raise TypeError(
-        f"Cant convert value {repr(value)} of type {type(value).__name__} to type(s) "
+        f"Cant convert value {value!r} of type {type(value).__name__} to type(s) "
         + (
             repr(types[0])
             if len(types) == 1
@@ -415,13 +415,13 @@ def __repr__(self) -> str:
         cls = self.class_
         cls_name = f"{cls.__module__}.{cls.__name__}" if cls.__module__ != "__main__" else cls.__name__
         attrs = ", ".join([repr(v) for v in self.args])
-        return f"{cls_name}({attrs}, errors={repr(self.errors)})"
+        return f"{cls_name}({attrs}, errors={self.errors!r})"
 
     def __str__(self) -> str:
         cls = self.class_
         cls_name = f"{cls.__module__}.{cls.__name__}" if cls.__module__ != "__main__" else cls.__name__
         s = cls_name
-        return f"{s} (errors = {repr(self.errors)})"
+        return f"{s} (errors = {self.errors!r})"
 
 
 def validate_types(expected_types: Union[type, Tuple[type, ...], None], value: Any) -> List[str]:
diff --git a/packages/core/src/robotcode/core/logging.py b/packages/core/src/robotcode/core/logging.py
@@ -307,7 +307,7 @@ def name(self) -> str:
     def __repr__(self) -> str:
         logger = self.logger
         level = logging.getLevelName(logger.getEffectiveLevel())
-        return f"{self.__class__.__name__}(name={repr(logger.name)}, level={repr(level)})"
+        return f"{self.__class__.__name__}(name={logger.name!r}, level={level!r})"
 
     _call_tracing_enabled: ClassVar = (
         "ROBOT_CALL_TRACING_ENABLED" in os.environ and os.environ["ROBOT_CALL_TRACING_ENABLED"] != "0"
@@ -438,7 +438,7 @@ def build_enter_message() -> str:
                         ", ".join(_repr(a) for a in message_args),
                         (", " if len(message_args) > 0 and len(wrapper_kwargs) > 0 else ""),
                         (
-                            ", ".join(f"{str(k)}={_repr(v)}" for k, v in wrapper_kwargs.items())
+                            ", ".join(f"{k!s}={_repr(v)}" for k, v in wrapper_kwargs.items())
                             if len(wrapper_kwargs) > 0
                             else ""
                         ),
diff --git a/packages/core/src/robotcode/core/uri.py b/packages/core/src/robotcode/core/uri.py
@@ -93,7 +93,7 @@ def __str__(self) -> str:
         return parse.urlunparse(tuple(self._parts))
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}({repr(parse.urlunparse(tuple(self._parts)))})"
+        return f"{type(self).__name__}({parse.urlunparse(tuple(self._parts))!r})"
 
     def to_path(self) -> Path:
         if self._path is None:
@@ -112,7 +112,7 @@ def _to_path_str(self) -> str:
         path = parse.unquote(self.path)
 
         if self._parts.scheme != "file":
-            raise InvalidUriError(f"Invalid URI scheme '{str(self)}'.")
+            raise InvalidUriError(f"Invalid URI scheme '{self!s}'.")
 
         if netloc and self._parts.scheme == "file":
             # unc path: file://shares/c$/far/boo
diff --git a/packages/core/src/robotcode/core/utils/glob_path.py b/packages/core/src/robotcode/core/utils/glob_path.py
@@ -81,7 +81,7 @@ def __str__(self) -> str:
         return self.pattern
 
     def __repr__(self) -> str:
-        return f"{type(self).__qualname__}(pattern={repr(self.pattern)}"
+        return f"{type(self).__qualname__}(pattern={self.pattern!r}"
 
 
 def globmatches(pattern: str, path: Union[Path, str, os.PathLike[Any]]) -> bool:
diff --git a/packages/debugger/src/robotcode/debugger/debugger.py b/packages/debugger/src/robotcode/debugger/debugger.py
@@ -164,10 +164,7 @@ def __init__(
         self.stack_frames: Deque[StackFrameEntry] = deque()
 
     def __repr__(self) -> str:
-        return (
-            f"StackFrameEntry({repr(self.name)}, {repr(self.type)}, "
-            f"{repr(self.source)}, {repr(self.line)}, {repr(self.column)})"
-        )
+        return f"StackFrameEntry({self.name!r}, {self.type!r}, {self.source!r}, {self.line!r}, {self.column!r})"
 
     def get_first_or_self(self) -> StackFrameEntry:
         if self.stack_frames:
diff --git a/packages/debugger/src/robotcode/debugger/protocol.py b/packages/debugger/src/robotcode/debugger/protocol.py
@@ -136,7 +136,7 @@ def _handle_body(self, body: bytes, charset: str) -> None:
         except BaseException as e:
             self._logger.exception(e)
             self.send_error(
-                f"Invalid Message: {type(e).__name__}: {str(e)} -> {str(body)}\n{traceback.format_exc()}",
+                f"Invalid Message: {type(e).__name__}: {e!s} -> {body!s}\n{traceback.format_exc()}",
                 error_message=Message(traceback.format_exc()),
             )
 
@@ -244,7 +244,7 @@ def done(t: asyncio.Task[Any]) -> None:
             try:
                 self.send_response(message.seq, message.command, t.result())
             except asyncio.CancelledError:
-                self._logger.debug(lambda: f"request message {repr(message)} canceled")
+                self._logger.debug(lambda: f"request message {message!r} canceled")
             except (SystemExit, KeyboardInterrupt):
                 raise
             except DebugAdapterRPCErrorException as ex:
diff --git a/packages/jsonrpc2/src/robotcode/jsonrpc2/protocol.py b/packages/jsonrpc2/src/robotcode/jsonrpc2/protocol.py
@@ -610,7 +610,7 @@ def set_result(f: asyncio.Future[Any], r: Any, ev: threading.Event) -> None:
                             await asyncio.sleep(0)
 
                     else:
-                        self.__logger.warning(lambda: f"Response {repr(entry)} loop is not running.")
+                        self.__logger.warning(lambda: f"Response {entry!r} loop is not running.")
 
         except (SystemExit, KeyboardInterrupt):
             raise
@@ -726,7 +726,7 @@ def done(t: asyncio.Future[Any]) -> None:
 
                 self.send_response(message.id, t.result())
             except asyncio.CancelledError:
-                self.__logger.debug(lambda: f"request message {repr(message)} canceled")
+                self.__logger.debug(lambda: f"request message {message!r} canceled")
                 self.send_error(JsonRPCErrors.REQUEST_CANCELLED, "Request canceled.", id=message.id)
             except (SystemExit, KeyboardInterrupt):
                 raise
diff --git a/packages/language_server/src/robotcode/language_server/common/parts/documents.py b/packages/language_server/src/robotcode/language_server/common/parts/documents.py
@@ -154,7 +154,7 @@ async def get_or_open_document(
         except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
             raise
         except BaseException as e:
-            raise CantReadDocumentError(f"Error reading document '{path}': {str(e)}") from e
+            raise CantReadDocumentError(f"Error reading document '{path}': {e!s}") from e
 
     @async_event
     async def on_read_document_text(sender, uri: Uri) -> Optional[str]:  # NOSONAR
diff --git a/packages/language_server/src/robotcode/language_server/common/parts/workspace.py b/packages/language_server/src/robotcode/language_server/common/parts/workspace.py
@@ -116,7 +116,7 @@ def __str__(self) -> str:
         return self.id
 
     def __repr__(self) -> str:
-        return f"{type(self).__qualname__}(id={repr(self.id)}, watchers={repr(self.watchers)})"
+        return f"{type(self).__qualname__}(id={self.id!r}, watchers={self.watchers!r})"
 
 
 class WorkspaceFolder:
diff --git a/packages/language_server/src/robotcode/language_server/common/text_document.py b/packages/language_server/src/robotcode/language_server/common/text_document.py
@@ -109,12 +109,7 @@ def __str__(self) -> str:  # pragma: no cover
         return self.__repr__()
 
     def __repr__(self) -> str:  # pragma: no cover
-        return (
-            f"TextDocument(uri={repr(self.uri)}, "
-            f"language_id={repr(self.language_id)}, "
-            f"version={repr(self._version)}"
-            f")"
-        )
+        return f"TextDocument(uri={self.uri!r}, language_id={self.language_id!r}, version={self._version!r})"
 
     def text(self) -> str:
         with self._lock:
diff --git a/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/entities.py b/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/entities.py
@@ -152,7 +152,7 @@ def __str__(self) -> str:
         return self.name
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}(name={repr(self.name)})"
+        return f"{type(self).__name__}(name={self.name!r})"
 
 
 class VariableDefinitionType(Enum):
diff --git a/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/imports_manager.py b/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/imports_manager.py
@@ -174,8 +174,8 @@ def __init__(
 
     def __repr__(self) -> str:
         return (
-            f"{type(self).__qualname__}(name={repr(self.name)}, "
-            f"args={repr(self.args)}, file_watchers={repr(self.file_watchers)}, id={repr(id(self))}"
+            f"{type(self).__qualname__}(name={self.name!r}, "
+            f"args={self.args!r}, file_watchers={self.file_watchers!r}, id={id(self)!r}"
         )
 
     async def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileChangeType]:
@@ -307,10 +307,7 @@ def __init__(
         self._lib_doc: Optional[LibraryDoc] = None
 
     def __repr__(self) -> str:
-        return (
-            f"{type(self).__qualname__}(name={repr(self.name)}, "
-            f"file_watchers={repr(self.file_watchers)}, id={repr(id(self))}"
-        )
+        return f"{type(self).__qualname__}(name={self.name!r}, file_watchers={self.file_watchers!r}, id={id(self)!r}"
 
     async def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileChangeType]:
         async with self._lock:
@@ -415,8 +412,8 @@ def __init__(
 
     def __repr__(self) -> str:
         return (
-            f"{type(self).__qualname__}(name={repr(self.name)}, "
-            f"args={repr(self.args)}, file_watchers={repr(self.file_watchers)}, id={repr(id(self))}"
+            f"{type(self).__qualname__}(name={self.name!r}, "
+            f"args={self.args!r}, file_watchers={self.file_watchers!r}, id={id(self)!r}"
         )
 
     async def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileChangeType]:
@@ -996,7 +993,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                 variables,
             )
 
-            self._logger.debug(lambda: f"Load Library {source}{repr(args)}")
+            self._logger.debug(lambda: f"Load Library {source}{args!r}")
             if meta is not None:
                 meta_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
                 if meta_file.exists():
@@ -1037,7 +1034,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                 )
 
             if result.stdout:
-                self._logger.warning(lambda: f"stdout captured at loading library {name}{repr(args)}:\n{result.stdout}")
+                self._logger.warning(lambda: f"stdout captured at loading library {name}{args!r}:\n{result.stdout}")
             try:
                 if meta is not None:
                     meta_file = Path(self.lib_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
@@ -1053,7 +1050,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
 
                     meta_file.write_text(as_json(meta), "utf-8")
                 else:
-                    self._logger.debug(lambda: f"Skip caching library {name}{repr(args)}")
+                    self._logger.debug(lambda: f"Skip caching library {name}{args!r}")
             except (SystemExit, KeyboardInterrupt):
                 raise
             except BaseException as e:
@@ -1140,7 +1137,7 @@ class MyUserLibrary(UserLibrary):
 
             def _log_creating_failed(self, handler: UserErrorHandler, error: BaseException) -> None:
                 err = Error(
-                    message=f"Creating keyword '{handler.name}' failed: {str(error)}",
+                    message=f"Creating keyword '{handler.name}' failed: {error!s}",
                     type_name=type(error).__qualname__,
                     source=self.current_kw.source if self.current_kw is not None else None,
                     line_no=self.current_kw.lineno if self.current_kw is not None else None,
@@ -1236,7 +1233,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                 variables,
             )
 
-            self._logger.debug(lambda: f"Load variables {source}{repr(args)}")
+            self._logger.debug(lambda: f"Load variables {source}{args!r}")
             if meta is not None:
                 meta_file = Path(self.variables_doc_cache_path, meta.filepath_base.with_suffix(".meta.json"))
                 if meta_file.exists():
@@ -1280,7 +1277,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
 
                 if result.stdout:
                     self._logger.warning(
-                        lambda: f"stdout captured at loading variables {name}{repr(args)}:\n{result.stdout}"
+                        lambda: f"stdout captured at loading variables {name}{args!r}:\n{result.stdout}"
                     )
 
                 try:
@@ -1297,7 +1294,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                             raise RuntimeError(f"Cannot write spec file for variables '{name}' to '{spec_file}'") from e
                         meta_file.write_text(as_json(meta), "utf-8")
                     else:
-                        self._logger.debug(lambda: f"Skip caching variables {name}{repr(args)}")
+                        self._logger.debug(lambda: f"Skip caching variables {name}{args!r}")
                 except (SystemExit, KeyboardInterrupt):
                     raise
                 except BaseException as e:
diff --git a/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/library_doc.py b/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/library_doc.py
@@ -195,7 +195,7 @@ def __str__(self) -> str:
         return self.name
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}(name={repr(self.name)})"
+        return f"{type(self).__name__}(name={self.name!r})"
 
 
 RUN_KEYWORD_WITH_CONDITION_MATCHERS = [KeywordMatcher(e) for e in RUN_KEYWORD_WITH_CONDITION_NAMES]
@@ -456,9 +456,9 @@ def _get_signature(self, header_level: int, add_type: bool = True) -> str:
                     prefix = "**"
 
                 result += (
-                    f"\n| `{prefix}{str(a.name)}`"
+                    f"\n| `{prefix}{a.name!s}`"
                     f"| {'=' if a.default_value is not None else ''}"
-                    f"| {f'`{str(a.default_value)}`' if a.default_value else ''}"
+                    f"| {f'`{a.default_value!s}`' if a.default_value else ''}"
                     f"| {' or '.join(f'`<{s}>`' for s in a.types) if a.types is not None else ''} |"
                 )
 
@@ -754,7 +754,7 @@ def _link_inline_links(self, text: str) -> str:
 
         def repl(m: re.Match) -> str:  # type: ignore
             if m.group(2) in headers:
-                return f"[{str(m.group(2))}](\\#{str(m.group(2)).lower().replace(' ', '-')})"
+                return f"[{m.group(2)!s}](\\#{str(m.group(2)).lower().replace(' ', '-')})"
             return str(m.group(0))
 
         return str(RE_INLINE_LINK.sub(repl, text))
diff --git a/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/namespace.py b/packages/language_server/src/robotcode/language_server/robotframework/diagnostics/namespace.py
@@ -517,7 +517,7 @@ class LibraryEntry:
     def __str__(self) -> str:
         result = self.import_name
         if self.args:
-            result += f"  {str(self.args)}"
+            result += f"  {self.args!s}"
         if self.alias:
             result += f"  WITH NAME  {self.alias}"
         return result
diff --git a/packages/language_server/src/robotcode/language_server/robotframework/parts/robot_workspace.py b/packages/language_server/src/robotcode/language_server/robotframework/parts/robot_workspace.py
@@ -125,7 +125,7 @@ async def _load_workspace_documents(self, sender: Any) -> List[WorkspaceDocument
 
                                     progress.begin()
                                     progress.report(
-                                        f"Load {str(name)}"
+                                        f"Load {name!s}"
                                         if config.analysis.progress_mode == AnalysisProgressMode.DETAILED
                                         else None,
                                         current=i,
@@ -149,7 +149,7 @@ async def _load_workspace_documents(self, sender: Any) -> List[WorkspaceDocument
                             if config.analysis.progress_mode != AnalysisProgressMode.OFF:
                                 progress.begin()
                                 progress.report(
-                                    f"Initialize {str(name)}"
+                                    f"Initialize {name!s}"
                                     if config.analysis.progress_mode == AnalysisProgressMode.DETAILED
                                     else None,
                                     current=i,
diff --git a/packages/language_server/src/robotcode/language_server/robotframework/protocol.py b/packages/language_server/src/robotcode/language_server/robotframework/protocol.py
@@ -161,7 +161,7 @@ async def _on_initialize(self, sender: Any, initialization_options: Optional[Any
 
         self.workspace.did_change_configuration.add(self._on_did_change_configuration)
 
-        self._logger.info(lambda: f"initialized with {repr(self.options)}")
+        self._logger.info(lambda: f"initialized with {self.options!r}")
 
     async def _on_did_change_configuration(self, sender: Any, settings: Dict[str, Any]) -> None:
         pass
diff --git a/packages/robot/src/robotcode/robot/config/model.py b/packages/robot/src/robotcode/robot/config/model.py
@@ -92,7 +92,7 @@ class EvaluationError(Exception):
     """Evaluation error."""
 
     def __init__(self, expression: str, message: str):
-        super().__init__(f"Evaluation of {repr(expression)} failed: {message}")
+        super().__init__(f"Evaluation of {expression!r} failed: {message}")
         self.expr = expression
 
 
@@ -258,7 +258,7 @@ def append_name(field: "dataclasses.Field[Any]", add_flag: Optional[str] = None)
                     append_name(field)
                     result.append(str(value))
             except EvaluationError as e:
-                raise ValueError(f"Evaluation of '{field.name}' failed: {str(e)}") from e
+                raise ValueError(f"Evaluation of '{field.name}' failed: {e!s}") from e
 
         return result
 
@@ -341,7 +341,7 @@ def evaluated(self) -> Self:
                         },
                     )
             except EvaluationError as e:
-                raise ValueError(f"Evaluation of '{f.name}' failed: {str(e)}") from e
+                raise ValueError(f"Evaluation of '{f.name}' failed: {e!s}") from e
         return result
 
 
diff --git a/packages/runner/src/robotcode/runner/cli/discover/discover.py b/packages/runner/src/robotcode/runner/cli/discover/discover.py
@@ -252,7 +252,7 @@ def discover(app: Application, read_from_stdin: bool) -> None:
     if read_from_stdin:
         global _stdin_data
         _stdin_data = from_json(sys.stdin.buffer.read(), Dict[str, str], strict=True)
-        app.verbose(f"Read data from stdin: {repr(_stdin_data)}")
+        app.verbose(f"Read data from stdin: {_stdin_data!r}")
 
 
 RE_IN_FILE_LINE_MATCHER = re.compile(r".+\sin\sfile\s'(?P<file>.*)'\son\sline\s(?P<line>\d+):(?P<message>.*)")
diff --git a/packages/runner/src/robotcode/runner/cli/libdoc.py b/packages/runner/src/robotcode/runner/cli/libdoc.py
diff --git a/packages/runner/src/robotcode/runner/cli/rebot.py b/packages/runner/src/robotcode/runner/cli/rebot.py
diff --git a/packages/runner/src/robotcode/runner/cli/robot.py b/packages/runner/src/robotcode/runner/cli/robot.py
diff --git a/packages/runner/src/robotcode/runner/cli/testdoc.py b/packages/runner/src/robotcode/runner/cli/testdoc.py
