perf: Change format() to f-strings, more modern and more efficient

Author: mdevolde

language_tool_python/__main__.py

@@ -42,7 +42,7 @@ def parse_args():
                         help='If set, additional rules will be activated.')
     parser.add_argument(
         '--version', action='version',
-        version='%(prog)s {}'.format(__version__),
+        version=f'%(prog)s {__version__}',
         help='show version')
     parser.add_argument('-a', '--apply', action='store_true',
                         help='automatically apply suggestions if available')
@@ -106,7 +106,7 @@ def main():
         if args.remote_host is not None:
             remote_server = args.remote_host
             if args.remote_port is not None:
-                remote_server += ':{}'.format(args.remote_port)
+                remote_server += f':{args.remote_port}'
         lang_tool = LanguageTool(
             language=args.language,
             motherTongue=args.mother_tongue,
@@ -116,7 +116,7 @@ def main():
         try:
             text = get_text(filename, encoding, ignore=args.ignore_lines)
         except UnicodeError as exception:
-            print('{}: {}'.format(filename, exception), file=sys.stderr)
+            print(f'{filename}: {exception}', file=sys.stderr)
             continue
 
         if not args.spell_check:
@@ -137,7 +137,7 @@ def main():
                     rule_id = match.ruleId
 
                     replacement_text = ', '.join(
-                        "'{}'".format(word)
+                        f"'{word}'"
                         for word in match.replacements).strip()
 
                     message = match.message
@@ -147,14 +147,11 @@ def main():
                     if replacement_text and not message.endswith(('.', '?')):
                         message += '; suggestions: ' + replacement_text
 
-                    print('{}: {}: {}'.format(
-                        filename,
-                        rule_id,
-                        message))
+                    print(f'{filename}: {rule_id}: {message}')
 
                     status = 2
         except LanguageToolError as exception:
-            print('{}: {}'.format(filename, exception), file=sys.stderr)
+            print(f'{filename}: {exception}', file=sys.stderr)
             continue
 
     return status

language_tool_python/download_lt.py

@@ -64,8 +64,7 @@ def parse_java_version(version_text):
         or re.search(JAVA_VERSION_REGEX_UPDATED, version_text)
     )
     if not match:
-        raise SystemExit(
-            'Could not parse Java version from """{}""".'.format(version_text))
+        raise SystemExit(f'Could not parse Java version from """{version_text}""".')
     major1 = int(match.group('major1'))
     major2 = int(match.group('major2')) if match.group('major2') else 0
     return (major1, major2)
@@ -95,7 +94,7 @@ def confirm_java_compatibility():
     elif major_version >= 8:
         return True
     else:
-        raise SystemError('Detected java {}.{}. LanguageTool requires Java >= 8.'.format(major_version, minor_version))
+        raise SystemError(f'Detected java {major_version}.{minor_version}. LanguageTool requires Java >= 8.')
 
 
 def get_common_prefix(z):
@@ -113,7 +112,7 @@ def http_get(url, out_file, proxies=None):
     content_length = req.headers.get('Content-Length')
     total = int(content_length) if content_length is not None else None
     if req.status_code == 403:  # Not found on AWS
-        raise Exception('Could not find at URL {}.'.format(url))
+        raise Exception(f'Could not find at URL {url}.')
     version = re.search(r'(\d+\.\d+)', url).group(1)
     progress = tqdm.tqdm(unit="B", unit_scale=True, total=total,
                          desc=f'Downloading LanguageTool {version}')
@@ -126,9 +125,7 @@ def http_get(url, out_file, proxies=None):
 
 def unzip_file(temp_file, directory_to_extract_to):
     """ Unzips a .zip file to folder path. """
-    logger.info(
-        'Unzipping {} to {}.'.format(temp_file.name, directory_to_extract_to)
-    )
+    logger.info(f'Unzipping {temp_file.name} to {directory_to_extract_to}.')
     with zipfile.ZipFile(temp_file.name, 'r') as zip_ref:
         zip_ref.extractall(directory_to_extract_to)
 
