refactor: apply ruff rules

Author: rchl

.gitignore

@@ -2,6 +2,8 @@
 __pycache__
 .mypy_cache
 *.pickle
+.ruff_cache
+.tox
 
 # build artifacts
 dist/

.style.yapf

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from ._client_handler import ClientHandler
 from ._client_handler import notification_handler
 from ._client_handler import request_handler
@@ -19,22 +20,22 @@
 from .uv_venv_manager import UvVenvManager
 
 __all__ = [
+    'SETTINGS_FILENAME',
     'ApiWrapperInterface',
     'ClientHandler',
-    'download_file',
-    'extract_archive',
     'GenericClientHandler',
     'NodeRuntime',
-    'notification_handler',
     'NpmClientHandler',
     'PipVenvManager',
-    'request_handler',
-    'rmtree_ex',
     'ServerNpmResource',
     'ServerPipResource',
     'ServerResourceInterface',
     'ServerStatus',
-    'SETTINGS_FILENAME',
     'UvRunner',
-    'UvVenvManager'
+    'UvVenvManager',
+    'download_file',
+    'extract_archive',
+    'notification_handler',
+    'request_handler',
+    'rmtree_ex',
 ]

lsp_utils/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from .abstract_plugin import ClientHandler
 from .api_decorator import notification_handler
 from .api_decorator import request_handler

lsp_utils/_client_handler/__init__.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 from ..api_wrapper_interface import ApiNotificationHandler
 from ..api_wrapper_interface import ApiRequestHandler
 from ..api_wrapper_interface import ApiWrapperInterface
 from ..server_resource_interface import ServerStatus
 from .api_decorator import register_decorated_handlers
 from .interface import ClientHandlerInterface
-from abc import ABCMeta
+from abc import ABC
 from functools import partial
 from LSP.plugin import AbstractPlugin
 from LSP.plugin import ClientConfig
@@ -16,18 +17,23 @@
 from LSP.plugin import Session
 from LSP.plugin import unregister_plugin
 from LSP.plugin import WorkspaceFolder
-from LSP.plugin.core.rpc import method2attr
+from LSP.plugin.core.rpc import method2attr  # pyright: ignore[reportPrivateLocalImportUsage]
 from os import path
-from typing import Any, Callable
+from typing import Any
+from typing import Callable
+from typing import TYPE_CHECKING
 from typing_extensions import override
-from weakref import WeakMethod, ref
-import sublime
+from weakref import ref
+from weakref import WeakMethod
+
+if TYPE_CHECKING:
+    import sublime
 
 __all__ = ['ClientHandler']
 
 
 class ApiWrapper(ApiWrapperInterface):
-    def __init__(self, plugin: 'ref[AbstractPlugin]'):
+    def __init__(self, plugin: ref[AbstractPlugin]) -> None:
         self.__plugin = plugin
 
     def __session(self) -> Session | None:
