Code formatting.

This is a huge commit containing following changes:

- Code formatting with Black. This includes changing quote styles from
  single quotes to double quotes.

- Linting with Ruff and fixing found issues.

- Import sorting and cleanup with Ruff.

- Reorganization of multiline imports with isort. Imports that are
  part of public APIs are excluded.

- Manual inspection of all changes. Includes refactoring to make
  formatting better and some usages of `# fmt: skip`.

- Converting string formatting to use f-strings consistently.

- Configuration for Black, Ruff and isort in `pyproject.toml`.

- Invoke task `invoke format` for running the whole formatting
  process. This formatting is done only for `src`, `atest` and `utest`
  directories, but the task allows formatting also other files.

Author: pekkaklarck

atest/genrunner.py

@@ -5,20 +5,20 @@
 Usage:  {tool} testdata/path/data.robot [robot/path/runner.robot]
 """
 
-from os.path import abspath, basename, dirname, exists, join
 import os
-import sys
 import re
+import sys
+from os.path import abspath, basename, dirname, exists, join
 
-if len(sys.argv) not in [2, 3] or not all(a.endswith('.robot') for a in sys.argv[1:]):
+if len(sys.argv) not in [2, 3] or not all(a.endswith(".robot") for a in sys.argv[1:]):
     sys.exit(__doc__.format(tool=basename(sys.argv[0])))
 
-SEPARATOR = re.compile(r'\s{2,}|\t')
+SEPARATOR = re.compile(r"\s{2,}|\t")
 INPATH = abspath(sys.argv[1])
-if join('atest', 'testdata') not in INPATH:
+if join("atest", "testdata") not in INPATH:
     sys.exit("Input not under 'atest/testdata'.")
 if len(sys.argv) == 2:
-    OUTPATH = INPATH.replace(join('atest', 'testdata'), join('atest', 'robot'))
+    OUTPATH = INPATH.replace(join("atest", "testdata"), join("atest", "robot"))
 else:
     OUTPATH = sys.argv[2]
 
@@ -42,39 +42,45 @@ def __init__(self, name, tags=None):
         line = line.rstrip()
         if not line:
             continue
-        elif line.startswith('*'):
-            name = SEPARATOR.split(line)[0].replace('*', '').replace(' ', '').upper()
-            parsing_tests = name in ('TESTCASE', 'TESTCASES', 'TASK', 'TASKS')
-            parsing_settings = name in ('SETTING', 'SETTINGS')
-        elif parsing_tests and not SEPARATOR.match(line) and line[0] != '#':
-            TESTS.append(TestCase(line.split('  ')[0]))
-        elif parsing_tests and line.strip().startswith('[Tags]'):
-            TESTS[-1].tags = line.split('[Tags]', 1)[1].split()
-        elif parsing_settings and line.startswith(('Force Tags', 'Default Tags', 'Test Tags')):
-            name, value = line.split('  ', 1)
-            SETTINGS.append((name, value.strip()))
-
-
-with open(OUTPATH, 'w') as output:
-    path = INPATH.split(join('atest', 'testdata'))[1][1:].replace(os.sep, '/')
-    output.write('''\
+        elif line.startswith("*"):
+            name = SEPARATOR.split(line)[0].replace("*", "").replace(" ", "").upper()
+            parsing_tests = name in ("TESTCASES", "TASKS")
+            parsing_settings = name == "SETTINGS"
+        elif parsing_tests and not SEPARATOR.match(line) and line[0] != "#":
+            TESTS.append(TestCase(SEPARATOR.split(line)[0]))
+        elif parsing_tests and line.strip().startswith("[Tags]"):
+            TESTS[-1].tags = line.split("[Tags]", 1)[1].split()
+        elif parsing_settings and line.startswith("Test Tags"):
+            name, *values = SEPARATOR.split(line)
+            SETTINGS.append((name, values))
+
+
+with open(OUTPATH, "w") as output:
+    path = INPATH.split(join("atest", "testdata"))[1][1:].replace(os.sep, "/")
+    output.write(
+        f"""\
 *** Settings ***
-Suite Setup       Run Tests    ${EMPTY}    %s
-''' % path)
-    for name, value in SETTINGS:
-        output.write('%s%s\n' % (name.ljust(18), value))
-    output.write('''\
+Suite Setup       Run Tests    ${{EMPTY}}    {path}
+"""
+    )
+    for name, values in SETTINGS:
+        values = "    ".join(values)
+        output.write(f"{name:18}{values}\n")
+    output.write(
+        """\
 Resource          atest_resource.robot
 
 *** Test Cases ***
