Merge pull request jxmorris12#129 from mdevolde/logger

feat: added loggers and logs, added logging conf for CL, moving error messages in var before raise

Author: mdevolde

MANIFEST.in

@@ -1,7 +1,7 @@
 include pyproject.toml
 include README.md
 include LICENSE
-recursive-include language_tool_python *.py
+recursive-include language_tool_python *.py *.toml
 include language_tool_python/py.typed
 
 prune .github/

language_tool_python/__init__.py

@@ -9,7 +9,12 @@
     "exceptions",
 ]
 
+import logging
+
 from . import exceptions, utils
 from .language_tag import LanguageTag
 from .match import Match
 from .server import LanguageTool, LanguageToolPublicAPI
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())

language_tool_python/__main__.py

@@ -1,10 +1,15 @@
 """LanguageTool command line."""
 
 import argparse
+import importlib.resources
 import locale
+import logging
 import re
 import sys
+import traceback
 from importlib.metadata import PackageNotFoundError, version
+from logging.config import dictConfig
+from pathlib import Path
 from typing import Any, Optional, Set, Union
 
 import toml
@@ -15,10 +20,23 @@
 try:
     __version__ = version("language_tool_python")
 except PackageNotFoundError:  # If the package is not installed in the environment, read the version from pyproject.toml
-    with open("pyproject.toml", "rb") as f:
+    project_root = Path(__file__).resolve().parent.parent
+    pyproject = project_root / "pyproject.toml"
+    with open(pyproject, "rb") as f:
         __version__ = toml.loads(f.read().decode("utf-8"))["project"]["version"]
 
 
+logger = logging.getLogger(__name__)
+with (
+    importlib.resources.as_file(
+        importlib.resources.files("language_tool_python").joinpath("logging.toml")
+    ) as config_path,
+    open(config_path, "rb") as f,
+):
+    log_config = toml.loads(f.read().decode("utf-8"))
+dictConfig(log_config)
+
+
 def parse_args() -> argparse.Namespace:
     """
     Parse command line arguments.
@@ -101,6 +119,7 @@ def parse_args() -> argparse.Namespace:
         help="hostname of the remote LanguageTool server",
     )
     parser.add_argument("--remote-port", help="port of the remote LanguageTool server")
+    parser.add_argument("--verbose", action="store_true", help="enable verbose output")
 
     args = parser.parse_args()
 
@@ -120,12 +139,11 @@ class RulesAction(argparse.Action):
     This action is used to modify the set of rules stored in the argparse
     namespace when the action is triggered. It updates the attribute specified
     by 'self.dest' with the provided values.
-
-    .. attribute:: dest
-        :type: str
-        The destination attribute to update.
     """
 
