fix: fix default config

Author: observerw

LSP_Technical_Documentation.md

@@ -5,6 +5,9 @@
 
 from loguru import logger
 
+from lsp_client.capability.notification.did_change_configuration import (
+    WithNotifyDidChangeConfiguration,
+)
 from lsp_client.protocol import (
     CapabilityClientProtocol,
     ServerRequestHook,
@@ -27,7 +30,8 @@ class WithRespondConfigurationRequest(
     `workspace/configuration` - https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_configuration
     """
 
-    configuration_map: ConfigurationMap | None = None
+    def create_default_config(self) -> dict[str, Any] | None:
+        return
 
     @override
     @classmethod
@@ -54,14 +58,16 @@ def get_configuration(self, scope_uri: str | None, section: str | None) -> Any:
 
         Default implementation uses `self.configuration_map` if available.
         """
-        if self.configuration_map:
-            return self.configuration_map.get(scope_uri, section)
-        return None
+
+        if not (config := self.get_config_map()):
+            return
+        return config.get(scope_uri, section)
 
     async def _respond_configuration(
         self, params: lsp_type.ConfigurationParams
     ) -> list[Any]:
         logger.debug("Responding to configuration request")
+
         return [
             self.get_configuration(item.scope_uri, item.section)
             for item in params.items
@@ -81,24 +87,17 @@ def register_server_request_hooks(
     ) -> None:
         super().register_server_request_hooks(registry)
 
-        # Automatically bind change notification if both capabilities are present
-        from lsp_client.capability.notification.did_change_configuration import (
-            WithNotifyDidChangeConfiguration,
-        )
-
-        if self.configuration_map and isinstance(
-            self, WithNotifyDidChangeConfiguration
-        ):
-            # We use a lambda to avoid sync/async issues if the notification
-            # needs to be scheduled on an event loop
-            import asyncer
+        # Notify server when configuration changes
+        if isinstance(self, WithNotifyDidChangeConfiguration):
 
-            def on_config_change(config_map: ConfigurationMap, **kwargs: Any):
+            async def notify_change(config_map: ConfigurationMap) -> None:
                 with logger.contextualize(method="didChangeConfiguration"):
-                    logger.debug("Configuration changed, notifying server")
-                    asyncer.runnify(self.notify_change_configuration)()
+                    logger.debug(
+                        "Configuration changed: {}, notifying server", config_map
+                    )
+                    await self.notify_change_configuration()
 
-            self.configuration_map.on_change(on_config_change)
+            self.get_config_map().on_change(notify_change)
 
         registry.register(
             lsp_type.WORKSPACE_CONFIGURATION,

examples/default_configuration.py

@@ -5,12 +5,12 @@
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager, suppress
 from pathlib import Path
-from typing import Literal, Self, override
+from typing import Any, Literal, Self, override
 
 import anyio
 import asyncer
 from anyio import AsyncContextManagerMixin
-from attrs import define, field
+from attrs import Factory, define, field
 from loguru import logger
 
 from lsp_client.capability.build import (
@@ -19,18 +19,14 @@
 )
 from lsp_client.capability.notification import WithNotifyTextDocumentSynchronize
 from lsp_client.client.buffer import LSPFileBuffer
-from lsp_client.client.lang import LanguageConfig
 from lsp_client.jsonrpc.convert import (
     notification_serialize,
     request_deserialize,
     request_serialize,
     response_deserialize,
     response_serialize,
 )
-from lsp_client.protocol import (
-    CapabilityClientProtocol,
-    CapabilityProtocol,
-)
+from lsp_client.protocol import CapabilityClientProtocol, CapabilityProtocol
 from lsp_client.server import DefaultServers, Server, ServerRuntimeError
 from lsp_client.server.types import ServerRequest
 from lsp_client.utils.channel import Receiver, channel
@@ -64,6 +60,7 @@ class Client(
     _server: Server = field(init=False)
     _workspace: Workspace = field(init=False)
     _buffer: LSPFileBuffer = field(factory=LSPFileBuffer, init=False)
+    _config: ConfigurationMap = Factory(ConfigurationMap)
 
     async def _iter_candidate_servers(self) -> AsyncGenerator[Server]:
         """
@@ -95,53 +92,25 @@ async def _iter_candidate_servers(self) -> AsyncGenerator[Server]:
     def get_workspace(self) -> Workspace:
         return self._workspace
 
+    @override
+    def get_config_map(self) -> ConfigurationMap:
+        return self._config
+
     def get_server(self) -> Server:
         return self._server
 
-    @abstractmethod
-    def get_language_config(self) -> LanguageConfig:
-        """Get language-specific configuration for this client."""
-
     @abstractmethod
     def create_default_servers(self) -> DefaultServers:
         """Create default servers for this client."""
 
+    def create_default_config(self) -> dict[str, Any] | None:
+        """Create default configuration map for this client."""
+        return
+
     @abstractmethod
     def check_server_compatibility(self, info: lsp_type.ServerInfo | None) -> None:
         """Check if the available server capabilities are compatible with the client."""
 
-    def create_default_configuration_map(self) -> ConfigurationMap | None:
-        """
-        Create default configuration map for this client.
-
-        This method can be overridden by subclasses to provide default configurations
-        that enable extra features like inlay hints, diagnostics, etc.
-
-        The base implementation returns None, meaning no default configuration.
-        Subclasses that support configuration should override this method to provide
-        sensible defaults that enable commonly-used features.
-
-        Returns:
-            ConfigurationMap with default settings, or None if no defaults are needed.
-
-        Example:
-            Override this method in a client subclass to provide defaults:
-
-            ```python
-            @override
-            def create_default_configuration_map(self) -> ConfigurationMap | None:
-                config_map = ConfigurationMap()
-                config_map.update_global({
-                    "myserver": {
-                        "inlayHints": {"enable": True},
-                        "diagnostics": {"enable": True},
-                    }
-                })
-                return config_map
-            ```
-        """
-        return None
-
     @override
     @asynccontextmanager
     async def open_files(self, *file_paths: AnyPath) -> AsyncGenerator[None]:
@@ -173,7 +142,6 @@ async def open_files(self, *file_paths: AnyPath) -> AsyncGenerator[None]:
                     tg.soonify(self.notify_text_document_closed)(item.file_path)
 
     @override
-    # @retry(stop=tenacity.stop_after_attempt(3), reraise=True)
     async def request[R](
         self,
         req: Request,
@@ -185,7 +153,6 @@ async def request[R](
             return response_deserialize(raw_resp, schema)
 
     @override
-    # @retry(stop=tenacity.stop_after_attempt(3), reraise=True)
     async def notify(self, msg: Notification) -> None:
         noti = notification_serialize(msg)
         with anyio.fail_after(self.request_timeout):
@@ -279,17 +246,8 @@ async def _run_server(
     async def __asynccontextmanager__(self) -> AsyncGenerator[Self]:
         self._workspace = format_workspace(self._workspace_arg)
 
-        # Initialize default configuration map if the client supports configuration
-        # and no configuration map has been set yet
-        from lsp_client.capability.server_request import WithRespondConfigurationRequest
-
-        if (
-            isinstance(self, WithRespondConfigurationRequest)
-            and self.configuration_map is None
-        ):
-            default_config = self.create_default_configuration_map()
-            if default_config is not None:
-                self.configuration_map = default_config
+        if init_config := self.create_default_config():
+            await self._config.update_global(init_config)
 
         async with (
             asyncer.create_task_group() as tg,

src/lsp_client/capability/server_request/configuration.py

@@ -4,37 +4,25 @@
 
 from .deno import DenoClient
 from .gopls import GoplsClient
-from .language_client import Language, LanguageClient
 from .pyrefly import PyreflyClient
 from .pyright import PyrightClient
 from .rust_analyzer import RustAnalyzerClient
 from .ty import TyClient
 from .typescript import TypescriptClient
 
-GoClient = GoplsClient
-PythonClient = PyrightClient
-RustClient = RustAnalyzerClient
-TypeScriptClient = TypescriptClient
-
-clients: Final = (
-    GoplsClient,
-    PyreflyClient,
-    PyrightClient,
-    RustAnalyzerClient,
-    DenoClient,
-    TypescriptClient,
-    TyClient,
-)
+clients: Final = {
+    "gopls": GoplsClient,
+    "pyrefly": PyreflyClient,
+    "pyright": PyrightClient,
+    "rust_analyzer": RustAnalyzerClient,
+    "deno": DenoClient,
+    "typescript": TypescriptClient,
+    "ty": TyClient,
+}
 
 __all__ = [
     "DenoClient",
-    "GoClient",
     "GoplsClient",
-    "Language",
-    "LanguageClient",
     "PyreflyClient",
-    "PythonClient",
-    "RustClient",
     "TyClient",
-    "TypeScriptClient",
 ]