-''')
+"""
+    )
     for test in TESTS:
-        output.write(test.name + '\n')
+        output.write(test.name + "\n")
         if test.tags:
-            output.write('    [Tags]    %s\n' % '    '.join(test.tags))
-        output.write('    Check Test Case    ${TESTNAME}\n')
+            tags = "    ".join(test.tags)
+            output.write(f"    [Tags]    {tags}\n")
+        output.write("    Check Test Case    ${TESTNAME}\n")
         if test is not TESTS[-1]:
-            output.write('\n')
+            output.write("\n")
 
 
 print(OUTPATH)

atest/interpreter.py

@@ -4,12 +4,11 @@
 import sys
 from pathlib import Path
 
-
-ROBOT_DIR = Path(__file__).parent.parent / 'src/robot'
+ROBOT_DIR = Path(__file__).parent.parent / "src/robot"
 
 
 def get_variables(path, name=None, version=None):
-    return {'INTERPRETER': Interpreter(path, name, version)}
+    return {"INTERPRETER": Interpreter(path, name, version)}
 
 
 class Interpreter:
@@ -21,93 +20,97 @@ def __init__(self, path, name=None, version=None):
             name, version = self._get_name_and_version()
         self.name = name
         self.version = version
-        self.version_info = tuple(int(item) for item in version.split('.'))
+        self.version_info = tuple(int(item) for item in version.split("."))
 
     def _get_interpreter(self, path):
-        path = path.replace('/', os.sep)
+        path = path.replace("/", os.sep)
         return [path] if os.path.exists(path) else path.split()
 
     def _get_name_and_version(self):
         try:
-            output = subprocess.check_output(self.interpreter + ['-V'],
-                                             stderr=subprocess.STDOUT,
-                                             encoding='UTF-8')
+            output = subprocess.check_output(
+                self.interpreter + ["-V"],
+                stderr=subprocess.STDOUT,
+                encoding="UTF-8",
+            )
         except (subprocess.CalledProcessError, FileNotFoundError) as err:
-            raise ValueError(f'Failed to get interpreter version: {err}')
+            raise ValueError(f"Failed to get interpreter version: {err}")
         name, version = output.split()[:2]
-        name = name if 'PyPy' not in output else 'PyPy'
-        version = re.match(r'\d+\.\d+\.\d+', version).group()
+        name = name if "PyPy" not in output else "PyPy"
+        version = re.match(r"\d+\.\d+\.\d+", version).group()
         return name, version
 
     @property
     def os(self):
-        for condition, name in [(self.is_linux, 'Linux'),
-                                (self.is_osx, 'OS X'),
-                                (self.is_windows, 'Windows')]:
+        for condition, name in [
+            (self.is_linux, "Linux"),
+            (self.is_osx, "OS X"),
+            (self.is_windows, "Windows"),
+        ]:
             if condition:
                 return name
         return sys.platform
 
     @property
     def output_name(self):
-        return f'{self.name}-{self.version}-{self.os}'.replace(' ', '')
+        return f"{self.name}-{self.version}-{self.os}".replace(" ", "")
 
     @property
     def excludes(self):
         if self.is_pypy:
-            yield 'no-pypy'
-            yield 'require-lxml'
+            yield "no-pypy"
+            yield "require-lxml"
         for require in [(3, 9), (3, 10), (3, 14)]:
             if self.version_info < require:
-                yield 'require-py%d.%d' % require
+                yield "require-py%d.%d" % require
         if self.is_windows:
-            yield 'no-windows'
+            yield "no-windows"
         if not self.is_windows:
-            yield 'require-windows'
+            yield "require-windows"
         if self.is_osx:
-            yield 'no-osx'
+            yield "no-osx"
         if not self.is_linux:
-            yield 'require-linux'
+            yield "require-linux"
 
     @property
     def is_python(self):
-        return self.name == 'Python'
+        return self.name == "Python"
 
     @property
     def is_pypy(self):
-        return self.name == 'PyPy'
+        return self.name == "PyPy"
 
     @property
     def is_linux(self):
-        return 'linux' in sys.platform
+        return "linux" in sys.platform
 
     @property
     def is_osx(self):
-        return sys.platform == 'darwin'
+        return sys.platform == "darwin"
 
     @property
     def is_windows(self):
-        return os.name == 'nt'
+        return os.name == "nt"
 
     @property
     def runner(self):
-        return self.interpreter + [str(ROBOT_DIR / 'run.py')]
+        return self.interpreter + [str(ROBOT_DIR / "run.py")]
 
     @property
     def rebot(self):
-        return self.interpreter + [str(ROBOT_DIR / 'rebot.py')]
+        return self.interpreter + [str(ROBOT_DIR / "rebot.py")]
 
     @property
     def libdoc(self):
-        return self.interpreter + [str(ROBOT_DIR / 'libdoc.py')]
+        return self.interpreter + [str(ROBOT_DIR / "libdoc.py")]
 
     @property
     def testdoc(self):
-        return self.interpreter + [str(ROBOT_DIR / 'testdoc.py')]
+        return self.interpreter + [str(ROBOT_DIR / "testdoc.py")]
 
     @property
     def underline(self):
-        return '-' * len(str(self))
+        return "-" * len(str(self))
 
     def __str__(self):
-        return f'{self.name} {self.version} on {self.os}'
+        return f"{self.name} {self.version} on {self.os}"