@@ -72,15 +78,13 @@ def send_request(self, method: str, params: Any, handler: Callable[[Any, bool],
         session = self.__session()
         if session:
             request: Request[Any, Any] = Request(method, params)
-            session.send_request(request, lambda result: handler(result, False), lambda result: handler(result, True))
+            session.send_request(request, lambda result: handler(result, False), lambda result: handler(result, True))  # noqa: FBT003
         else:
-            handler(None, True)
+            handler(None, True)  # noqa: FBT003
 
 
-class ClientHandler(AbstractPlugin, ClientHandlerInterface, metaclass=ABCMeta):
-    """
-    The base class for creating an LSP plugin.
-    """
+class ClientHandler(AbstractPlugin, ClientHandlerInterface, ABC):
+    """The base class for creating an LSP plugin."""
 
     # --- AbstractPlugin handlers -------------------------------------------------------------------------------------
 
@@ -121,9 +125,9 @@ def can_start(cls, window: sublime.Window, initiating_view: sublime.View,
         if cls.manages_server():
             server = cls.get_server()
             if not server or server.get_status() == ServerStatus.ERROR:
-                return "{}: Error installing server dependencies.".format(cls.package_name)
+                return f"{cls.package_name}: Error installing server dependencies."
             if server.get_status() != ServerStatus.READY:
-                return "{}: Server installation in progress...".format(cls.package_name)
+                return f"{cls.package_name}: Server installation in progress..."
         message = cls.is_allowed_to_start(window, initiating_view, workspace_folders, configuration)
         if message:
             return message
@@ -167,6 +171,6 @@ def cleanup(cls) -> None:
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
-        api = ApiWrapper(ref(self))  # type: ignore
+        api = ApiWrapper(ref(self))
         register_decorated_handlers(self, api)
         self.on_ready(api)

lsp_utils/_client_handler/abstract_plugin.py

@@ -1,13 +1,21 @@
 from __future__ import annotations
-from ..api_wrapper_interface import ApiWrapperInterface
-from .interface import ClientHandlerInterface
-from typing import Any, Callable, List, TypeVar, Union
+
+from typing import Any
+from typing import Callable
+from typing import List
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
 import inspect
 
+if TYPE_CHECKING:
+    from ..api_wrapper_interface import ApiWrapperInterface
+    from .interface import ClientHandlerInterface
+
 __all__ = [
     "notification_handler",
-    "request_handler",
     "register_decorated_handlers",
+    "request_handler",
 ]
 
 T = TypeVar('T')
@@ -24,31 +32,28 @@
 
 def notification_handler(notification_methods: MessageMethods) -> Callable[[NotificationHandler], NotificationHandler]:
     """
-    Marks the decorated function as a "notification" message handler.
+    Mark the decorated function as a "notification" message handler.
 
     On server sending the notification, the decorated function will be called with the `params` argument which contains
     the payload.
     """
-
     return _create_handler("notification", notification_methods)
 
 
 def request_handler(request_methods: MessageMethods) -> Callable[[RequestHandler], RequestHandler]:
     """
-    Marks the decorated function as a "request" message handler.
+    Mark the decorated function as a "request" message handler.
 
     On server sending the request, the decorated function will be called with two arguments (`params` and `respond`).
     The first argument (`params`) is the payload of the request and the second argument (`respond`) is the function that
     must be used to respond to the request. The `respond` function takes any data that should be sent back to the
     server.
     """
-
     return _create_handler("request", request_methods)
 
 
 def _create_handler(client_event: str, message_methods: MessageMethods) -> Callable[[T], T]:
-    """ Marks the decorated function as a message handler. """
-
+    """Mark the decorated function as a message handler."""
     message_methods = [message_methods] if isinstance(message_methods, str) else message_methods
 
     def decorator(func: T) -> T:

lsp_utils/_client_handler/api_decorator.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
-from ..api_wrapper_interface import ApiWrapperInterface
-from ..server_resource_interface import ServerResourceInterface
-from abc import ABCMeta
+
+from abc import ABC
 from abc import abstractmethod
-from LSP.plugin import ClientConfig
-from LSP.plugin import DottedDict
-from LSP.plugin import WorkspaceFolder
-import sublime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..api_wrapper_interface import ApiWrapperInterface
+    from ..server_resource_interface import ServerResourceInterface
+    from LSP.plugin import ClientConfig
+    from LSP.plugin import DottedDict
+    from LSP.plugin import WorkspaceFolder
+    import sublime
 
 __all__ = ['ClientHandlerInterface']
 
 
-class ClientHandlerInterface(metaclass=ABCMeta):
+class ClientHandlerInterface(ABC):
     package_name: str = ''
 
     @classmethod

lsp_utils/_client_handler/interface.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
+
 from .download_file import download_file
 from .download_file import extract_archive
+from .logging import logger
 
 __all__ = [
     'download_file',
     'extract_archive',
+    'logger',
 ]

lsp_utils/_util/__init__.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
-from pathlib import Path
+
 from shutil import copyfileobj
-from urllib.request import HTTPError, urlopen
+from typing import TYPE_CHECKING
+from urllib.request import urlopen
 from zipfile import ZipFile
 import tarfile
 
+if TYPE_CHECKING:
+    from pathlib import Path
 
 __all__ = [
     'download_file',
@@ -14,12 +17,8 @@
 
 def download_file(url: str, target_path: Path) -> None:
     """Download given URL to the specified target file path."""
-    try:
-        with urlopen(url) as response, target_path.open('wb') as out_file:
-            copyfileobj(response, out_file)
-    except HTTPError as ex:
-        print(f'Failed downloading URL: {url}')
-        raise ex
+    with urlopen(url) as response, target_path.open('wb') as out_file:  # noqa: S310
+        copyfileobj(response, out_file)
 
 
 def extract_archive(archive_file: Path, target_directory: Path) -> Path:
@@ -39,16 +38,18 @@ def extract_archive(archive_file: Path, target_directory: Path) -> Path:
         with tarfile.open(archive_file, 'r:*') as archive:
             return extract_files_from_archive(archive, target_directory)
     else:
-        raise Exception(f'Unsupported archive "{archive_name}"')
+        msg = f'Unsupported archive "{archive_name}"'
+        raise Exception(msg)
 
 
 def extract_files_from_archive(archive: ZipFile | tarfile.TarFile, target_directory: Path) -> Path:
     names = archive.namelist() if isinstance(archive, ZipFile) else archive.getnames()
-    bad_members = [x for x in names if x.startswith('/') or x.startswith('..')]
+    bad_members = [x for x in names if x.startswith(('/', '..'))]
     if bad_members:
-        raise Exception(f'archive appears to be malicious, bad filenames: {bad_members}')
+        msg = f'archive appears to be malicious, bad filenames: {bad_members}'
+        raise Exception(msg)
     topdir_name = get_top_level_directory(names)
-    archive.extractall(str(target_directory))
+    archive.extractall(str(target_directory))  # noqa: S202
     if topdir_name:
         return target_directory / topdir_name
     return target_directory
@@ -57,9 +58,9 @@ def extract_files_from_archive(archive: ZipFile | tarfile.TarFile, target_direct
 def get_top_level_directory(names: list[str]) -> str | None:
     """
     Check if all files in a list are contained within a parent directory.
+
     Returns str | None: Common parent name if present.
     """
-
     # Filter out directory entries and get top-level paths.
     top_levels: set[str] = set()
     for name in names:

lsp_utils/_util/download_file.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+import logging
+
+__all__ = [
+    'logger',
+]
+
+logger = logging.getLogger(str(__package__).split('.')[0])
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter('[%(name)s] %(levelname)s: %(message)s'))
+logger.addHandler(handler)
+logger.setLevel(logging.DEBUG)