fix: Patched ruff warnings, applied ruff format, better integrated/configured ruff into the contribution process (jxmorris12#118)

* refactor (__init__.py) : declared imports in __all__ (ruff patch)

* refactor : ruff format

* fix (CONTRIBUTING.md) : replacing black by ruff as formatting tool

* fix: ruff auto fix (type I)

* fix: ruff fix (type B)

* fix: ruff fix (type SIM)

* fix: ruff fix (type RET)

* feat (pyproject.toml) : adding ruff lint config to checks specific rules

Author: mdevolde

CONTRIBUTING.md

@@ -34,7 +34,7 @@ Before creating your pull request, when you have made all your commits, you need
 ruff check language_tool_python tests
 
 # Format code
-black language_tool_python tests
+ruff format language_tool_python tests
 
 # Tests
 pytest

extract_long_description.py

@@ -1,8 +1,9 @@
-import toml
 import os
 
+import toml
+
 with open("pyproject.toml", "rb") as f:
-    pyproject = toml.loads(f.read().decode('utf-8'))
+    pyproject = toml.loads(f.read().decode("utf-8"))
 
 readme_path = pyproject["project"]["readme"]
 

language_tool_python/__init__.py

@@ -1,6 +1,14 @@
 """LanguageTool API for Python."""
 
+__all__ = [
+    "LanguageTool",
+    "LanguageToolPublicAPI",
+    "LanguageTag",
+    "Match",
+    "utils",
+]
+
+from . import utils
 from .language_tag import LanguageTag
 from .match import Match
 from .server import LanguageTool, LanguageToolPublicAPI
-from . import utils

language_tool_python/__main__.py

@@ -4,18 +4,19 @@
 import locale
 import re
 import sys
-from importlib.metadata import version, PackageNotFoundError
-import toml
+from importlib.metadata import PackageNotFoundError, version
 from typing import Any, Optional, Set, Union
 
+import toml
+
 from .server import LanguageTool
 from .utils import LanguageToolError
 
 try:
     __version__ = version("language_tool_python")
-except PackageNotFoundError: # If the package is not installed in the environment, read the version from pyproject.toml
+except PackageNotFoundError:  # If the package is not installed in the environment, read the version from pyproject.toml
     with open("pyproject.toml", "rb") as f:
-        __version__ = toml.loads(f.read().decode('utf-8'))["project"]["version"]
+        __version__ = toml.loads(f.read().decode("utf-8"))["project"]["version"]
 
 
 def parse_args() -> argparse.Namespace:
@@ -27,50 +28,88 @@ def parse_args() -> argparse.Namespace:
     """
     parser = argparse.ArgumentParser(
         description=__doc__.strip() if __doc__ else None,
-        prog='language_tool_python')
-    parser.add_argument('files', nargs='+',
-                        help='plain text file or "-" for stdin')
-    parser.add_argument('-c', '--encoding',
-                        help='input encoding')
-    parser.add_argument('-l', '--language', metavar='CODE',
-                        help='language code of the input or "auto"')
-    parser.add_argument('-m', '--mother-tongue', metavar='CODE',
-                        help='language code of your first language')
-    parser.add_argument('-d', '--disable', metavar='RULES', type=get_rules,
-                        action=RulesAction, default=set(),
-                        help='list of rule IDs to be disabled')
-    parser.add_argument('-e', '--enable', metavar='RULES', type=get_rules,
-                        action=RulesAction, default=set(),
-                        help='list of rule IDs to be enabled')
-    parser.add_argument('--enabled-only', action='store_true',
-                        help='disable all rules except those specified in '
-                             '--enable')
-    parser.add_argument('-p', '--picky', action='store_true',
-                        help='If set, additional rules will be activated.')
+        prog="language_tool_python",
+    )
+    parser.add_argument("files", nargs="+", help='plain text file or "-" for stdin')
+    parser.add_argument("-c", "--encoding", help="input encoding")
+    parser.add_argument(
+        "-l",
+        "--language",
+        metavar="CODE",
+        help='language code of the input or "auto"',
+    )
+    parser.add_argument(
+        "-m",
+        "--mother-tongue",
+        metavar="CODE",
+        help="language code of your first language",
+    )
+    parser.add_argument(
+        "-d",
+        "--disable",
+        metavar="RULES",
+        type=get_rules,
+        action=RulesAction,
+        default=set(),
+        help="list of rule IDs to be disabled",
+    )
+    parser.add_argument(
+        "-e",
+        "--enable",
+        metavar="RULES",
+        type=get_rules,
+        action=RulesAction,
+        default=set(),
+        help="list of rule IDs to be enabled",
+    )
+    parser.add_argument(
+        "--enabled-only",
+        action="store_true",
+        help="disable all rules except those specified in --enable",
+    )
     parser.add_argument(
-        '--version', action='version',
-        version=f'%(prog)s {__version__}',
-        help='show version')
-    parser.add_argument('-a', '--apply', action='store_true',
-                        help='automatically apply suggestions if available')
-    parser.add_argument('-s', '--spell-check-off', dest='spell_check',
-                        action='store_false',
-                        help='disable spell-checking rules')
-    parser.add_argument('--ignore-lines',
-                        help='ignore lines that match this regular expression')
-    parser.add_argument('--remote-host',
-                        help='hostname of the remote LanguageTool server')
-    parser.add_argument('--remote-port',
-                        help='port of the remote LanguageTool server')
+        "-p",
+        "--picky",
+        action="store_true",
+        help="If set, additional rules will be activated.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="show version",
+    )
+    parser.add_argument(
+        "-a",
+        "--apply",
+        action="store_true",
+        help="automatically apply suggestions if available",
+    )
+    parser.add_argument(
+        "-s",
+        "--spell-check-off",
+        dest="spell_check",
+        action="store_false",
+        help="disable spell-checking rules",
+    )
+    parser.add_argument(
+        "--ignore-lines",
+        help="ignore lines that match this regular expression",
+    )
+    parser.add_argument(
+        "--remote-host",
+        help="hostname of the remote LanguageTool server",
+    )
+    parser.add_argument("--remote-port", help="port of the remote LanguageTool server")
 
     args = parser.parse_args()
 
     if args.enabled_only:
         if args.disable:
-            parser.error('--enabled-only cannot be used with --disable')
+            parser.error("--enabled-only cannot be used with --disable")
 
         if not args.enable:
-            parser.error('--enabled-only requires --enable')
+            parser.error("--enabled-only requires --enable")
 
     return args
 
@@ -85,7 +124,14 @@ class RulesAction(argparse.Action):
     Attributes:
         dest (str): the destination attribute to update
     """
-    def __call__(self, parser: argparse.ArgumentParser, namespace: Any, values: Any, option_string: Optional[str] = None):
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: Any,
+        values: Any,
+        option_string: Optional[str] = None,
+    ):
         """
         This method is called when the action is triggered. It updates the set of rules
         in the namespace with the provided values. The method is invoked automatically
@@ -115,7 +161,11 @@ def get_rules(rules: str) -> Set[str]:
     return {rule.upper() for rule in re.findall(r"[\w\-]+", rules)}
 
 
-def get_text(filename: Union[str, int], encoding: Optional[str], ignore: Optional[str]) -> str:
+def get_text(
+    filename: Union[str, int],
+    encoding: Optional[str],
+    ignore: Optional[str],
+) -> str:
     """
     Read the content of a file and return it as a string, optionally ignoring lines that match a regular expression.
 
