Apply ruff format across the codebase.

One-time reformat to 88-character line length; no logic changes.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: holybiber

autotranslate.py

@@ -8,57 +8,76 @@
 from googletrans import Translator
 from configparser import ConfigParser
 
-TIMEOUT: int = 30           # Timeout after 30s (prevent indefinite hanging when there is network issues)
+TIMEOUT: int = (
+    30  # Timeout after 30s (prevent indefinite hanging when there is network issues)
+)
 
 
 class TranslationTool:
     def __init__(self, config: ConfigParser):
-        if not config.has_option('autotranslate', 'site') or \
-           not config.has_option('autotranslate', 'username'):
-            raise RuntimeError("Missing connection settings for autotranslate in config.ini")
+        if not config.has_option("autotranslate", "site") or not config.has_option(
+            "autotranslate", "username"
+        ):
+            raise RuntimeError(
+                "Missing connection settings for autotranslate in config.ini"
+            )
 
-        self.logger: logging.Logger = logging.getLogger('pywikitools.autotranslate')
+        self.logger: logging.Logger = logging.getLogger("pywikitools.autotranslate")
 
-        code = config.get('autotranslate', 'site')
+        code = config.get("autotranslate", "site")
         family = Family()
-        self.site = pywikibot.Site(code=code, fam=family, user=config.get('autotranslate', 'username'))
+        self.site = pywikibot.Site(
+            code=code, fam=family, user=config.get("autotranslate", "username")
+        )
         if not self.site.logged_in():
             self.site.login()
             if not self.site.logged_in():
                 raise RuntimeError("Login with pywikibot failed.")
         # Set throttle to 0 to speed up write operations (otherwise pywikibot would wait up to 10s after each write)
         self.site.throttle.set_delays(delay=0, writedelay=0, absolute=True)
-        self.fortraininglib: ForTrainingLib = ForTrainingLib(family.base_url(code, ''),
-                                                             family.scriptpath(code))
+        self.fortraininglib: ForTrainingLib = ForTrainingLib(
+            family.base_url(code, ""), family.scriptpath(code)
+        )
 
         self.language_supported_by_deepl = True
-        if not config.has_option('autotranslate', 'deeplendpoint') or \
-           not config.has_option('autotranslate', 'deeplapikey'):
+        if not config.has_option(
+            "autotranslate", "deeplendpoint"
+        ) or not config.has_option("autotranslate", "deeplapikey"):
             self.logger.warning("Missing settings for DeepL connection in config.ini")
             self.language_supported_by_deepl = False
         else:
-            self.deepl_endpoint = config.get('autotranslate', 'deeplendpoint')
-            self.deepl_api_key = config.get('autotranslate', 'deeplapikey')
+            self.deepl_endpoint = config.get("autotranslate", "deeplendpoint")
+            self.deepl_api_key = config.get("autotranslate", "deeplapikey")
 
         self.google_translator = Translator()
 
-    def fetch_and_translate(self, page_name, language_code, force=False, simulate=False):
+    def fetch_and_translate(
+        self, page_name, language_code, force=False, simulate=False
+    ):
         translated_page = self.fortraininglib.get_translation_units(page_name, "en")
 
         if (
-            not simulate and not force
-            and self.fortraininglib.get_translated_title(page_name, language_code) is not None
+            not simulate
+            and not force
+            and self.fortraininglib.get_translated_title(page_name, language_code)
+            is not None
         ):
-            self.logger.warning("Translation already exists. If you want to force overwrite, use the -f flag.")
+            self.logger.warning(
+                "Translation already exists. If you want to force overwrite, use the -f flag."
+            )
             return
 
         # Split the translation units into snippets to avoid mark-up symbols
         for translation_unit in translated_page:
-            translation_unit.split_all_tags = True  # We want that to get rid of all markup
+            translation_unit.split_all_tags = (
+                True  # We want that to get rid of all markup
+            )
             translation_unit.remove_links()
 
             for orig_snippet, trans_snippet in translation_unit:
-                trans_snippet.content = self.translate_with_deepl_or_google(orig_snippet.content, language_code)
+                trans_snippet.content = self.translate_with_deepl_or_google(
+                    orig_snippet.content, language_code
+                )
             translation_unit.sync_from_snippets()
             identifier = f"{translation_unit.identifier}/{language_code}"
             translated_text = translation_unit.get_translation()
