refactor: change logger calls with an f-string to use lambdas

Author: d-biehl

.pre-commit-config.yaml

@@ -5,29 +5,22 @@ default_stages: [commit, push]
 repos:
   - repo: local
     hooks:
-      - id: system
-        name: Black
-        entry: hatch -e devel.py38-rf41 run black --check --diff .
+      - id: python_style
+        name: Check Python Style
+        entry: hatch run lint:style
         pass_filenames: false
         language: system
   - repo: local
     hooks:
-      - id: system
-        name: Ruff
-        entry: hatch -e devel.py38-rf41 run ruff check .
+      - id: python_typing
+        name: Check Python Typing
+        entry: hatch run lint:typing
         pass_filenames: false
         language: system
   - repo: local
     hooks:
-      - id: system
-        name: MyPy
-        entry: hatch -e devel.py38-rf41 run mypy .
-        pass_filenames: false
-        language: system
-  - repo: local
-    hooks:
-      - id: system
-        name: eslint
+      - id: eslint
+        name: Check JavaScript Style and Typing
         entry: npm run lint
         pass_filenames: false
         language: system

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling>=1.12.2", "hatch-vcs"]
+requires = ["hatchling>=1.12.2"]
 build-backend = "hatchling.build"
 
 
@@ -67,15 +67,11 @@ rest = ["docutils", "types-docutils"]
 'robotcode.debugger' = 'robotcode.debugger.__main__:main'
 'robotcode.language_server' = 'robotcode.language_server.__main__:main'
 
+
 [tool.hatch.version]
-source = "vcs"
+path = "robotcode/__version__.py"
 
 
-[tool.hatch.build.hooks.vcs]
-version-file = "robotcode/__version__.py"
-template = '''
-__version__ = "{version}"
-'''
 [tool.hatch.build.targets.sdist]
 only-include = ["robotcode", "CHANGELOG.md"]
 
@@ -87,7 +83,6 @@ dependencies = [
   "pytest_asyncio",
   "pytest-regtest>=1.5.0",
   "pytest-cov",
-  "isort",
   "mypy",
   "ruff",
   "black",
@@ -150,6 +145,31 @@ matrix.rf.dependencies = [
   ] },
 ]
 
+[tool.hatch.envs.lint]
+detached = true
+dependencies = [
+  "pytest",
+  "pytest_asyncio",
+  "pytest-regtest>=1.5.0",
+  "mypy",
+  "ruff",
+  "black",
+  "debugpy",
+  "robotremoteserver",
+  "PyYAML>=5.4",
+  "types-PyYAML>=5.4",
+  "robotframework-robocop>=2.0.0",
+  "robotframework-tidy>=2.0.0",
+  "docutils",
+  "types-docutils",
+]
+
+[tool.hatch.envs.lint.scripts]
+typing = "mypy --install-types --non-interactive {args:.}"
+style = ["ruff {args:.}", "black --check --diff {args:.}"]
+fmt = ["black {args:.}", "ruff --fix {args:.}", "style"]
+all = ["style", "typing"]
+
 [tool.semantic_release]
 version_variable = ["robotcode/__version__.py:__version__"]
 version_pattern = ['package.json:"version": "{version}"']
@@ -189,12 +209,6 @@ junit_suite_name = "robotcode"
 # log_cli_format = "%(levelname)s %(name)s: %(message)s"
 asyncio_mode = "auto"
 
-[tool.isort]
-profile = "black"
-src_paths = ["robotcode", "tests"]
-skip_gitignore = true
-skip = ['external', '.venv', ".hatch"]
-
 
 [tool.coverage.run]
 omit = ["*tests*"]
@@ -241,7 +255,20 @@ select = [
   "F",
   "W",
   "I",
-  "N"
+  "N",
+  #"UP",
+  "YTT",
+  #"ANN",
+  #"BLE",
+  #"B",
+  #"A"
+  #"COM"
+  #"C4", TODO enable this
+  "DTZ",
+  "T10",
+  # "EM",
+  "ISC",
+  "G",
 ]
 
 

robotcode/debugger/__main__.py

