Merge pull request #136 from mdevolde/pathlib

refactor: replaced os.path uses by pathlib (breaking)

Author: mdevolde

language_tool_python/config_file.py

@@ -2,7 +2,6 @@
 
 import atexit
 import logging
-import os
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
@@ -246,6 +245,6 @@ def _create_temp_file(self) -> str:
  logger.debug("Created temporary LanguageTool config file at %s", temp_name)
 
  # Remove file when program exits.
- atexit.register(lambda: os.unlink(temp_name))
+ atexit.register(lambda: Path(temp_name).unlink(missing_ok=True))
 
  return temp_name

language_tool_python/download_lt.py

@@ -7,6 +7,7 @@
 import tempfile
 import zipfile
 from datetime import datetime
+from pathlib import Path
 from shutil import which
 from typing import IO, Dict, Optional, Tuple
 from urllib.parse import urljoin
@@ -200,29 +201,29 @@ def http_get(
  progress.close()
 
 
-def unzip_file(temp_file_name: str, directory_to_extract_to: str) -> None:
+def unzip_file(temp_file_name: str, directory_to_extract_to: Path) -> None:
  """
  Unzips a zip file to a specified directory.
 
  :param temp_file_name: A temporary file object representing the zip file to be extracted.
  :type temp_file_name: str
  :param directory_to_extract_to: The directory where the contents of the zip file will be extracted.
- :type directory_to_extract_to: str
+ :type directory_to_extract_to: Path
  """
 
  logger.info("Unzipping %s to %s", temp_file_name, directory_to_extract_to)
  with zipfile.ZipFile(temp_file_name, "r") as zip_ref:
  zip_ref.extractall(directory_to_extract_to)
 
 
-def download_zip(url: str, directory: str) -> None:
+def download_zip(url: str, directory: Path) -> None:
  """
  Downloads a ZIP file from the given URL and extracts it to the specified directory.
 
  :param url: The URL of the ZIP file to download.
  :type url: str
  :param directory: The directory where the ZIP file should be extracted.
- :type directory: str
+ :type directory: Path
  """
  logger.info("Downloading from %s to %s", url, directory)
  # Download file using a context manager.
@@ -232,14 +233,13 @@ def download_zip(url: str, directory: str) -> None:
  # Extract zip file to path.
  unzip_file(temp_name, directory)
  # Remove the temporary file.
- os.remove(temp_name)
+ Path(temp_name).unlink(missing_ok=True)
 
 
 def download_lt(language_tool_version: str = LTP_DOWNLOAD_VERSION) -> None:
  """
  Downloads and extracts the specified version of LanguageTool.
- This function checks for Java compatibility, creates the necessary download
- directory if it does not exist, and downloads the specified version of
+ This function checks for Java compatibility, and downloads the specified version of
  LanguageTool if it is not already present.
 
  :param language_tool_version: The version of LanguageTool to download. If not
@@ -259,10 +259,7 @@ def download_lt(language_tool_version: str = LTP_DOWNLOAD_VERSION) -> None:
  if os.environ.get(LTP_JAR_DIR_PATH_ENV_VAR):
  return
 
- # Make download path, if it doesn't exist.
- os.makedirs(download_folder, exist_ok=True)
-
- if not os.path.isdir(download_folder):
+ if not download_folder.is_dir():
  err = f"Download folder {download_folder} is not a directory."
  raise PathError(err)
  old_path_list = find_existing_language_tool_downloads(download_folder)
@@ -282,11 +279,11 @@ def download_lt(language_tool_version: str = LTP_DOWNLOAD_VERSION) -> None:
  f"You can also use 'latest' to download the latest snapshot of LanguageTool."
  )
  raise ValueError(err)
- dirname, _ = os.path.splitext(filename)
+ dirname = Path(filename).stem
  dirname = dirname.replace("latest", LT_SNAPSHOT_CURRENT_VERSION)
  if version == "latest":
  dirname = f"LanguageTool-{LT_SNAPSHOT_CURRENT_VERSION}"
- extract_path = os.path.join(download_folder, dirname)
+ extract_path = download_folder / dirname
 
  if extract_path not in old_path_list:
  download_zip(language_tool_download_url, download_folder)

language_tool_python/server.py

@@ -5,13 +5,13 @@
 import http.client
 import json
 import logging
-import os
 import random
 import socket
 import subprocess
 import time
 import urllib.parse
 import warnings
+from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Set
 
 import psutil
@@ -410,7 +410,7 @@ def disable_spellchecking(self) -> None:
  self.disabled_categories.update(self._spell_checking_categories)
 
  @staticmethod
- def _get_valid_spelling_file_path() -> str:
+ def _get_valid_spelling_file_path() -> Path:
  """
  Retrieve the valid file path for the spelling file.
  This function constructs the file path for the spelling file used by the
@@ -420,14 +420,19 @@ def _get_valid_spelling_file_path() -> str:
  :raises FileNotFoundError: If the spelling file does not exist at the
  constructed path.
  :return: The valid file path for the spelling file.
- :rtype: str
+ :rtype: Path
  """
  library_path = get_language_tool_directory()
- spelling_file_path = os.path.join(
- library_path,
- "org/languagetool/resource/en/hunspell/spelling.txt",
+ spelling_file_path = (
+ library_path
+ / "org"
+ / "languagetool"
+ / "resource"
+ / "en"
+ / "hunspell"
+ / "spelling.txt"
  )
- if not os.path.exists(spelling_file_path):
+ if not spelling_file_path.exists():
  err = (
  f"Failed to find the spellings file at {spelling_file_path}\n"
  " Please file an issue at "

language_tool_python/utils.py

@@ -1,17 +1,18 @@
 """Utility functions for the LanguageTool library."""
 
 import contextlib
-import glob
 import locale
 import logging
 import os
 import subprocess
 import urllib.parse
 from enum import Enum
+from pathlib import Path
 from shutil import which
 from typing import Any, List, Optional, Tuple
 
 import psutil
+from packaging import version
 
 from .config_file import LanguageToolConfig
 from .exceptions import JavaError, PathError
@@ -120,42 +121,65 @@ def correct(text: str, matches: List[Match]) -> str:
  return "".join(ltext)
 
 
-def get_language_tool_download_path() -> str:
+def get_language_tool_download_path() -> Path:
  """
  Get the download path for LanguageTool.
  This function retrieves the download path for LanguageTool from the environment variable
  specified by ``LTP_PATH_ENV_VAR``. If the environment variable is not set, it defaults to
  a path in the user's home directory under ``.cache/language_tool_python``.
+ The function ensures that the directory exists before returning it.
 
  :return: The download path for LanguageTool.
- :rtype: str
+ :rtype: Path
  """
  # Get download path from environment or use default.
- return os.environ.get(
+ path_str = os.environ.get(
  LTP_PATH_ENV_VAR,
- os.path.join(os.path.expanduser("~"), ".cache", "language_tool_python"),
+ str(Path.home() / ".cache" / "language_tool_python"),
  )
+ path = Path(path_str)
+ path.mkdir(parents=True, exist_ok=True)
+ return path
 
 
-def find_existing_language_tool_downloads(download_folder: str) -> List[str]:
+def find_existing_language_tool_downloads(download_folder: Path) -> List[Path]:
  """
  Find existing LanguageTool downloads in the specified folder.
  This function searches for directories in the given download folder
  that match the pattern 'LanguageTool*' and returns a list of their paths.
 
  :param download_folder: The folder where LanguageTool downloads are stored.
- :type download_folder: str
+ :type download_folder: Path
  :return: A list of paths to the existing LanguageTool download directories.
- :rtype: List[str]
+ :rtype: List[Path]
  """
- return [
- path
- for path in glob.glob(os.path.join(download_folder, "LanguageTool*"))
- if os.path.isdir(path)
- ]
+ return [path for path in download_folder.glob("LanguageTool*") if path.is_dir()]
+
+
+def _extract_version(path: Path) -> version.Version:
+ """
+ Extract the version number from a LanguageTool directory path.
 
+ This function parses the directory name to extract the version information
+ from LanguageTool installation folders that follow the naming convention
+ 'LanguageTool-X.Y-SNAPSHOT'.
 
-def get_language_tool_directory() -> str:
+ :param path: The path to the LanguageTool directory
+ :type path: Path
+ :return: The parsed version object extracted from the directory name
+ :rtype: version.Version
+ :raises ValueError: If the directory name doesn't start with 'LanguageTool-'
+ """
+ if not path.name.startswith("LanguageTool-"):
+ raise ValueError(f"Invalid LanguageTool folder name: {path.name}")
+ # Handle LanguageTool- prefix
+ version_str = path.name.removeprefix("LanguageTool-")
+ # Handle both -SNAPSHOT and -snapshot suffixes
+ version_str = version_str.removesuffix("-SNAPSHOT").removesuffix("-snapshot")
+ return version.parse(version_str)
+
+
+def get_language_tool_directory() -> Path:
  """
  Get the directory path of the LanguageTool installation.
  This function checks the download folder for LanguageTool installations,
@@ -165,11 +189,11 @@ def get_language_tool_directory() -> str:
  :raises NotADirectoryError: If the download folder path is not a valid directory.
  :raises FileNotFoundError: If no LanguageTool installation is found in the download folder.
  :return: The path to the latest version of LanguageTool found in the directory.
- :rtype: str
+ :rtype: Path
  """
 
  download_folder = get_language_tool_download_path()
- if not os.path.isdir(download_folder):
+ if not download_folder.is_dir():
  err = f"LanguageTool directory path is not a valid directory {download_folder}."
  raise NotADirectoryError(err)
  language_tool_path_list = find_existing_language_tool_downloads(download_folder)
@@ -179,7 +203,10 @@ def get_language_tool_directory() -> str:
  raise FileNotFoundError(err)
 
  # Return the latest version found in the directory.
- latest = max(language_tool_path_list)
+ latest = max(
+ language_tool_path_list,
+ key=_extract_version,
+ )
  logger.debug("Using LanguageTool directory: %s", latest)
  return latest
 
@@ -199,7 +226,12 @@ def get_server_cmd(
  :rtype: List[str]
  """
  java_path, jar_path = get_jar_info()
- cmd = [java_path, "-cp", jar_path, "org.languagetool.server.HTTPServer"]
+ cmd = [
+ str(java_path),
+ "-cp",
+ str(jar_path),
+ "org.languagetool.server.HTTPServer",
+ ]
 
  if port is not None:
  cmd += ["-p", str(port)]
@@ -211,7 +243,7 @@ def get_server_cmd(
  return cmd
 
 
-def get_jar_info() -> Tuple[str, str]:
+def get_jar_info() -> Tuple[Path, Path]:
  """
  Retrieve the path to the Java executable and the LanguageTool JAR file.
  This function searches for the Java executable in the system's PATH and
@@ -221,13 +253,14 @@ def get_jar_info() -> Tuple[str, str]:
  :raises JavaError: If the Java executable cannot be found.
  :raises PathError: If the LanguageTool JAR file cannot be found in the specified directory.
  :return: A tuple containing the path to the Java executable and the path to the LanguageTool JAR file.
- :rtype: Tuple[str, str]
+ :rtype: Tuple[Path, Path]
  """
 
- java_path = which("java")
- if not java_path:
+ java_path_str = which("java")
+ if not java_path_str:
  err = "can't find Java"
  raise JavaError(err)
+ java_path = Path(java_path_str)
 
  # Use the env var to the jar directory if it is defined
  # otherwise look in the download directory
@@ -237,8 +270,8 @@ def get_jar_info() -> Tuple[str, str]:
  )
  jar_path = None
  for jar_name in JAR_NAMES:
- for jar_path in glob.glob(os.path.join(jar_dir_name, jar_name)):
- if os.path.isfile(jar_path):
+ for jar_path in Path(jar_dir_name).glob(jar_name):
+ if jar_path.is_file():
  logger.debug("Found LanguageTool JAR: %s", jar_path)
  break
  else:

tests/test_major_functionality.py

@@ -332,14 +332,18 @@ def test_spellcheck_en_gb():
 
 def test_session_only_new_spellings():
  import hashlib
- import os
 
  import language_tool_python
 
  library_path = language_tool_python.utils.get_language_tool_directory()
- spelling_file_path = os.path.join(
- library_path,
- "org/languagetool/resource/en/hunspell/spelling.txt",
+ spelling_file_path = (
+ library_path
+ / "org"
+ / "languagetool"
+ / "resource"
+ / "en"
+ / "hunspell"
+ / "spelling.txt"
  )
  with open(spelling_file_path, "r") as spelling_file:
  initial_spelling_file_contents = spelling_file.read()