@@ -72,19 +91,20 @@ def fetch_and_translate(self, page_name, language_code, force=False, simulate=Fa
     def translate_with_deepl_or_google(self, text, language_code) -> str:
         """Do the translation: First try DeepL, if that doesn't work (DeepL supports less languages), use Google"""
         if self.language_supported_by_deepl:
-            data = {
-                "text": text,
-                "target_lang": language_code
-            }
-            headers = {
-                "Authorization": f"DeepL-Auth-Key {self.deepl_api_key}"
-            }
-            response = requests.post(self.deepl_endpoint, data=data, headers=headers, timeout=TIMEOUT)
+            data = {"text": text, "target_lang": language_code}
+            headers = {"Authorization": f"DeepL-Auth-Key {self.deepl_api_key}"}
+            response = requests.post(
+                self.deepl_endpoint, data=data, headers=headers, timeout=TIMEOUT
+            )
             if response.status_code == 200:
-                return response.json()['translations'][0]['text']
+                return response.json()["translations"][0]["text"]
             else:
-                self.logger.warning(f"DeepL error {response.status_code}: {response.text}")
-                self.logger.warning(f"DeepL cannot translate to {language_code}. Using Google Translate instead.")
+                self.logger.warning(
+                    f"DeepL error {response.status_code}: {response.text}"
+                )
+                self.logger.warning(
+                    f"DeepL cannot translate to {language_code}. Using Google Translate instead."
+                )
                 self.language_supported_by_deepl = False
 
         # If DeepL fails, use Google Translate
@@ -104,16 +124,23 @@ def upload_translation(self, identifier: str, translated_text: str):
     parser = argparse.ArgumentParser(description="Machine-translate a worksheet.")
     parser.add_argument("worksheet_name", help="Name of the worksheet to translate.")
     parser.add_argument("language_code", help="Target language code for translation.")
-    parser.add_argument("-f", "--force", action="store_true", help="Force overwrite if translation exists.")
-    parser.add_argument("--simulate", action="store_true",
-                        help="Print translated units without uploading to MediaWiki.")
+    parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="Force overwrite if translation exists.",
+    )
+    parser.add_argument(
+        "--simulate",
+        action="store_true",
+        help="Print translated units without uploading to MediaWiki.",
+    )
     args = parser.parse_args()
 
     config = ConfigParser()
     config.read(join(dirname(abspath(__file__)), "config.ini"))
 
     translator_tool = TranslationTool(config)
-    translator_tool.fetch_and_translate(args.worksheet_name,
-                                        args.language_code,
-                                        args.force,
-                                        args.simulate)
+    translator_tool.fetch_and_translate(
+        args.worksheet_name, args.language_code, args.force, args.simulate
+    )

check_for_typos.py

@@ -23,12 +23,20 @@ def parse_arguments() -> argparse.Namespace:
     Returns:
         argparse.Namespace: parsed arguments
     """
-    log_levels: List[str] = ['debug', 'info', 'warning', 'error']
+    log_levels: List[str] = ["debug", "info", "warning", "error"]
 
     parser = argparse.ArgumentParser()
     parser.add_argument("language_code", help="Language code")
-    parser.add_argument("-l", "--loglevel", choices=log_levels, default="warning", help="set loglevel for the script")
-    parser.add_argument("--only", help="Only apply the correction rule with the specified method name")
+    parser.add_argument(
+        "-l",
+        "--loglevel",
+        choices=log_levels,
+        default="warning",
+        help="set loglevel for the script",
+    )
+    parser.add_argument(
+        "--only", help="Only apply the correction rule with the specified method name"
+    )
     return parser.parse_args()
 
 
@@ -37,7 +45,7 @@ def parse_arguments() -> argparse.Namespace:
     root = logging.getLogger()
     root.setLevel(logging.DEBUG)
     sh = logging.StreamHandler(sys.stdout)
-    fformatter = logging.Formatter('%(levelname)s: %(message)s')
+    fformatter = logging.Formatter("%(levelname)s: %(message)s")
     sh.setFormatter(fformatter)
     numeric_level = getattr(logging, args.loglevel.upper(), None)
     assert isinstance(numeric_level, int)
@@ -55,7 +63,10 @@ def parse_arguments() -> argparse.Namespace:
     for worksheet in correctbot.fortraininglib.get_worksheet_list():
         correctbot.check_page(worksheet, args.language_code, apply_only_rule)
         print(f"{worksheet}: {correctbot.get_correction_counter()} corrections")
-        if correctbot.get_correction_counter() > 0 or correctbot.get_suggestion_counter() > 0:
+        if (
+            correctbot.get_correction_counter() > 0
+            or correctbot.get_suggestion_counter() > 0
+        ):
             print(correctbot.get_correction_stats())
             print(correctbot.get_correction_diff())
             print(correctbot.get_suggestion_stats())

check_pdf_metadata.py

@@ -59,7 +59,9 @@ def build_worksheet_info(
         resolved_version = fetched.strip()
 
     progress = TranslationProgress(translated=1, fuzzy=0, total=1)
-    return WorksheetInfo(worksheet_name, language_code, resolved_title, progress, resolved_version)
+    return WorksheetInfo(
+        worksheet_name, language_code, resolved_title, progress, resolved_version
+    )
 
 
 def main(argv: Optional[List[str]] = None) -> int:

correct_bot.py

@@ -35,15 +35,27 @@ def parse_arguments() -> argparse.Namespace:
     Returns:
         CorrectBot instance
     """