@@ -145,7 +142,7 @@ def download_zip(url, directory):
     # Remove the temporary file.
     os.remove(downloaded_file.name)
     # Tell the user the download path.
-    logger.info('Downloaded {} to {}.'.format(url, directory))
+    logger.info(f'Downloaded {url} to {directory}.')
 
 
 def download_lt(language_tool_version: Optional[str] = LTP_DOWNLOAD_VERSION):

language_tool_python/language_tag.py

@@ -22,7 +22,7 @@ def __str__(self):
         return self.normalized_tag
 
     def __repr__(self):
-        return '<LanguageTag "{}">'.format(str(self))
+        return f'<LanguageTag "{str(self)}">'
 
     def _normalize(self, tag):
         if not tag:
@@ -35,4 +35,4 @@ def _normalize(self, tag):
             try:
                 return languages[self._LANGUAGE_RE.match(tag).group(1).lower()]
             except (KeyError, AttributeError):
-                raise ValueError('unsupported language: {!r}'.format(tag))
+                raise ValueError(f'unsupported language: {tag!r}')

language_tool_python/match.py

@@ -69,26 +69,18 @@ def _ordered_dict_repr():
             slots += list(set(self.__dict__).difference(slots))
             attrs = [slot for slot in slots
                      if slot in self.__dict__ and not slot.startswith('_')]
-            return '{{{}}}'.format(
-                ', '.join([
-                    '{!r}: {!r}'.format(attr, getattr(self, attr))
-                    for attr in attrs
-                ])
-            )
+            return f"{{{', '.join([f'{attr!r}: {getattr(self, attr)!r}' for attr in attrs])}}}"
 
-        return '{}({})'.format(self.__class__.__name__, _ordered_dict_repr())
+        return f'{self.__class__.__name__}({_ordered_dict_repr()})'
 
     def __str__(self):
         ruleId = self.ruleId
-        s = 'Offset {}, length {}, Rule ID: {}'.format(
-            self.offset, self.errorLength, ruleId)
+        s = f'Offset {self.offset}, length {self.errorLength}, Rule ID: {ruleId}'
         if self.message:
-            s += '\nMessage: {}'.format(self.message)
+            s += f'\nMessage: {self.message}'
         if self.replacements:
-            s += '\nSuggestion: {}'.format('; '.join(self.replacements))
-        s += '\n{}\n{}'.format(
-            self.context, ' ' * self.offsetInContext + '^' * self.errorLength
-        )
+            s += f"\nSuggestion: {'; '.join(self.replacements)}"
+        s += f"\n{self.context}\n{' ' * self.offsetInContext + '^' * self.errorLength}"
         return s
 
     @property
@@ -103,7 +95,7 @@ def select_replacement(self, index: int) -> None:
         if not self.replacements:
             raise ValueError('This Match has no suggestions')
         elif index < 0 or index >= len(self.replacements):
-            raise ValueError('This Match\'s suggestions are numbered from 0 to {}'.format(len(self.replacements) - 1))
+            raise ValueError(f'This Match\'s suggestions are numbered from 0 to {len(self.replacements) - 1}')
         self.replacements = [self.replacements[index]]
 
     def __eq__(self, other):
@@ -124,5 +116,4 @@ def __setattr__(self, key, value):
 
     def __getattr__(self, name):
         if name not in get_match_ordered_dict():
-            raise AttributeError('{!r} object has no attribute {!r}'
-                                 .format(self.__class__.__name__, name))
+            raise AttributeError(f'{self.__class__.__name__!r} object has no attribute {name!r}')

language_tool_python/server.py

@@ -99,8 +99,7 @@ def __del__(self):
         self.close()
 
     def __repr__(self):
