python-fragments 0.5__tar.gz → 0.8__tar.gz

{python_fragments-0.5 → python_fragments-0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fragments
-Version: 0.5
+Version: 0.8
 Summary: Modern HTML template rendering in Python
 Author-email: The Running Algorithm <services@therunningalgorithm.info>
 License: Proprietary
@@ -8,7 +8,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Provides-Extra: lsp
 Requires-Dist: basedpyright>=1.39.0; extra == "lsp"
-Requires-Dist: pygls>=2.0.0; extra == "lsp"
+Requires-Dist: lsprotocol>=2025.0.0; extra == "lsp"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.4.1; extra == "dev"
 

{python_fragments-0.5 → python_fragments-0.8}/fragments/ast_nodes.py

@@ -16,6 +16,7 @@ class ASTModule:
     __template__: str = "from fragments.html.elements import el, sequence, comment\n{}"
 
     def transpile(self, transpiled_start: int = 0) -> None:
+        """Build transpiled outputs for the module."""
         self.transpiled_start = transpiled_start
         transpiled_start += len(self.__template__) - 2
         for child in self.children:
@@ -26,9 +27,21 @@ class ASTModule:
         self.transpiled_content = self.__template__.format(children)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
+    def map_offset(self, offset: int) -> int | None:
+        for owner in self.children:
+            if owner.source_start < offset <= owner.source_end:
+                return owner.map_offset(offset)
+
+    def unmap_offset(self, offset: int) -> int | None:
+        for owner in self.children:
+            if owner.transpiled_start < offset <= owner.transpiled_end:
+                return owner.unmap_offset(offset)
+
 
 @dataclass(slots=True)
 class ASTPython:
+    """Build transpiled outputs for the vanilla Python code."""
+
     source_start: int = field(compare=False)
     source_end: int = field(compare=False)
     content: str
@@ -42,6 +55,20 @@ class ASTPython:
         self.transpiled_content = self.content
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
+    def map_offset(self, offset: int) -> int | None:
+        if self.source_start < offset <= self.source_end:
+            specific_offset = offset - self.source_start
+            return self.transpiled_start + specific_offset
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        if self.transpiled_start < offset <= self.transpiled_end:
+            specific_offset = offset - self.transpiled_start
+            return self.source_start + specific_offset
+
+        return None
+
 
 @dataclass(slots=True)
 class ASTFragment:
@@ -67,6 +94,20 @@ class ASTFragment:
         self.transpiled_content = self.__template__.format(",".join(child.transpiled_content for child in self.children))
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
+    def map_offset(self, offset: int) -> int | None:
+        for owner in self.children:
+            if owner.source_start < offset <= owner.source_end:
+                return owner.map_offset(offset)
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        for owner in self.children:
+            if owner.transpiled_start < offset <= owner.transpiled_end:
+                return owner.unmap_offset(offset)
+
+        return None
+
 
 @dataclass(slots=True)
 class ASTHTMLElement:
@@ -77,7 +118,7 @@ class ASTHTMLElement:
     attributes: dict[str, "ASTHTMLAttribute"]
     if_attribute: "ASTInterpolation | None"
     for_attribute: "ASTInterpolation | None"
-    children: Sequence["ASTHTMLElement | ASTHTMLText | ASTInterpolation"]
+    children: Sequence["ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation"]
     one_line: bool
 
     transpiled_content: str = field(init=False)
@@ -152,6 +193,40 @@ class ASTHTMLElement:
         self.transpiled_content = self.__component_template__.format(self.name, children, attributes)
         self.transpiled_end = start + len(self.transpiled_content)
 
+    def map_offset(self, offset: int) -> int | None:
+        for attribute in self.attributes.values():
+            if attribute.source_start < offset <= attribute.source_end:
+                return attribute.map_offset(offset)
+
+        for child in self.children:
+            if child.source_start < offset <= child.source_end:
+                return child.map_offset(offset)
+
+        if self.if_attribute is not None and self.if_attribute.source_start < offset <= self.if_attribute.source_end:
+            return self.if_attribute.map_offset(offset)
+
+        if self.for_attribute is not None and self.for_attribute.source_start < offset <= self.for_attribute.source_end:
+            return self.for_attribute.map_offset(offset)
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        for attribute in self.attributes.values():
+            if attribute.transpiled_start < offset <= attribute.transpiled_end:
+                return attribute.unmap_offset(offset)
+
+        for child in self.children:
+            if child.transpiled_start < offset <= child.transpiled_end:
+                return child.unmap_offset(offset)
+
+        if self.if_attribute is not None and self.if_attribute.transpiled_start < offset <= self.if_attribute.transpiled_end:
+            return self.if_attribute.unmap_offset(offset)
+
+        if self.for_attribute is not None and self.for_attribute.transpiled_start < offset <= self.for_attribute.transpiled_end:
+            return self.for_attribute.unmap_offset(offset)
+
+        return None
+
 
 @dataclass(slots=True)
 class ASTHTMLComment:
@@ -171,6 +246,12 @@ class ASTHTMLComment:
         self.transpiled_content = self.__template__.format(self.content)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
+    def map_offset(self, offset: int) -> None:
+        return None
+
+    def unmap_offset(self, offset: int) -> None:
+        return None
+
 
 @dataclass(slots=True)
 class ASTHTMLAttribute:
@@ -201,6 +282,24 @@ class ASTHTMLAttribute:
         self.transpiled_content = self.__interpolation_template__.format(self.name, self.interpolation.transpiled_content)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
+    def map_offset(self, offset: int) -> int | None:
+        if self.interpolation is None:
+            return None
+
+        if self.interpolation.source_start < offset <= self.interpolation.source_end:
+            return self.interpolation.map_offset(offset)
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        if self.interpolation is None:
+            return None
+
+        if self.interpolation.transpiled_start < offset <= self.interpolation.transpiled_end:
+            return self.interpolation.unmap_offset(offset)
+
+        return None
+
 
 @dataclass(slots=True)
 class ASTHTMLText:
@@ -220,18 +319,40 @@ class ASTHTMLText:
         self.transpiled_start = transpiled_start
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
+    def map_offset(self, offset: int) -> None:
+        return None
+
+    def unmap_offset(self, offset: int) -> None:
+        return None
+
 
 @dataclass(slots=True)
 class ASTInterpolation:
     source_start: int = field(compare=False)
     source_end: int = field(compare=False)
     expression: str
+    leading_whitespace: int
+    trailing_whitespace: int
 
     transpiled_content: str = field(init=False)
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
     def transpile(self, transpiled_start: int) -> None:
-        self.transpiled_content = self.expression
+        self.transpiled_content = self.expression.strip()
         self.transpiled_start = transpiled_start
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
+
+    def map_offset(self, offset: int) -> int | None:
+        if self.source_start + 2 + self.leading_whitespace < offset <= self.source_end - 2 - self.trailing_whitespace:
+            specific_offset = offset - self.source_start - 2 - self.leading_whitespace
+            return self.transpiled_start + specific_offset
+
+        return None
+
+    def unmap_offset(self, offset: int) -> int | None:
+        if self.transpiled_start < offset <= self.transpiled_end:
+            specific_offset = offset - self.transpiled_start
+            return self.source_start + specific_offset + 2 + self.leading_whitespace
+
+        return None

{python_fragments-0.5 → python_fragments-0.8}/fragments/grammar.py

@@ -7,7 +7,6 @@ from fragments.source import Source
 PYTHON = r"([\s\S]*?)(?=<>)|[\s\S]*$"
 IDENTIFIER = r"[a-zA-Z_][a-zA-Z0-9_]*"
 STRING_CONTENTS = r"(.*?)(?=\")"
-INTERPOLATION_EXPRESSION = r"(.*?)(?= }})"
 HTML_IDENTIFIER = r"[a-zA-Z][a-zA-Z0-9_-]*"
 HTML_TEXT = r"(.*?)(?=<)"
 
@@ -190,13 +189,14 @@ def expect_html_element(source: Source) -> tuple[Source, ASTHTMLElement]:
 
 def expect_interpolation(source: Source) -> tuple[Source, ASTInterpolation]:
     """An interpolation block."""
+    INTERPOLATION_EXPRESSION = r"([\s\S]*?)(?= }})"
     source_start = source.offset
     source = expect_string(source, "{{")
-    source, _ = source.eat_whitespace()
+    source, leading_whitespace = source.eat_whitespace()
     source, expression = expect_regex(source, INTERPOLATION_EXPRESSION, "expression")
-    source, _ = source.eat_whitespace()
+    source, trailing_whitespace = source.eat_whitespace()
     source = expect_string(source, "}}")
-    return source, ASTInterpolation(source_start, source.offset, expression)
+    return source, ASTInterpolation(source_start, source.offset, expression, len(leading_whitespace), len(trailing_whitespace))
 
 
 def expect_html_text(source: Source) -> tuple[Source, ASTHTMLText]:

python_fragments-0.8/fragments/lsp/based_proxy.py

@@ -0,0 +1,130 @@
+from asyncio.streams import StreamReader
+from asyncio.transports import WriteTransport
+import asyncio
+import os
+import sys
+from asyncio.subprocess import Process
+from typing import Callable
+from lsprotocol import types
+from fragments.lsp.file_state import FileState
+from fragments.lsp.message_queue import MessageQueue
+from fragments.lsp.types import HandlerFunc
+
+_PYRIGHT_PROCESS: Process | None = None
+_PYRIGHT: "MessageQueue | None" = None
+_PYRIGHT_HANDLERS: dict[str, HandlerFunc] = {}
+_PROXY: "MessageQueue | None" = None
+_PROXY_HANDLERS: dict[str, HandlerFunc] = {}
+
+FILE_STATES: dict[str, FileState] = {}
+PARSE_ERRORS: dict[str, types.Diagnostic | None] = {}
+
+
+def pyright() -> MessageQueue:
+    global _PYRIGHT
+    assert _PYRIGHT is not None
+    return _PYRIGHT
+
+
+def proxy() -> MessageQueue:
+    global _PROXY
+    assert _PROXY is not None
+    return _PROXY
+
+
+def handle_from_client(method: str) -> Callable[[HandlerFunc], HandlerFunc]:
+    """Register a function to handle messages from the client."""
+
+    def decorator(func: HandlerFunc) -> HandlerFunc:
+        _PROXY_HANDLERS[method] = func
+        return func
+
+    return decorator
+
+
+def handle_from_pyright(method: str) -> Callable[[HandlerFunc], HandlerFunc]:
+    """Register a function to handle messages from pyright."""
+
+    def decorator(func: HandlerFunc) -> HandlerFunc:
+        _PYRIGHT_HANDLERS[method] = func
+        return func
+
+    return decorator
+
+
+async def stop() -> None:
+    global _PYRIGHT_PROCESS
+    if _PYRIGHT_PROCESS is None:
+        return
+
+    _PYRIGHT_PROCESS.terminate()
+    try:
+        await asyncio.wait_for(_PYRIGHT_PROCESS.wait(), timeout=5.0)
+    except asyncio.TimeoutError:
+        _PYRIGHT_PROCESS.kill()
+    _PYRIGHT_PROCESS = None
+
+
+async def start() -> None:
+    global _PYRIGHT_PROCESS, _PYRIGHT, _PROXY
+
+    loop: asyncio.AbstractEventLoop = asyncio.get_running_loop()
+
+    reader: asyncio.StreamReader = asyncio.StreamReader()
+    await loop.connect_read_pipe(lambda: asyncio.StreamReaderProtocol(reader), sys.stdin.buffer)
+    stdin: StreamReader = reader
+    transport, _ = await loop.connect_write_pipe(lambda: asyncio.BaseProtocol(), sys.stdout.buffer)
+    stdout: WriteTransport = transport
+    _PROXY = MessageQueue(stdin, stdout, _PROXY_HANDLERS)
+
+    bin_directory: str = os.path.dirname(sys.executable)
+    environment: dict[str, str] = dict[str, str](os.environ)
+    if sys.prefix != sys.base_prefix:
+        environment["VIRTUAL_ENV"] = sys.prefix
+
+    _PYRIGHT_PROCESS = await asyncio.create_subprocess_exec(
+        os.path.join(bin_directory, "basedpyright-langserver"),
+        "--stdio",
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=sys.stderr.buffer,
+        env=environment,
+    )
+    pyright_stdin = _PYRIGHT_PROCESS.stdin
+    pyright_stdout = _PYRIGHT_PROCESS.stdout
+    assert pyright_stdin is not None
+    assert pyright_stdout is not None
+
+    _PYRIGHT = MessageQueue(pyright_stdout, pyright_stdin, _PYRIGHT_HANDLERS)
+
+    pyright_task = asyncio.create_task(_PYRIGHT.read_loop())
+    await _PROXY.read_loop()
+    await stop()
+    pyright_task.cancel()
+
+
+def main() -> None:
+    import asyncio
+    from fragments.lsp.client_message_handlers import (  # noqa: F401
+        completion,
+        definition,
+        diagnostics,
+        document_highlight,
+        document_symbols,
+        folding_range,
+        hover,
+        inlay_hints,
+        lifecycle,
+        references,
+        rename,
+        semantic_tokens,
+        signature_help,
+        code_actions,
+    )
+    from fragments.lsp.pyright_notification_handlers import (  # noqa: F401
+        capability,
+        configuration,
+        diagnostics as pyright_diagnostics,
+    )
+
+    asyncio.run(start())

python_fragments-0.8/fragments/lsp/client_message_handlers/code_actions.py

@@ -0,0 +1,34 @@
+from lsprotocol import types
+from lsprotocol.types import REQUESTS, NOTIFICATIONS
+from typing import cast
+from fragments.lsp import based_proxy
+from fragments.lsp.based_proxy import handle_from_client
+
+
+@handle_from_client(types.TEXT_DOCUMENT_CODE_ACTION)
+async def code_action(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.CodeActionRequest, message)
+    original_id = request.id
+    file_state = based_proxy.FILE_STATES.get(request.params.text_document.uri)
+
+    if file_state is None or file_state.vanilla:
+        based_proxy.proxy().respond(original_id, await based_proxy.pyright().request(request))
+        return
+
+    mapped_range = file_state.map_range(request.params.range)
+    if mapped_range is None:
+        based_proxy.proxy().respond(original_id, types.CodeActionResponse(id=original_id, result=[]))
+        return
+
+    request.params.range = mapped_range
+    response = cast(types.CodeActionResponse, await based_proxy.pyright().request(request))
+
+    for action in response.result or []:
+        if isinstance(action, types.CodeAction) and action.edit is not None:
+            for change in action.edit.document_changes or []:
+                if isinstance(change, types.TextDocumentEdit) and (state := based_proxy.FILE_STATES.get(change.text_document.uri)):
+                    for edit in change.edits:
+                        if not isinstance(edit, types.SnippetTextEdit) and (r := state.unmap_range(edit.range)) is not None:
+                            edit.range = r
+
+    based_proxy.proxy().respond(original_id, response)

python_fragments-0.8/fragments/lsp/client_message_handlers/completion.py

@@ -0,0 +1,54 @@
+from lsprotocol import types
+from lsprotocol.types import REQUESTS, NOTIFICATIONS
+from typing import cast
+from fragments.lsp import based_proxy
+from fragments.lsp.based_proxy import handle_from_client
+from fragments.lsp.file_state import FileState
+
+
+def _remap_item(item: types.CompletionItem, file_state: FileState) -> bool:
+    if isinstance(item.text_edit, types.InsertReplaceEdit):
+        insert = file_state.unmap_range(item.text_edit.insert)
+        replace = file_state.unmap_range(item.text_edit.replace)
+        if insert is None or replace is None:
+            return False
+        item.text_edit.insert, item.text_edit.replace = insert, replace
+    elif item.text_edit is not None:
+        if (r := file_state.unmap_range(item.text_edit.range)) is None:
+            return False
+        item.text_edit.range = r
+    if item.additional_text_edits:
+        remapped_edits = []
+        for edit in item.additional_text_edits:
+            if (r := file_state.unmap_range(edit.range)) is not None:
+                edit.range = r
+                remapped_edits.append(edit)
+        item.additional_text_edits = remapped_edits
+    return True
+
+
+@handle_from_client(types.TEXT_DOCUMENT_COMPLETION)
+async def completion(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.CompletionRequest, message)
+    original_id = request.id
+    file_state = based_proxy.FILE_STATES.get(request.params.text_document.uri)
+
+    if file_state is None or file_state.vanilla:
+        based_proxy.proxy().respond(original_id, await based_proxy.pyright().request(request))
+        return
+
+    if (mapped := file_state.map_position(request.params.position)) is None:
+        return
+    request.params.position = mapped
+
+    response = cast(types.CompletionResponse, await based_proxy.pyright().request(request))
+    items = response.result.items if isinstance(response.result, types.CompletionList) else list(response.result or [])
+    remapped = [item for item in items if _remap_item(item, file_state)]
+    response.result = remapped
+    based_proxy.proxy().respond(original_id, response)
+
+
+@handle_from_client(types.COMPLETION_ITEM_RESOLVE)
+async def completion_item_resolve(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.CompletionResolveRequest, message)
+    based_proxy.proxy().respond(request.id, cast(types.CompletionResolveResponse, await based_proxy.pyright().request(request)))

python_fragments-0.8/fragments/lsp/client_message_handlers/definition.py

@@ -0,0 +1,44 @@
+from lsprotocol import types
+from lsprotocol.types import REQUESTS, NOTIFICATIONS
+from typing import cast
+from fragments.lsp import based_proxy
+from fragments.lsp.based_proxy import handle_from_client
+
+
+@handle_from_client(types.TEXT_DOCUMENT_DEFINITION)
+async def definition(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.DefinitionRequest, message)
+    original_id = request.id
+    file_state = based_proxy.FILE_STATES.get(request.params.text_document.uri)
+
+    if file_state is None or file_state.vanilla:
+        based_proxy.proxy().respond(original_id, await based_proxy.pyright().request(request))
+        return
+
+    mapped_position = file_state.map_position(request.params.position)
+    if mapped_position is None:
+        based_proxy.proxy().respond(original_id, types.DefinitionResponse(id=original_id, result=None))
+        return
+
+    request.params.position = mapped_position
+    response = cast(types.DefinitionResponse, await based_proxy.pyright().request(request))
+
+    if isinstance(response.result, list):
+        remapped: list[types.Location] = []
+        for location in cast(list[types.Location], response.result):
+            target_state = based_proxy.FILE_STATES.get(location.uri)
+            if target_state is not None:
+                new_range = target_state.unmap_range(location.range)
+                if new_range is None:
+                    continue
+                location.range = new_range
+            remapped.append(location)
+        response.result = remapped
+    elif isinstance(response.result, types.Location):
+        target_state = based_proxy.FILE_STATES.get(response.result.uri)
+        if target_state is not None:
+            new_range = target_state.unmap_range(response.result.range)
+            if new_range is not None:
+                response.result.range = new_range
+
+    based_proxy.proxy().respond(original_id, response)

python_fragments-0.8/fragments/lsp/client_message_handlers/diagnostics.py

@@ -0,0 +1,45 @@
+from lsprotocol import types
+from lsprotocol.types import REQUESTS, NOTIFICATIONS
+from typing import cast
+from fragments.lsp import based_proxy
+from fragments.lsp.based_proxy import handle_from_client
+
+
+@handle_from_client(types.TEXT_DOCUMENT_DIAGNOSTIC)
+async def text_document_diagnostic(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.DocumentDiagnosticRequest, message)
+    original_id = request.id
+    uri = request.params.text_document.uri
+    parse_error = based_proxy.PARSE_ERRORS.get(uri)
+    file_state = based_proxy.FILE_STATES.get(uri)
+
+    if parse_error is not None:
+        based_proxy.proxy().respond(
+            original_id,
+            types.DocumentDiagnosticResponse(
+                id=original_id,
+                result=types.RelatedFullDocumentDiagnosticReport(kind="full", items=[parse_error]),
+            ),
+        )
+        return
+
+    response = cast(types.DocumentDiagnosticResponse, await based_proxy.pyright().request(request))
+
+    if file_state is None or file_state.vanilla or response.result is None:
+        based_proxy.proxy().respond(original_id, response)
+        return
+
+    if isinstance(response.result, types.RelatedUnchangedDocumentDiagnosticReport):
+        based_proxy.proxy().respond(original_id, response)
+        return
+
+    remapped_items: list[types.Diagnostic] = []
+    for diagnostic in response.result.items or []:
+        remapped_range = file_state.unmap_range(diagnostic.range)
+        if remapped_range is None:
+            continue
+        diagnostic.range = remapped_range
+        remapped_items.append(diagnostic)
+
+    response.result.items = remapped_items
+    based_proxy.proxy().respond(original_id, response)

python_fragments-0.8/fragments/lsp/client_message_handlers/document_highlight.py

@@ -0,0 +1,36 @@
+from lsprotocol import types
+from lsprotocol.types import REQUESTS, NOTIFICATIONS
+from typing import cast
+from fragments.lsp import based_proxy
+from fragments.lsp.based_proxy import handle_from_client
+
+
+@handle_from_client(types.TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT)
+async def document_highlight(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.DocumentHighlightRequest, message)
+    original_id = request.id
+    file_state = based_proxy.FILE_STATES.get(request.params.text_document.uri)
+
+    if file_state is None or file_state.vanilla:
+        based_proxy.proxy().respond(original_id, await based_proxy.pyright().request(request))
+        return
+
+    mapped_position = file_state.map_position(request.params.position)
+    if mapped_position is None:
+        based_proxy.proxy().respond(original_id, types.DocumentHighlightResponse(id=original_id, result=None))
+        return
+
+    request.params.position = mapped_position
+    response = cast(types.DocumentHighlightResponse, await based_proxy.pyright().request(request))
+
+    if response.result:
+        remapped: list[types.DocumentHighlight] = []
+        for highlight in response.result:
+            new_range = file_state.unmap_range(highlight.range)
+            if new_range is None:
+                continue
+            highlight.range = new_range
+            remapped.append(highlight)
+        response.result = remapped
+
+    based_proxy.proxy().respond(original_id, response)

python_fragments-0.8/fragments/lsp/client_message_handlers/document_symbols.py

@@ -0,0 +1,52 @@
+from lsprotocol import types
+from lsprotocol.types import REQUESTS, NOTIFICATIONS
+from typing import cast
+from fragments.lsp import based_proxy
+from fragments.lsp.based_proxy import handle_from_client
+from fragments.lsp.file_state import FileState
+
+
+def _remap_document_symbols(symbols: list[types.DocumentSymbol], file_state: FileState) -> list[types.DocumentSymbol]:
+    remapped: list[types.DocumentSymbol] = []
+    for symbol in symbols:
+        new_range = file_state.unmap_range(symbol.range)
+        new_selection_range = file_state.unmap_range(symbol.selection_range)
+        if new_range is None or new_selection_range is None:
+            continue
+        symbol.range = new_range
+        symbol.selection_range = new_selection_range
+        if symbol.children:
+            symbol.children = _remap_document_symbols(list(symbol.children), file_state)
+        remapped.append(symbol)
+    return remapped
+
+
+@handle_from_client(types.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+async def document_symbol(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.DocumentSymbolRequest, message)
+    original_id = request.id
+    file_state = based_proxy.FILE_STATES.get(request.params.text_document.uri)
+
+    if file_state is None or file_state.vanilla:
+        based_proxy.proxy().respond(original_id, await based_proxy.pyright().request(request))
+        return
+
+    response = cast(types.DocumentSymbolResponse, await based_proxy.pyright().request(request))
+
+    if not response.result:
+        based_proxy.proxy().respond(original_id, response)
+        return
+
+    if isinstance(response.result[0], types.SymbolInformation):
+        remapped_info: list[types.SymbolInformation] = []
+        for symbol in cast(list[types.SymbolInformation], response.result):
+            new_range = file_state.unmap_range(symbol.location.range)
+            if new_range is None:
+                continue
+            symbol.location.range = new_range
+            remapped_info.append(symbol)
+        response.result = remapped_info
+    else:
+        response.result = _remap_document_symbols(cast(list[types.DocumentSymbol], response.result), file_state)
+
+    based_proxy.proxy().respond(original_id, response)

python_fragments-0.8/fragments/lsp/client_message_handlers/folding_range.py

@@ -0,0 +1,11 @@
+from lsprotocol import types
+from lsprotocol.types import REQUESTS, NOTIFICATIONS
+from typing import cast
+from fragments.lsp import based_proxy
+from fragments.lsp.based_proxy import handle_from_client
+
+
+@handle_from_client(types.TEXT_DOCUMENT_FOLDING_RANGE)
+async def folding_range(message: REQUESTS | NOTIFICATIONS) -> None:
+    request = cast(types.FoldingRangeRequest, message)
+    based_proxy.proxy().respond(request.id, cast(types.FoldingRangeResponse, await based_proxy.pyright().request(request)))