@@ -109,7 +109,7 @@ async def start_debugpy_async(
 
     port = find_free_port(debugpy_port)
     if port != debugpy_port:
-        _logger.warning(f"start debugpy session on port {port}")
+        _logger.warning(lambda: f"start debugpy session on port {port}")
 
     if enable_debugpy(port, addresses):
         global config_done_callback
@@ -396,8 +396,8 @@ def main() -> None:
                 logging.getLogger("robotcode.jsonrpc2").propagate = True
                 logging.getLogger("robotcode.jsonrpc2").setLevel(logging.CRITICAL)
 
-    _logger.info(f"starting {__package__} version={__version__}")
-    _logger.debug(f"args={args}")
+    _logger.info(lambda: f"starting {__package__} version={__version__}")
+    _logger.debug(lambda: f"args={args}")
 
     asyncio.run(
         run_robot(

robotcode/debugger/debugger.py

@@ -159,7 +159,7 @@ def __init__(
     def __repr__(self) -> str:
         return (
             f"StackFrameEntry({repr(self.name)}, {repr(self.type)}, "
-            + f"{repr(self.source)}, {repr(self.line)}, {repr(self.column)})"
+            f"{repr(self.source)}, {repr(self.line)}, {repr(self.column)})"
         )
 
     def get_first_or_self(self) -> StackFrameEntry:

robotcode/debugger/launcher/__main__.py

@@ -135,8 +135,8 @@ def main() -> None:
                 logging.getLogger("robotcode.debugger.launcher").setLevel(logging.CRITICAL)
                 logging.getLogger("robotcode.jsonrpc2").setLevel(logging.CRITICAL)
 
-    _logger.info(f"starting debugger launcher server version={__version__}")
-    _logger.debug(f"args={args}")
+    _logger.info(lambda: f"starting debugger launcher server version={__version__}")
+    _logger.debug(lambda: f"args={args}")
     if args.debugpy:
         start_debugpy(args.debugpy_port, args.debugpy_wait_for_client)
 

robotcode/debugger/listeners.py

@@ -200,7 +200,7 @@ def enqueue(item: Union[TestSuite, TestCase]) -> Iterator[str]:
         if self._event_sended:
             return
 
-        items = list(reversed([i for i in enqueue(cast(TestSuite, data))]))
+        items = list(reversed(list(enqueue(cast(TestSuite, data)))))
 
         Debugger.instance().send_event(
             self,

robotcode/debugger/protocol.py

@@ -248,7 +248,7 @@ def done(t: asyncio.Task[Any]) -> None:
             try:
                 self.send_response(message.seq, message.command, t.result())
             except asyncio.CancelledError:
-                self._logger.debug(f"request message {repr(message)} canceled")
+                self._logger.debug(lambda: f"request message {repr(message)} canceled")
             except (SystemExit, KeyboardInterrupt):
                 raise
             except DebugAdapterRPCErrorException as ex:

robotcode/jsonrpc2/protocol.py

@@ -389,10 +389,10 @@ def eof_received(self) -> Optional[bool]:
 
     MESSAGE_PATTERN: Final = re.compile(
         rb"(?:[^\r\n]*\r\n)*"
-        + rb"(Content-Length: ?(?P<length>\d+)\r\n)"
-        + rb"((Content-Type: ?(?P<content_type>[^\r\n;]+)"
-        + rb"(; *(charset=(?P<charset>[^\r\n]+))?)?\r\n)|(?:[^\r\n]+\r\n))*"
-        + rb"\r\n(?P<body>.*)",
+        rb"(Content-Length: ?(?P<length>\d+)\r\n)"
+        rb"((Content-Type: ?(?P<content_type>[^\r\n;]+)"
+        rb"(; *(charset=(?P<charset>[^\r\n]+))?)?\r\n)|(?:[^\r\n]+\r\n))*"
+        rb"\r\n(?P<body>.*)",
         re.DOTALL,
     )
 
@@ -620,7 +620,7 @@ def set_result(f: asyncio.Future[Any], r: Any, ev: threading.Event) -> None:
                             await asyncio.sleep(0)
 
                     else:
-                        self._logger.warning(f"Response {repr(entry)} loop is not running.")
+                        self._logger.warning(lambda: f"Response {repr(entry)} loop is not running.")
 
         except (SystemExit, KeyboardInterrupt):
             raise
@@ -728,7 +728,7 @@ def done(t: asyncio.Future[Any]) -> None:
 
                 self.send_response(message.id, t.result())
             except asyncio.CancelledError:
-                self._logger.debug(f"request message {repr(message)} canceled")
+                self._logger.debug(lambda: f"request message {repr(message)} canceled")
                 self.send_error(JsonRPCErrors.REQUEST_CANCELLED, "Request canceled.", id=message.id)
             except (SystemExit, KeyboardInterrupt):
                 raise
@@ -751,7 +751,7 @@ def cancel_request(self, id: Union[int, str, None]) -> None:
             entry = self._received_request.get(id, None)
 
         if entry is not None and entry.future is not None and not entry.future.cancelled():
-            self._logger.debug(f"try to cancel request {entry.request}")
+            self._logger.debug(lambda: f"try to cancel request {entry.request if entry is not None else ''}")
             entry.future.cancel()
 
     @_logger.call
@@ -765,7 +765,7 @@ async def handle_notification(self, message: JsonRPCNotification) -> None:
         e = self.registry.get_entry(message.method)
 
         if e is None or not callable(e.method):
-            self._logger.warning(f"Unknown method: {message.method}")
+            self._logger.warning(lambda: f"Unknown method: {message.method}")
             return
         try:
             params = self._convert_params(e.method, e.param_type, message.params)

robotcode/language_server/__main__.py

@@ -184,8 +184,8 @@ def main() -> None:
         else:
             init_logging(args)
 
-    _logger.info(f"starting language server version={__version__}")
-    _logger.debug(f"args={args}")
+    _logger.info(lambda: f"starting language server version={__version__}")
+    _logger.debug(lambda: f"args={args}")
 
     if args.debugpy:
         start_debugpy(args.debugpy_port, args.debugpy_wait_for_client)

robotcode/language_server/common/parts/code_action.py

@@ -46,16 +46,15 @@ async def resolve(sender, code_action: CodeAction) -> Optional[CodeAction]:  # N
 
     def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
         if len(self.collect):
-            code_action_kinds = [
-                k
-                for k in chain(
+            code_action_kinds = list(
+                chain(
                     *[
                         cast(HasCodeActionKinds, e).__code_action_kinds__
                         for e in self.collect
                         if isinstance(e, HasCodeActionKinds)
                     ]
                 )
-            ]
+            )
 
             capabilities.code_action_provider = CodeActionOptions(
                 code_action_kinds=code_action_kinds if code_action_kinds else None,