+    dest: str
+    """The destination attribute to update."""
+
     def __call__(
         self,
         parser: argparse.ArgumentParser,
@@ -186,6 +204,21 @@ def get_text(
         )
 
 
+def print_exception(exc: Exception, debug: bool) -> None:
+    """
+    Print an exception message to stderr, optionally including a stack trace.
+
+    :param exc: The exception to print.
+    :type exc: Exception
+    :param debug: Whether to include a stack trace.
+    :type debug: bool
+    """
+    if debug:
+        traceback.print_exc()
+    else:
+        print(exc, file=sys.stderr)
+
+
 def main() -> int:
     """
     Main function to parse arguments, process files, and check text using LanguageTool.
@@ -195,6 +228,9 @@ def main() -> int:
     """
     args = parse_args()
 
+    if args.verbose:
+        logging.getLogger().setLevel(logging.DEBUG)
+
     status = 0
 
     for filename in args.files:
@@ -216,55 +252,53 @@ def main() -> int:
             remote_server = args.remote_host
             if args.remote_port is not None:
                 remote_server += f":{args.remote_port}"
-        lang_tool = LanguageTool(
+        with LanguageTool(
             language=args.language,
             motherTongue=args.mother_tongue,
             remote_server=remote_server,
-        )
-
-        try:
-            text = get_text(filename, encoding, ignore=args.ignore_lines)
-        except UnicodeError as exception:
-            print(f"{filename}: {exception}", file=sys.stderr)
-            continue
-
-        if not args.spell_check:
-            lang_tool.disable_spellchecking()
+        ) as lang_tool:
+            try:
+                text = get_text(filename, encoding, ignore=args.ignore_lines)
+            except (UnicodeError, FileNotFoundError) as exception:
+                print_exception(exception, args.verbose)
+                continue
 
-        lang_tool.disabled_rules.update(args.disable)
-        lang_tool.enabled_rules.update(args.enable)
-        lang_tool.enabled_rules_only = args.enabled_only
+            if not args.spell_check:
+                lang_tool.disable_spellchecking()
 
-        if args.picky:
-            lang_tool.picky = True
+            lang_tool.disabled_rules.update(args.disable)
+            lang_tool.enabled_rules.update(args.enable)
+            lang_tool.enabled_rules_only = args.enabled_only
 
-        try:
-            if args.apply:
-                print(lang_tool.correct(text))
-            else:
-                for match in lang_tool.check(text):
-                    rule_id = match.ruleId
+            if args.picky:
+                lang_tool.picky = True
 
-                    replacement_text = ", ".join(
-                        f"'{word}'" for word in match.replacements
-                    ).strip()
+            try:
+                if args.apply:
+                    print(lang_tool.correct(text))
+                else:
+                    for match in lang_tool.check(text):
+                        rule_id = match.ruleId
 
-                    message = match.message
+                        replacement_text = ", ".join(
+                            f"'{word}'" for word in match.replacements
+                        ).strip()
 
-                    # Messages that end with punctuation already include the
-                    # suggestion.
-                    if replacement_text and not message.endswith("?"):
-                        message += " Suggestions: " + replacement_text
+                        message = match.message
 
-                    line, column = match.get_line_and_column(text)
+                        # Messages that end with punctuation already include the
+                        # suggestion.
+                        if replacement_text and not message.endswith("?"):
+                            message += " Suggestions: " + replacement_text
 
-                    print(f"{filename}:{line}:{column}: {rule_id}: {message}")
+                        line, column = match.get_line_and_column(text)
 
-                    status = 2
-        except LanguageToolError as exception:
-            print(f"{filename}: {exception}", file=sys.stderr)
-            continue
+                        print(f"{filename}:{line}:{column}: {rule_id}: {message}")
 
+                        status = 2
+            except LanguageToolError as exception:
+                print_exception(exception, args.verbose)
+                continue
     return status
 
 

language_tool_python/config_file.py

@@ -1,6 +1,7 @@
 """Module for configuring LanguageTool's local server."""
 
 import atexit
+import logging
 import os
 import tempfile
 from dataclasses import dataclass
@@ -9,6 +10,8 @@
 
 from .exceptions import PathError
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class OptionSpec:
@@ -94,9 +97,11 @@ def _path_validator(v: Any) -> None:
     """
     p = Path(v)
     if not p.exists():
-        raise PathError(f"path does not exist: {p}")
+        err = f"path does not exist: {p}"
+        raise PathError(err)
     if not p.is_file():
-        raise PathError(f"path is not a file: {p}")
+        err = f"path is not a file: {p}"
+        raise PathError(err)
 
 
 CONFIG_SCHEMA: Dict[str, OptionSpec] = {
@@ -169,22 +174,27 @@ def _encode_config(config: Dict[str, Any]) -> Dict[str, str]:
     :raises TypeError: If a value's type does not match the expected type(s) defined
                       in the CONFIG_SCHEMA specification.
     """
+    logger.debug("Encoding LanguageTool config with keys: %s", list(config.keys()))
     encoded: Dict[str, str] = {}
     for key, value in config.items():
         if _is_lang_key(key) and key.count("-") == 1:  # lang-<code>
+            logger.debug("Encoding language option %s=%r", key, value)
             encoded[key] = str(value)
             continue
         if _is_lang_key(key) and key.count("-") == 2:  # lang-<code>-dictPath
+            logger.debug("Encoding language dictPath %s=%r", key, value)
             _path_validator(value)
             encoded[key] = _path_encoder(value)
             continue
 
         spec = CONFIG_SCHEMA.get(key)
         if spec is None:
-            raise ValueError(f"unexpected key in config: {key}")
+            err = f"unexpected key in config: {key}"
+            raise ValueError(err)
 
         if not isinstance(value, spec.py_types):
-            raise TypeError(f"invalid type for {key}: {type(value).__name__}")
+            err = f"invalid type for {key}: {type(value).__name__}"
+            raise TypeError(err)
         if spec.validator is not None:
             spec.validator(value)
         encoded[key] = spec.encoder(value)
@@ -210,7 +220,8 @@ def __init__(self, config: Dict[str, Any]):
         Initialize the LanguageToolConfig object.
         """
         if not config:
-            raise ValueError("config cannot be empty")
+            err = "config cannot be empty"
+            raise ValueError(err)
 
         self.config = _encode_config(config)
         self.path = self._create_temp_file()
@@ -232,6 +243,8 @@ def _create_temp_file(self) -> str:
                 tmp_file.write(f"{key}={value}\n")
             temp_name = tmp_file.name
 
+        logger.debug("Created temporary LanguageTool config file at %s", temp_name)
+
         # Remove file when program exits.
         atexit.register(lambda: os.unlink(temp_name))