@@ -129,9 +179,10 @@ def get_text(filename: Union[str, int], encoding: Optional[str], ignore: Optiona
     :rtype: str
     """
     with open(filename, encoding=encoding) as f:
-        text = ''.join('\n' if (ignore and re.match(ignore, line)) else line
-                       for line in f.readlines())
-    return text
+        return "".join(
+            "\n" if (ignore and re.match(ignore, line)) else line
+            for line in f.readlines()
+        )
 
 
 def main() -> int:
@@ -149,20 +200,21 @@ def main() -> int:
         if len(args.files) > 1:
             print(filename, file=sys.stderr)
 
-        if filename == '-':
+        if filename == "-":
             filename = sys.stdin.fileno()
             encoding = args.encoding or (
-                sys.stdin.encoding if sys.stdin.isatty()
+                sys.stdin.encoding
+                if sys.stdin.isatty()
                 else locale.getpreferredencoding()
             )
         else:
-            encoding = args.encoding or 'utf-8'
+            encoding = args.encoding or "utf-8"
 
         remote_server = None
         if args.remote_host is not None:
             remote_server = args.remote_host
             if args.remote_port is not None:
-                remote_server += f':{args.remote_port}'
+                remote_server += f":{args.remote_port}"
         lang_tool = LanguageTool(
             language=args.language,
             motherTongue=args.mother_tongue,
@@ -172,7 +224,7 @@ def main() -> int:
         try:
             text = get_text(filename, encoding, ignore=args.ignore_lines)
         except UnicodeError as exception:
-            print(f'{filename}: {exception}', file=sys.stderr)
+            print(f"{filename}: {exception}", file=sys.stderr)
             continue
 
         if not args.spell_check:
@@ -192,24 +244,24 @@ def main() -> int:
                 for match in lang_tool.check(text):
                     rule_id = match.ruleId
 
-                    replacement_text = ', '.join(
-                        f"'{word}'"
-                        for word in match.replacements).strip()
+                    replacement_text = ", ".join(
+                        f"'{word}'" for word in match.replacements
+                    ).strip()
 
                     message = match.message
 
                     # Messages that end with punctuation already include the
                     # suggestion.
-                    if replacement_text and not message.endswith('?'):
-                        message += ' Suggestions: ' + replacement_text
-                    
+                    if replacement_text and not message.endswith("?"):
+                        message += " Suggestions: " + replacement_text
+
                     line, column = match.get_line_and_column(text)
 
-                    print(f'{filename}:{line}:{column}: {rule_id}: {message}')
+                    print(f"{filename}:{line}:{column}: {rule_id}: {message}")
 
                     status = 2
         except LanguageToolError as exception:
-            print(f'{filename}: {exception}', file=sys.stderr)
+            print(f"{filename}: {exception}", file=sys.stderr)
             continue
 
     return status