-        return '{}(language={!r}, motherTongue={!r})'.format(
-            self.__class__.__name__, self.language, self.motherTongue)
+        return f'{self.__class__.__name__}(language={self.language!r}, motherTongue={self.motherTongue!r})'
 
     def close(self):
         if self._server_is_alive():
@@ -188,10 +187,9 @@ def _get_valid_spelling_file_path() -> str:
         )
         if not os.path.exists(spelling_file_path):
             raise FileNotFoundError(
-                "Failed to find the spellings file at {}\n "
+                f"Failed to find the spellings file at {spelling_file_path}\n "
                 "Please file an issue at "
-                "https://github.com/jxmorris12/language_tool_python/issues"
-                .format(spelling_file_path))
+                "https://github.com/jxmorris12/language_tool_python/issues")
         return spelling_file_path
 
     def _register_spellings(self):
@@ -205,7 +203,7 @@ def _register_spellings(self):
                     spellings_file.write("\n")
                 spellings_file.write("\n".join(new_spellings))
         if DEBUG_MODE:
-            print("Registered new spellings at {}".format(spelling_file_path))
+            print(f"Registered new spellings at {spelling_file_path}")
 
     def _unregister_spellings(self):
         spelling_file_path = self._get_valid_spelling_file_path()
@@ -258,9 +256,8 @@ def _query_server(self, url, params=None, num_tries=2):
                     except json.decoder.JSONDecodeError as e:
                         if DEBUG_MODE:
                             print(
-                                'URL {} and params {} '
-                                'returned invalid JSON response: {}'
-                                .format(url, params, e)
+                                f'URL {url} and params {params} '
+                                f'returned invalid JSON response: {e}'
                             )
                             print(response)
                             print(response.content)
@@ -270,11 +267,11 @@ def _query_server(self, url, params=None, num_tries=2):
                     self._terminate_server()
                     self._start_local_server()
                 if n + 1 >= num_tries:
-                    raise LanguageToolError('{}: {}'.format(self._url, e))
+                    raise LanguageToolError(f'{self._url}: {e}')
 
     def _start_server_on_free_port(self):
         while True:
-            self._url = 'http://{}:{}/v2/'.format(self._host, self._port)
+            self._url = f'http://{self._host}:{self._port}/v2/'
             try:
                 self._start_local_server()
                 break
@@ -327,10 +324,7 @@ def _start_local_server(self):
                 if match:
                     port = int(match.group(1))
                     if port != self._port:
-                        raise LanguageToolError(
-                            'requested port {}, but got {}'
-                            .format(self._port, port)
-                        )
+                        raise LanguageToolError(f'requested port {self._port}, but got {port}')
                     break
             if not match:
                 err_msg = self._terminate_server()

language_tool_python/utils.py

@@ -116,18 +116,13 @@ def get_language_tool_directory() -> str:
     """Get LanguageTool directory."""
     download_folder = get_language_tool_download_path()
     if not os.path.isdir(download_folder):
-        raise NotADirectoryError(
-            "LanguageTool directory path is not a valid directory {}."
-            .format(download_folder)
-        )
+        raise NotADirectoryError(f"LanguageTool directory path is not a valid directory {download_folder}.")
     language_tool_path_list = find_existing_language_tool_downloads(
         download_folder
     )
 
     if not len(language_tool_path_list):
-        raise FileNotFoundError(
-            'LanguageTool not found in {}.'.format(download_folder)
-        )
+        raise FileNotFoundError(f'LanguageTool not found in {download_folder}.')
 
     # Return the latest version found in the directory.
     return max(language_tool_path_list)
@@ -170,8 +165,7 @@ def get_jar_info() -> Tuple[str, str]:
         if jar_path:
             break
     else:
-        raise PathError("can't find languagetool-standalone in {!r}"
-                        .format(jar_dir_name))
+        raise PathError(f"can't find languagetool-standalone in {jar_dir_name!r}")
     return java_path, jar_path