chore: type improvements

Author: rchl

st4_py38/lsp_utils/_client_handler/abstract_plugin.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
-from .._util import weak_method
+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 functools import partial
 from LSP.plugin import AbstractPlugin
 from LSP.plugin import ClientConfig
@@ -16,58 +18,56 @@
 from LSP.plugin import WorkspaceFolder
 from LSP.plugin.core.rpc import method2attr
 from os import path
-from typing import Any, Callable, Dict, List, Optional, Tuple, TypedDict
-from weakref import ref
+from typing import Any, Callable
+from typing_extensions import override
+from weakref import WeakMethod, ref
 import sublime
 
 __all__ = ['ClientHandler']
 
-LanguagesDict = TypedDict('LanguagesDict', {
-    'document_selector': Optional[str],
-    'languageId': Optional[str],
-    'scopes': Optional[List[str]],
-    'syntaxes': Optional[List[str]],
-}, total=False)
-ApiNotificationHandler = Callable[[Any], None]
-ApiRequestHandler = Callable[[Any, Callable[[Any], None]], None]
-
 
 class ApiWrapper(ApiWrapperInterface):
     def __init__(self, plugin: 'ref[AbstractPlugin]'):
         self.__plugin = plugin
 
-    def __session(self) -> Optional[Session]:
+    def __session(self) -> Session | None:
         plugin = self.__plugin()
         return plugin.weaksession() if plugin else None
 
     # --- ApiWrapperInterface -----------------------------------------------------------------------------------------
 
+    @override
     def on_notification(self, method: str, handler: ApiNotificationHandler) -> None:
-        def handle_notification(weak_handler: ApiNotificationHandler, params: Any) -> None:
-            weak_handler(params)
+        def handle_notification(weak_handler: WeakMethod[ApiNotificationHandler], params: Any) -> None:
+            if handler := weak_handler():
+                handler(params)
 
         plugin = self.__plugin()
         if plugin:
-            setattr(plugin, method2attr(method), partial(handle_notification, weak_method(handler)))
+            setattr(plugin, method2attr(method), partial(handle_notification, WeakMethod(handler)))
 
+    @override
     def on_request(self, method: str, handler: ApiRequestHandler) -> None:
         def send_response(request_id: Any, result: Any) -> None:
             session = self.__session()
             if session:
                 session.send_response(Response(request_id, result))
 
-        def on_response(weak_handler: ApiRequestHandler, params: Any, request_id: Any) -> None:
-            weak_handler(params, lambda result: send_response(request_id, result))
+        def on_response(weak_handler: WeakMethod[ApiRequestHandler], params: Any, request_id: Any) -> None:
+            if handler := weak_handler():
+                handler(params, lambda result: send_response(request_id, result))
 
         plugin = self.__plugin()
         if plugin:
-            setattr(plugin, method2attr(method), partial(on_response, weak_method(handler)))
+            setattr(plugin, method2attr(method), partial(on_response, WeakMethod(handler)))
 
+    @override
     def send_notification(self, method: str, params: Any) -> None:
         session = self.__session()
         if session:
             session.send_notification(Notification(method, params))
 
+    @override
     def send_request(self, method: str, params: Any, handler: Callable[[Any, bool], None]) -> None:
         session = self.__session()
         if session:
