diff --git a/.editorconfig b/.editorconfig
index af2ccf4ca2..edbe1710e8 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -27,3 +27,7 @@ function_next_line = false
 
 [libs/**]
 ignore = true
+
+[*.py]
+# This is the widest that is still PEP-8 compliant
+max_line_length = 99
diff --git a/.github/autobuild/get_build_vars.py b/.github/autobuild/get_build_vars.py
index f1dc6d2c83..7987d71b2b 100755
--- a/.github/autobuild/get_build_vars.py
+++ b/.github/autobuild/get_build_vars.py
@@ -1,9 +1,11 @@
 #!/usr/bin/env python3
-# This script is trigged from the Github Autobuild workflow.
-# It analyzes Jamulus.pro and git push details (tag vs. branch, etc.) to decide
-#   - whether a release should be created,
-#   - whether it is a pre-release, and
-#   - what its title should be.
+"""
+This script is triggered from the GitHub Autobuild workflow.
+It analyzes Jamulus.pro and git push details (tag vs. branch, etc.) to decide
+  - whether a release should be created,
+  - whether it is a pre-release, and
+  - what its title should be.
+"""
 
 import os
 import re
@@ -15,10 +17,10 @@
 def get_version_from_jamulus_pro():
     with open(REPO_PATH + '/Jamulus.pro', 'r') as f:
         pro_content = f.read()
-    m = re.search(r'^VERSION\s*=\s*(\S+)$', pro_content, re.MULTILINE)
-    if not m:
-        raise Exception("Unable to determine Jamulus.pro VERSION")
-    return m.group(1)
+    matches = re.search(r'^VERSION\s*=\s*(\S+)$', pro_content, re.MULTILINE)
+    if not matches:
+        raise ValueError("Unable to determine Jamulus.pro VERSION")
+    return matches.group(1)
 
 
 def get_git_hash():
@@ -34,7 +36,7 @@ def get_git_hash():
 
 def get_build_version(jamulus_pro_version):
     if "dev" in jamulus_pro_version:
-        version = "{}-{}".format(jamulus_pro_version, get_git_hash())
+        version = f"{jamulus_pro_version}-{get_git_hash()}"
         return 'intermediate', version
 
     version = jamulus_pro_version
@@ -42,9 +44,9 @@ def get_build_version(jamulus_pro_version):
 
 
 def set_github_variable(varname, varval):
-    print("{}='{}'".format(varname, varval))  # console output
-    outputfile = os.getenv('GITHUB_OUTPUT')
-    with open(outputfile, "a") as ghout:
+    print(f"{varname}='{varval}'")  # console output
+    output_file = os.getenv('GITHUB_OUTPUT')
+    with open(output_file, "a") as ghout:
         ghout.write(f"{varname}={varval}\n")
 
 jamulus_pro_version = get_version_from_jamulus_pro()
@@ -52,8 +54,8 @@ def set_github_variable(varname, varval):
 build_type, build_version = get_build_version(jamulus_pro_version)
 print(f'building a version of type "{build_type}": {build_version}')
 
-fullref = os.environ['GITHUB_REF']
-publish_to_release = bool(re.match(r'^refs/tags/r\d+_\d+_\d+\S*$', fullref))
+full_ref = os.environ['GITHUB_REF']
+publish_to_release = bool(re.match(r'^refs/tags/r\d+_\d+_\d+\S*$', full_ref))
 
 # BUILD_VERSION is required for all builds including branch pushes
 # and PRs:
@@ -65,12 +67,12 @@ def set_github_variable(varname, varval):
 set_github_variable("PUBLISH_TO_RELEASE", str(publish_to_release).lower())
 
 if publish_to_release:
-    reflist = fullref.split("/", 2)
-    release_tag = reflist[2]
+    ref_list = full_ref.split("/", 2)
+    release_tag = ref_list[2]
     release_title = f"Release {build_version}  ({release_tag})"
     is_prerelease = not re.match(r'^r\d+_\d+_\d+$', release_tag)
     if not is_prerelease and build_version != release_tag[1:].replace('_', '.'):
-        raise Exception(f"non-pre-release tag {release_tag} doesn't match Jamulus.pro VERSION = {build_version}")
+        raise ValueError(f"non-pre-release tag {release_tag} doesn't match Jamulus.pro VERSION = {build_version}")
 
     # Those variables are only used when a release is created at all:
     set_github_variable("IS_PRERELEASE", str(is_prerelease).lower())
diff --git a/.github/workflows/coding-style-check.yml b/.github/workflows/coding-style-check.yml
index 5573599cdf..29c81771c5 100644
--- a/.github/workflows/coding-style-check.yml
+++ b/.github/workflows/coding-style-check.yml
@@ -9,6 +9,7 @@ on:
       - '**.h'
       - '**.mm'
       - '**.sh'
+      - '**.py'
   pull_request:
     branches: [ main ]
     paths:
@@ -16,13 +17,14 @@ on:
       - '**.h'
       - '**.mm'
       - '**.sh'
+      - '**.py'
 
 permissions:
   contents: read
 
 jobs:
-  check-coding-style:
-    name: Verify coding style
+  check-c-like-style:
+    name: Verify C-like coding style
     # As this action runs with minimal permissions and does not influence the build output,
     # we perform no version pinning for the runner or the installed tools here.
     # The clangFormatVersion is based on Ubuntu current LTS (jammy at time of writing).
@@ -36,10 +38,26 @@ jobs:
         # When updating the extension list, remember to update
         # Jamulus.pro's CLANG_SOURCES as well and the paths: in 'on:' list above.
         extensions: 'cpp,h,mm'
+
+  check-bash-style:
+    name: Verify shell script (Bash) coding style
+    runs-on: ubuntu-latest
     # shellcheck is already pre-installed on ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
     - name: Check .sh with shellcheck
       run: find -name '*.sh' -not -path './libs/*' -exec shellcheck --shell=bash {} +
     - name: Install shfmt
       run: sudo snap install shfmt
     - name: Check .sh with shfmt
       run: shfmt -d .
+
+  check-python-style:
+    name: Verify Python coding style
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Install pylint
+      run: pip install --user "pylint < 3.0"
+    - name: Check Python files with pylint
+      run: find ./tools -name '*.py' -print -exec pylint {} +
diff --git a/.pylintrc b/.pylintrc
new file mode 100644
index 0000000000..a26aa7d8a9
--- /dev/null
+++ b/.pylintrc
@@ -0,0 +1,39 @@
+[MAIN]
+
+# Specify a score threshold under which the program will exit with error.
+fail-under=10
+
+[BASIC]
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=100
+
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=s, f, i, j, k, e, _
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=yes
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+# See .editorconfig
+max-line-length=99
+
+disable=
+        # Disable enforcing constants as ALL_CAPS -
+        # pylint produces too many false positives here
+        C0103,
+        # Allow redefining names from outer scope
+        W0621,
+        # Assume utf-8 everywhere
+        W1514,
+        # Allow classes with any number of public methods
+        R0903,
+        # Allow TODOs in code
+        W0511
+
+output-format=colorized
+
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6855c3be7a..dff34e60b8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -20,6 +20,7 @@ If a feature or function can be accomplished in another way by another system or
 
 ### Source code consistency
 
+#### C-like languages
 Please install and run `clang-format` on your PC **before committing** to maintain a consistent coding style. You should use the version we use to validate the style in our CI [(see our coding-style-check file and look for the `clangFormatVersion`)](https://github.com/jamulussoftware/jamulus/blob/main/.github/workflows/coding-style-check.yml#L20). Our CI will fail and tell you about styling violations.
 
 There are several ways to run clang-format:
@@ -30,7 +31,7 @@ There are several ways to run clang-format:
 
 - By hand: run `clang-format -i <path/to/changed/files>`
 
-#### Style definition
+##### Style definition
 
 Please see the [.clang_format file](https://github.com/jamulussoftware/jamulus/blob/main/.clang-format) in the root folder. In summary:
 
@@ -40,6 +41,12 @@ Please see the [.clang_format file](https://github.com/jamulussoftware/jamulus/b
 - Enclose all bodies of `if`, `else`, `while`, `for`, etc. in braces `{` and `}` on separate lines.
 - Do not use concatinations in strings with parameters. Instead use substitutions. **Do:** `QString ( tr ( "Hello, %1. Have a nice day!" ) ).arg( getName() )` **Don't:** `tr ( "Hello " ) + getName() + tr ( ". Have a nice day!" )` ...to make translation easier.
 
+#### Python
+Please install and use [pylint](https://pylint.org/) to scan any Python code.
+There is a configuration file that defines some overrides,
+and note the [Editorconfig file](.editorconfig) in the project too.
+
+
 ### Supported platforms
 
 We support the following platforms and versions:
diff --git a/Jamulus.pro b/Jamulus.pro
index 3fd9ce3f3e..0b2fb55cb5 100644
--- a/Jamulus.pro
+++ b/Jamulus.pro
@@ -1067,7 +1067,7 @@ DISTFILES += ChangeLog \
     tools/create-translation-issues.sh \
     tools/generate_json_rpc_docs.py \
     tools/get_release_contributors.py \
-    tools/qt5-to-qt6-country-code-table.py \
+    tools/qt5_to_qt6_country_code_table.py \
     tools/update-copyright-notices.sh \
     windows/deploy_windows.ps1 \
     windows/installer.nsi
diff --git a/src/util.h b/src/util.h
index 19c972094b..0c3fbb5071 100644
--- a/src/util.h
+++ b/src/util.h
@@ -834,7 +834,7 @@ class CLocale
     static bool                    IsCountryCodeSupported ( unsigned short iCountryCode );
     static QLocale::Country        GetCountryCodeByTwoLetterCode ( QString sTwoLetterCode );
 #if QT_VERSION >= QT_VERSION_CHECK( 6, 0, 0 )
-    // ./tools/qt5-to-qt6-country-code-table.py generates these lists:
+    // ./tools/qt5_to_qt6_country_code_table.py generates these lists:
     constexpr int const static wireFormatToQt6Table[] = {
         0,   1,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,
         29,  30,  31,  32,  33,  35,  36,  37,  38,  39,  40,  41,  43,  45,  46,  48,  49,  50,  51,  53,  54,  55,  57,  56,  58,  59,  118,
diff --git a/tools/generate_json_rpc_docs.py b/tools/generate_json_rpc_docs.py
index 852414636e..42ea437a62 100755
--- a/tools/generate_json_rpc_docs.py
+++ b/tools/generate_json_rpc_docs.py
@@ -36,13 +36,14 @@ class DocumentationItem:
     def __init__(self, name, type_):
         """
         @param name: str
-        @param type: str
+        @param type_: str
         """
         self.name = name
         self.type = type_
         self.brief = DocumentationText()
         self.params = []
         self.results = []
+        self.current_tag = None
 
     def handle_tag(self, tag_name):
         """
@@ -57,7 +58,7 @@ def handle_tag(self, tag_name):
             self.current_tag = DocumentationText()
             self.results.append(self.current_tag)
         else:
-            raise Exception("Unknown tag: " + tag_name)
+            raise ValueError("Unknown tag: " + tag_name)
 
     def handle_text(self, text):
         """
@@ -75,11 +76,7 @@ def to_markdown(self):
         """
         @return: Markdown-formatted str with name, brief, params and results
         """
-        output = []
-        output.append("### " + self.name)
-        output.append("")
-        output.append(str(self.brief))
-        output.append("")
+        output = ["### " + self.name, "", str(self.brief), ""]
 
         if len(self.params) > 0:
             output.append("Parameters:")
@@ -133,10 +130,8 @@ def to_markdown(self):
         """
         @return: str containing the Markdown table
         """
-        output = []
-        output.append("| Name | Type | Description |")
-        output.append("| --- | --- | --- |")
-        tag_re = re.compile(r"^\{(\w+)\}\s+([\S]+)\s+-\s+(.*)$", re.DOTALL)
+        output = ["| Name | Type | Description |", "| --- | --- | --- |"]
+        tag_re = re.compile(r"^{(\w+)}\s+(\S+)\s+-\s+(.*)$", re.DOTALL)
         for tag in self.tags:
             text = str(tag)
             # Parse tag in form of "{type} name - description"
@@ -185,7 +180,7 @@ def to_markdown(self):
 
 items.sort(key=lambda item: item.name)
 
-preamble = """
+PREAMBLE = """
 # Jamulus JSON-RPC Documentation
 
 <!--
@@ -251,7 +246,7 @@ def to_markdown(self):
 
 docs_path = os.path.join(repo_root, 'docs', 'JSON-RPC.md')
 with open(docs_path, "w") as f:
-    f.write(preamble)
+    f.write(PREAMBLE)
 
     f.write("## Method reference\n")
     for item in filter(lambda item: item.type == "method", items):
diff --git a/tools/get_release_contributors.py b/tools/get_release_contributors.py
index fed51479d9..8989a00974 100755
--- a/tools/get_release_contributors.py
+++ b/tools/get_release_contributors.py
@@ -1,27 +1,32 @@
 #!/usr/bin/env python3
 """
-Generates a list of Github user names who contributed to a specific release.
+Generates a list of GitHub usernames who contributed to a specific release.
 
-May need a Github Personal access token to avoid hitting rate limits.
+May need a GitHub Personal access token to avoid hitting rate limits.
 
 Usage:
 
 ## Website repo (jamulussoftware/jamuluswebsite)
 - cd jamuluswebsite
-- git log --oneline release # Find commit ID of previous version. Search for "RELEASE:"
-- /path/to/jamulussoftware/code/tools/get_release_contributors.py --from COMMIT_ID_FROM_PREVIOUS_STEP --to next-release --github-token YOUR_TOKEN --repo .
+# Find commit ID of previous version. Search for "RELEASE:"
+- git log --oneline release
+- /path/to/jamulussoftware/code/tools/get_release_contributors.py \
+    --from COMMIT_ID_FROM_PREVIOUS_STEP --to next-release \
+    --github-token YOUR_TOKEN --repo .
 
 ## Code repo (jamulussoftware/jamulus)
 - git pull -C /path/
-- ./tools/get_release_contributors.py --from r3_8_1 --to r3_8_2 --github-token YOUR_TOKEN --repo .
+- ./tools/get_release_contributors.py --from r3_8_1 --to r3_8_2 \
+    --github-token YOUR_TOKEN --repo .
 
 """
-import requests
 import argparse
 import logging
 import os
 import re
 import subprocess
+
+import requests
 import yaml
 
 logger = logging.getLogger('')
@@ -31,26 +36,28 @@ class UnexpectedGithubStatus(RuntimeError):
     """
     Exception which is raised when an API request fails.
     """
-    pass
 
 
 # List of contributor names which should be ignored (such as bots):
-ignore_list = ['@github-actions[bot]', '@imgbot[bot]', '@actions-bot', '@actions-user', '@ImgBotApp', '@dependabot[bot]', '@weblate']
+ignore_list = ['@github-actions[bot]', '@imgbot[bot]', '@actions-bot',
+               '@actions-user', '@ImgBotApp', '@dependabot[bot]', '@weblate']
 
 CHARSET = 'utf-8'
 
 
 class Authors:
     """
-    The Authors class provides methods to get the Github login of each
+    The Authors class provides methods to get the GitHub login of each
     commit in an efficient fashion.
-    It uses the Github API and caches name+email-to-login associations
+    It uses the GitHub API and caches name+email-to-login associations
     to avoid excessive API usage.
     """
 
     def __init__(self, path):
         self.keys_to_user = {}
         self.path = path
+        self.repo = None
+        self.token = None
         try:
             self.load()
         except FileNotFoundError:
@@ -64,9 +71,9 @@ def set_github_token(self, token):
 
     def _get_login(self, key, commit_hash):
         """
-        Returns the Github login associated with the given name+email key.
+        Returns the GitHub login associated with the given name+email key.
         A related commit hash is required in order to have a reference
-        to use in the Github API request.
+        to use in the GitHub API request.
 
         Once looked up, the results are cached in a local file.
         """
@@ -89,37 +96,36 @@ def get_login_or_realname(self, key, commit_hash):
         login = self._get_login(key, commit_hash)
         if login:
             return f'@{login}'
-        m = re.match('\A([^@<>]+) <.*>\Z', key)
-        if m:
-            return m.group(1)
-        logger.warning(f'unable to extract github login or real name from {repr(key)}')
+        matches = re.match(r'\A([^@<>]+) <.*>\Z', key)
+        if matches:
+            return matches.group(1)
+        logger.warning("unable to extract GitHub login or real name from %r", key)
         return None
 
-    def get_user_by_commit(self, hash):
+    def get_user_by_commit(self, sha):
         """
-        Retrieves the associated Github user name for the given commit
-        hash.
+        Retrieves the associated GitHub username for the given commit hash.
         """
-        r = self._github_api_get(f'repos/jamulussoftware/{self.repo}/commits/{hash}')
-        if 200 <= r.status_code < 300:
+        resp = self._github_api_get(f'repos/jamulussoftware/{self.repo}/commits/{sha}')
+        if 200 <= resp.status_code < 300:
             try:
-                return r.json()['author']['login']
+                return resp.json()['author']['login']
             except (TypeError, KeyError):
-                logger.warning('%s has not github author, saving as empty', hash)
+                logger.warning('%s has not GitHub author, saving as empty', sha)
                 return ''
-        if r.status_code == 422:
-            logger.warning('unable to find author of %s, saving as empty', hash)
+        if resp.status_code == 422:
+            logger.warning('unable to find author of %s, saving as empty', sha)
             return ''
-        raise UnexpectedGithubStatus('status was %d' % r.status_code)
+        raise UnexpectedGithubStatus(f"status was {resp.status_code}")
 
     def _github_api_get(self, path, *args, **kwargs):
         headers = {
             'Accept': 'application/vnd.github.v3+json',
         }
         if self.token:
-            headers['Authorization'] = 'token %s' % self.token
-        r = requests.get(f'https://api.github.com/{path}', *args, headers=headers, **kwargs)
-        return r
+            headers['Authorization'] = f"token {self.token}"
+        return requests.get(f'https://api.github.com/{path}', *args, headers=headers, **kwargs,
+                            timeout=10)
 
     def get_user_by_email(self, key):
         m = re.match(r'\A[^<]+<([^<> ]+@[^<> ]+)>\Z', key)
@@ -127,21 +133,21 @@ def get_user_by_email(self, key):
             return None
         email = m.group(1)
         # Handle Github-generated email addresses via static matching:
-        m = re.match(r'\A(\d+\+)?([^+@]+)\@users\.noreply\.github\.com\Z', email)
+        m = re.match(r'\A(\d+\+)?([^+@]+)@users\.noreply\.github\.com\Z', email)
         if m:
             return m.group(2)
-        r = self._github_api_get('search/users', params={'q': f'{email} in:email'})
-        if r.status_code < 200 or r.status_code >= 300:
-            logger.warning(f'search/users for {email} failed with code {r.status_code}')
+        resp = self._github_api_get('search/users', params={'q': f'{email} in:email'})
+        if resp.status_code < 200 or resp.status_code >= 300:
+            logger.warning('search/users for %s failed with code %s', email, resp.status_code)
             return None
-        items = r.json().get('items', [])
+        items = resp.json().get('items', [])
         for item in items:
             login = item['login']
             u = self._github_api_get(f'users/{login}').json()
             if u.get('email', '') == email:
                 return login
 
-        logger.warning(f'unable to find a github profile with public email {email}')
+        logger.warning('unable to find a github profile with public email %s', email)
         return None
 
     def save(self):
@@ -193,38 +199,43 @@ def print_website_contributors(from_, to):
 
 
 def print_contributors(title, git_log_selector, from_, to):
-    contributors = [u for u in find_contributors(git_log_selector, from_, to) if u and u not in ignore_list]
+    contributors = [u for u in find_contributors(git_log_selector, from_, to) if
+                    u and u not in ignore_list]
     contributors_str = ', '.join(contributors)
-    print('%s: %s' % (title, contributors_str))
+    print(f'{title}: {contributors_str}')
 
 
-def find_contributors(git_log_selector, from_, to):
+def find_contributors(git_log_selector, from_ref, to_ref):
     """
     Uses `git log` with the provided git_log_selector to list all commits
-    starting with git reference `from_` and going until reference `to`.
+    starting with git reference `from_ref` and going until reference `to_ref`.
 
     A `git_log_selector` could just be a path such as '.'.
     `from_` and `to` can be any committish such as a commit hash or a tag.
     """
     contributors = set()
     co_author_keys = set()
-    commits = subprocess.check_output(['git', 'log', '-z', '--show-pulls', '--format=format:%H %an <%ae>%n%b', '%s..%s' % (from_, to), '--'] + git_log_selector)
+    commits = subprocess.check_output(
+        ['git', 'log', '-z', '--show-pulls', '--format=format:%H %an <%ae>%n%b',
+         f'{from_ref}..{to_ref}', '--'] + git_log_selector)
     commits = commits.decode(CHARSET)
     for commit in commits.split('\0'):
         if not commit:
             continue
-        hash, author_key = commit.split('\n', 1)[0].split(' ', 1)
-        contributor = authors.get_login_or_realname(author_key, hash)
+        sha, author_key = commit.split('\n', 1)[0].split(' ', 1)
+        contributor = authors.get_login_or_realname(author_key, sha)
         contributors.add(contributor)
-        co_authors = re.findall('Co-authored-by:\s*(\S.*(<[^ >]+>))\s*(?:$|\n)', commit, re.I)
+        co_authors = re.findall(r'Co-authored-by:\s*(\S.*(<[^ >]+>))\s*(?:$|\n)', commit, re.I)
         for co_author_full, co_author_email in co_authors:
-            logger.debug(f'checking co author {co_author_full}')
+            logger.debug('checking co author %s', co_author_full)
             contributor = authors.get_login_or_realname(co_author_full, None)
             if not contributor or not contributor.startswith('@'):
                 # try to find a previous commit by this mail address
                 # and pass this commit id to get_login_or_realname() to retrieve the
-                # associated handle from the github API.
-                commit = subprocess.check_output(['git', 'log', '--format=%H', '--max-count=1', '--author=%s' % re.escape(co_author_email)]).strip().decode(CHARSET)
+                # associated handle from the GitHub API.
+                esc_email = re.escape(co_author_email)
+                commit = subprocess.check_output(['git', 'log', '--format=%H', '--max-count=1',
+                                                  f'--author={esc_email}']).strip().decode(CHARSET)
                 if commit:
                     contributor = authors.get_login_or_realname(co_author_full, commit)
             if contributor:
@@ -237,7 +248,8 @@ def find_contributors(git_log_selector, from_, to):
         if contributor:
             contributors.add(contributor)
         else:
-            contributors.add(realname)
+            # TODO: check this is the right logic...
+            contributors.add(co_author)
     return sorted(contributors, key=str.casefold)
 
 
@@ -245,13 +257,16 @@ def find_contributors(git_log_selector, from_, to):
     p = argparse.ArgumentParser(
         description='Generates a list of Github user names who contributed to a specific release.')
     p.add_argument('--from', dest='from_', required=True,
-                   help='the first git hash or tag to include in the analysis, e.g. the tag of the previous release')
+                   help='the first git hash or tag to include in the analysis, '
+                        'e.g. the tag of the previous release')
     p.add_argument('--to', required=True,
-                   help='the last git hash or tag to include in the analysis, e.g. the (rc) tag of the target release')
+                   help='the last git hash or tag to include in the analysis, '
+                        'e.g. the (rc) tag of the target release')
     p.add_argument('--repo', required=True,
                    help='the path to the git repository to be analyzed, e.g. ./jamuluswebsite')
     p.add_argument('--github-token',
-                   help='a Github Personal Access Token; optional, but might be needed if we exceed the anonymous API requests per hour limit')
+                   help='a Github Personal Access Token; optional, but might be needed '
+                        'if we exceed the anonymous API requests per hour limit')
     p.add_argument('--verbose', '-v', action='store_true',
                    help='enable verbose output')
     p.add_argument('--quiet', '-q', action='store_true',
diff --git a/tools/qt5-to-qt6-country-code-table.py b/tools/qt5_to_qt6_country_code_table.py
similarity index 72%
rename from tools/qt5-to-qt6-country-code-table.py
rename to tools/qt5_to_qt6_country_code_table.py
index 4d54bf9a01..f82169ce73 100755
--- a/tools/qt5-to-qt6-country-code-table.py
+++ b/tools/qt5_to_qt6_country_code_table.py
@@ -10,8 +10,8 @@
 import re
 
 # verify that the following actually points to Qt5 on your system!
-qt5_include = '/usr/include/qt/QtCore/qlocale.h'
-qt6_include = '/usr/include/qt6/QtCore/qlocale.h'
+QT5_INCLUDE = '/usr/include/qt/QtCore/qlocale.h'
+QT6_INCLUDE = '/usr/include/qt6/QtCore/qlocale.h'
 
 
 def parse_enum_from_header(header):
@@ -19,7 +19,7 @@ def parse_enum_from_header(header):
     val_to_name = {}
     with open(header) as f:
         s = f.read()
-    matches = re.search(r'enum Country[^\n]+\{([^}]+)\}', s)
+    matches = re.search(r'enum Country[^\n]+{([^}]+)}', s)
     assignments = matches.group(1)
 
     assign_pattern = re.compile(r'^\s*(\S+)(?:\s+.*)?\s+=\s+([^\s,]+),?$')
@@ -28,7 +28,7 @@ def parse_enum_from_header(header):
             continue
         matches = assign_pattern.match(assignment)
         if not matches:
-            raise Exception("unable to match line: %r" % assignment)
+            raise ValueError(f"unable to match line: {assignment!r}")
         name = matches.group(1)
         val = matches.group(2)
         if val.isnumeric():
@@ -40,23 +40,24 @@ def parse_enum_from_header(header):
             # resolve aliases:
             name_to_val[name] = name_to_val[val]
         else:
-            raise("Unhandled case")
+            raise ValueError("Unhandled case")
     return name_to_val, val_to_name
 
 
 def make_struct(name, table):
     ret = ''
-    highest_key = max([int(x) for x in table.keys()])
-    ret += 'constexpr int const static %s[] = {' % (name,)
-    for key in range(highest_key+1):
-        ret += '%d' % table.get(key, -1)  # fill gaps with -1
+    highest_key = max(int(x) for x in table.keys())
+    # Need to escape the literal '{' by using '{{'
+    ret += f'constexpr int const static {name}[] = {{'
+    for key in range(highest_key + 1):
+        ret += str(table.get(key, -1))  # fill gaps with -1
         ret += ', '
     ret += '};'
     return ret
 
 
-qt5_name_to_val, qt5_val_to_name = parse_enum_from_header(qt5_include)
-qt6_name_to_val, qt6_val_to_name = parse_enum_from_header(qt6_include)
+qt5_name_to_val, qt5_val_to_name = parse_enum_from_header(QT5_INCLUDE)
+qt6_name_to_val, qt6_val_to_name = parse_enum_from_header(QT6_INCLUDE)
 
 qt5_to_qt6 = {}
 qt6_to_qt5 = {}