-    log_levels: List[str] = ['debug', 'info', 'warning', 'error']
+    log_levels: List[str] = ["debug", "info", "warning", "error"]
 
     parser = argparse.ArgumentParser()
     parser.add_argument("page", help="Name of the mediawiki page")
     parser.add_argument("language_code", help="Language code")
-    parser.add_argument("-s", "--simulate", action="store_true",
-                        help="Simulates the corrections but does not apply them to the webpage.")
-    parser.add_argument("-l", "--loglevel", choices=log_levels, default="warning", help="set loglevel for the script")
-    parser.add_argument("--only", help="Only apply the correction rule with the specified method name")
+    parser.add_argument(
+        "-s",
+        "--simulate",
+        action="store_true",
+        help="Simulates the corrections but does not apply them to the webpage.",
+    )
+    parser.add_argument(
+        "-l",
+        "--loglevel",
+        choices=log_levels,
+        default="warning",
+        help="set loglevel for the script",
+    )
+    parser.add_argument(
+        "--only", help="Only apply the correction rule with the specified method name"
+    )
     return parser.parse_args()
 
 
@@ -54,7 +66,7 @@ def parse_arguments() -> argparse.Namespace:
     root = logging.getLogger()
     root.setLevel(logging.DEBUG)
     sh = logging.StreamHandler(sys.stdout)
-    fformatter = logging.Formatter('%(levelname)s: %(message)s')
+    fformatter = logging.Formatter("%(levelname)s: %(message)s")
     sh.setFormatter(fformatter)
     numeric_level = getattr(logging, args.loglevel.upper(), None)
     assert isinstance(numeric_level, int)

downloadalltranslations.py

@@ -5,6 +5,7 @@
 The PDF files are named [languagename in English] - [language autonym].pdf
 They're put into a (newly created) subdirectory named after the worksheet
 """
+
 import sys
 import os
 import logging
@@ -14,10 +15,12 @@
 
 
 def usage():
-    print("Usage: python3 downloadalltranslations.py [-l {debug, info, warning, error, critical}] <worksheetname>")
+    print(
+        "Usage: python3 downloadalltranslations.py [-l {debug, info, warning, error, critical}] <worksheetname>"
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     try:
         opts, args = getopt.getopt(sys.argv[1:], "hl:", ["help", "loglevel"])
     except getopt.GetoptError as err:
@@ -48,7 +51,9 @@ def usage():
 
     fortraininglib = ForTrainingLib("https://www.4training.net")
     translations = fortraininglib.list_page_translations(worksheetname)
-    logging.info(f'Worksheet {worksheetname} is translated into {len(translations)} languages: {translations.keys()}')
+    logging.info(
+        f"Worksheet {worksheetname} is translated into {len(translations)} languages: {translations.keys()}"
+    )
     for language in translations.keys():
         pdf = fortraininglib.get_pdf_name(worksheetname, language)
         if pdf is None:
@@ -57,17 +62,23 @@ def usage():
         logging.debug(f"Language: {language}, filename: {pdf}")
         url = fortraininglib.get_file_url(pdf)
         if not url:
-            logging.warning(f"Language: {language}, file: {pdf} doesn't seem to exist, ignoring")
+            logging.warning(
+                f"Language: {language}, file: {pdf} doesn't seem to exist, ignoring"
+            )
             continue
         file_request = requests.get(url, allow_redirects=True)
         language_autonym = fortraininglib.get_language_name(language)
-        language_english = fortraininglib.get_language_name(language, 'en')
+        language_english = fortraininglib.get_language_name(language, "en")
         if language_autonym is None or language_english is None:
-            logging.warning(f"Strang: couldn't get language name for language {language}, ignoring")
+            logging.warning(
+                f"Strang: couldn't get language name for language {language}, ignoring"
+            )
             continue
         file_name = f"{worksheetname}/{language_english} - {language_autonym}.pdf"
         try:
-            open(file_name, 'wb').write(file_request.content)
+            open(file_name, "wb").write(file_request.content)
         except FileNotFoundError:
-            logging.warning(f"Language: {language}, error while trying to open file {file_name}, ignoring")
+            logging.warning(
+                f"Language: {language}, error while trying to open file {file_name}, ignoring"
+            )
         logging.info(f"We saved {file_name}")