@@ -77,41 +77,47 @@ def send_request(self, method: str, params: Any, handler: Callable[[Any, bool],
             handler(None, True)
 
 
-class ClientHandler(AbstractPlugin, ClientHandlerInterface):
+class ClientHandler(AbstractPlugin, ClientHandlerInterface, metaclass=ABCMeta):
     """
     The base class for creating an LSP plugin.
     """
 
     # --- AbstractPlugin handlers -------------------------------------------------------------------------------------
 
     @classmethod
+    @override
     def name(cls) -> str:
         return cls.get_displayed_name()
 
     @classmethod
-    def configuration(cls) -> Tuple[sublime.Settings, str]:
+    @override
+    def configuration(cls) -> tuple[sublime.Settings, str]:
         return cls.read_settings()
 
     @classmethod
-    def additional_variables(cls) -> Dict[str, str]:
+    @override
+    def additional_variables(cls) -> dict[str, str]:
         return cls.get_additional_variables()
 
     @classmethod
+    @override
     def needs_update_or_installation(cls) -> bool:
         if cls.manages_server():
             server = cls.get_server()
             return bool(server and server.needs_installation())
         return False
 
     @classmethod
+    @override
     def install_or_update(cls) -> None:
         server = cls.get_server()
         if server:
             server.install_or_update()
 
     @classmethod
+    @override
     def can_start(cls, window: sublime.Window, initiating_view: sublime.View,
-                  workspace_folders: List[WorkspaceFolder], configuration: ClientConfig) -> Optional[str]:
+                  workspace_folders: list[WorkspaceFolder], configuration: ClientConfig) -> str | None:
         if cls.manages_server():
             server = cls.get_server()
             if not server or server.get_status() == ServerStatus.ERROR:
@@ -127,8 +133,9 @@ def can_start(cls, window: sublime.Window, initiating_view: sublime.View,
         return None
 
     @classmethod
+    @override
     def on_pre_start(cls, window: sublime.Window, initiating_view: sublime.View,
-                     workspace_folders: List[WorkspaceFolder], configuration: ClientConfig) -> Optional[str]:
+                     workspace_folders: list[WorkspaceFolder], configuration: ClientConfig) -> str | None:
         extra_paths = cls.get_additional_paths()
         if extra_paths:
             original_path_raw = configuration.env.get('PATH') or ''
@@ -147,10 +154,12 @@ def on_pre_start(cls, window: sublime.Window, initiating_view: sublime.View,
     # --- ClientHandlerInterface --------------------------------------------------------------------------------------
 
     @classmethod
+    @override
     def setup(cls) -> None:
         register_plugin(cls)
 
     @classmethod
+    @override
     def cleanup(cls) -> None:
         unregister_plugin(cls)
 

st4_py38/lsp_utils/_client_handler/api_decorator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from ..api_wrapper_interface import ApiWrapperInterface
 from .interface import ClientHandlerInterface
-from typing import Any, Callable, List, Optional, TypeVar, Union
+from typing import Any, Callable, List, TypeVar, Union
 import inspect
 
 __all__ = [
@@ -73,7 +73,7 @@ def register_decorated_handlers(client_handler: ClientHandlerInterface, api: Api
     """
     for _, func in inspect.getmembers(client_handler, predicate=inspect.isroutine):
         for client_event, handler_mark in _HANDLER_MARKS.items():
-            message_methods: Optional[List[str]] = getattr(func, handler_mark, None)
+            message_methods: list[str] | None = getattr(func, handler_mark, None)
             if message_methods is None:
                 continue
 

st4_py38/lsp_utils/_client_handler/interface.py

@@ -6,14 +6,13 @@
 from LSP.plugin import ClientConfig
 from LSP.plugin import DottedDict
 from LSP.plugin import WorkspaceFolder
-from typing import Dict, List, Optional, Tuple
 import sublime
 
 __all__ = ['ClientHandlerInterface']
 
 
 class ClientHandlerInterface(metaclass=ABCMeta):
-    package_name = ''
+    package_name: str = ''
 
     @classmethod
     @abstractmethod
@@ -37,12 +36,12 @@ def package_storage(cls) -> str:
 
     @classmethod
     @abstractmethod
-    def get_additional_variables(cls) -> Dict[str, str]:
+    def get_additional_variables(cls) -> dict[str, str]:
         ...
 
     @classmethod
     @abstractmethod
-    def get_additional_paths(cls) -> List[str]:
+    def get_additional_paths(cls) -> list[str]:
         ...
 
     @classmethod
@@ -52,7 +51,7 @@ def manages_server(cls) -> bool:
 
     @classmethod
     @abstractmethod
-    def get_command(cls) -> List[str]:
+    def get_command(cls) -> list[str]:
         ...
 
     @classmethod
@@ -62,17 +61,17 @@ def binary_path(cls) -> str:
 
     @classmethod
     @abstractmethod
-    def get_server(cls) -> Optional[ServerResourceInterface]:
+    def get_server(cls) -> ServerResourceInterface | None:
         ...
 
     @classmethod
     @abstractmethod
-    def get_binary_arguments(cls) -> List[str]:
+    def get_binary_arguments(cls) -> list[str]:
         ...
 
     @classmethod
     @abstractmethod
-    def read_settings(cls) -> Tuple[sublime.Settings, str]:
+    def read_settings(cls) -> tuple[sublime.Settings, str]:
         ...
 
     @classmethod
@@ -86,9 +85,9 @@ def is_allowed_to_start(
         cls,
         window: sublime.Window,
         initiating_view: sublime.View,
-        workspace_folders: List[WorkspaceFolder],
+        workspace_folders: list[WorkspaceFolder],
         configuration: ClientConfig,
-    ) -> Optional[str]:
+    ) -> str | None:
         ...
 
     @abstractmethod

st4_py38/lsp_utils/_util/__init__.py

@@ -1,6 +1,4 @@
 from __future__ import annotations
-from .weak_method import weak_method
 
 __all__ = [
-    'weak_method',
 ]

st4_py38/lsp_utils/_util/weak_method.py

@@ -2,11 +2,15 @@
 from abc import ABCMeta, abstractmethod
 from typing import Any, Callable
 
-__all__ = ['ApiWrapperInterface']
+__all__ = [
+    'ApiWrapperInterface',
+    'ApiNotificationHandler',
+    'ApiRequestHandler',
+]
 
 
-NotificationHandler = Callable[[Any], None]
-RequestHandler = Callable[[Any, Callable[[Any], None]], None]
+ApiNotificationHandler = Callable[[Any], None]
+ApiRequestHandler = Callable[[Any, Callable[[Any], None]], None]
 
 
 class ApiWrapperInterface(metaclass=ABCMeta):
@@ -16,14 +20,14 @@ class ApiWrapperInterface(metaclass=ABCMeta):
     """
 
     @abstractmethod
-    def on_notification(self, method: str, handler: NotificationHandler) -> None:
+    def on_notification(self, method: str, handler: ApiNotificationHandler) -> None:
         """
         Registers a handler for given notification name. The handler will be called with optional params.
         """
         ...
 
     @abstractmethod
-    def on_request(self, method: str, handler: RequestHandler) -> None:
+    def on_request(self, method: str, handler: ApiRequestHandler) -> None:
         """
         Registers a handler for given request name. The handler will be called with two arguments - first the params
         sent with the request and second the function that must be used to respond to the request. The response