jaclang 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

jaclang/vendor/pygls/client.py

@@ -0,0 +1,176 @@
+############################################################################
+# Copyright(c) Open Law Library. All rights reserved.                      #
+# See ThirdPartyNotices.txt in the project root for additional notices.    #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+import asyncio
+import logging
+import re
+from threading import Event
+from typing import Any
+from typing import Callable
+from typing import List
+from typing import Optional
+from typing import Type
+from typing import Union
+
+from cattrs import Converter
+
+from jaclang.vendor.pygls.exceptions import PyglsError, JsonRpcException
+from jaclang.vendor.pygls.protocol import JsonRPCProtocol, default_converter
+
+
+logger = logging.getLogger(__name__)
+
+
+async def aio_readline(stop_event, reader, message_handler):
+    CONTENT_LENGTH_PATTERN = re.compile(rb"^Content-Length: (\d+)\r\n$")
+
+    # Initialize message buffer
+    message = []
+    content_length = 0
+
+    while not stop_event.is_set():
+        # Read a header line
+        header = await reader.readline()
+        if not header:
+            break
+        message.append(header)
+
+        # Extract content length if possible
+        if not content_length:
+            match = CONTENT_LENGTH_PATTERN.fullmatch(header)
+            if match:
+                content_length = int(match.group(1))
+                logger.debug("Content length: %s", content_length)
+
+        # Check if all headers have been read (as indicated by an empty line \r\n)
+        if content_length and not header.strip():
+            # Read body
+            body = await reader.readexactly(content_length)
+            if not body:
+                break
+            message.append(body)
+
+            # Pass message to protocol
+            message_handler(b"".join(message))
+
+            # Reset the buffer
+            message = []
+            content_length = 0
+
+
+class JsonRPCClient:
+    """Base JSON-RPC client."""
+
+    def __init__(
+        self,
+        protocol_cls: Type[JsonRPCProtocol] = JsonRPCProtocol,
+        converter_factory: Callable[[], Converter] = default_converter,
+    ):
+        # Strictly speaking `JsonRPCProtocol` wants a `LanguageServer`, not a
+        # `JsonRPCClient`. However there similar enough for our purposes, which is
+        # that this client will mostly be used in testing contexts.
+        self.protocol = protocol_cls(self, converter_factory())  # type: ignore
+
+        self._server: Optional[asyncio.subprocess.Process] = None
+        self._stop_event = Event()
+        self._async_tasks: List[asyncio.Task] = []
+
+    @property
+    def stopped(self) -> bool:
+        """Return ``True`` if the client has been stopped."""
+        return self._stop_event.is_set()
+
+    def feature(
+        self,
+        feature_name: str,
+        options: Optional[Any] = None,
+    ):
+        """Decorator used to register LSP features.
+
+        Example
+        -------
+        ::
+
+           import logging
+           from jaclang.vendor.pygls.client import JsonRPCClient
+
+           ls = JsonRPCClient()
+
+           @ls.feature('window/logMessage')
+           def completions(ls, params):
+               logging.info("%s", params.message)
+        """
+        return self.protocol.fm.feature(feature_name, options)
+
+    async def start_io(self, cmd: str, *args, **kwargs):
+        """Start the given server and communicate with it over stdio."""
+
+        logger.debug("Starting server process: %s", " ".join([cmd, *args]))
+        server = await asyncio.create_subprocess_exec(
+            cmd,
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stdin=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            **kwargs,
+        )
+
+        self.protocol.connection_made(server.stdin)  # type: ignore
+        connection = asyncio.create_task(
+            aio_readline(self._stop_event, server.stdout, self.protocol.data_received)
+        )
+        notify_exit = asyncio.create_task(self._server_exit())
+
+        self._server = server
+        self._async_tasks.extend([connection, notify_exit])
+
+    async def _server_exit(self):
+        if self._server is not None:
+            await self._server.wait()
+            logger.debug(
+                "Server process %s exited with return code: %s",
+                self._server.pid,
+                self._server.returncode,
+            )
+            await self.server_exit(self._server)
+            self._stop_event.set()
+
+    async def server_exit(self, server: asyncio.subprocess.Process):
+        """Called when the server process exits."""
+
+    def _report_server_error(
+        self, error: Exception, source: Union[PyglsError, JsonRpcException]
+    ):
+        try:
+            self.report_server_error(error, source)
+        except Exception:
+            logger.error("Unable to report error", exc_info=True)
+
+    def report_server_error(
+        self, error: Exception, source: Union[PyglsError, JsonRpcException]
+    ):
+        """Called when the server does something unexpected e.g. respond with malformed
+        JSON."""
+
+    async def stop(self):
+        self._stop_event.set()
+
+        if self._server is not None and self._server.returncode is None:
+            logger.debug("Terminating server process: %s", self._server.pid)
+            self._server.terminate()
+
+        if len(self._async_tasks) > 0:
+            await asyncio.gather(*self._async_tasks)

jaclang/vendor/pygls/constants.py

@@ -0,0 +1,26 @@
+############################################################################
+# Copyright(c) Open Law Library. All rights reserved.                      #
+# See ThirdPartyNotices.txt in the project root for additional notices.    #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+
+# Dynamically assigned attributes
+ATTR_EXECUTE_IN_THREAD = "execute_in_thread"
+ATTR_COMMAND_TYPE = "command"
+ATTR_FEATURE_TYPE = "feature"
+ATTR_REGISTERED_NAME = "reg_name"
+ATTR_REGISTERED_TYPE = "reg_type"
+
+# Parameters
+PARAM_LS = "ls"

jaclang/vendor/pygls/exceptions.py

@@ -0,0 +1,220 @@
+############################################################################
+# Original work Copyright 2018 Palantir Technologies, Inc.                 #
+# Original work licensed under the MIT License.                            #
+# See ThirdPartyNotices.txt in the project root for license information.   #
+# All modifications Copyright (c) Open Law Library. All rights reserved.   #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+import traceback
+from typing import Set
+from typing import Type
+
+
+class JsonRpcException(Exception):
+    """A class used as a base class for json rpc exceptions."""
+
+    def __init__(self, message=None, code=None, data=None):
+        message = message or getattr(self.__class__, "MESSAGE")
+        super().__init__(message)
+        self.message = message
+        self.code = code or getattr(self.__class__, "CODE")
+        self.data = data
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, self.__class__)
+            and self.code == other.code
+            and self.message == other.message
+        )
+
+    def __hash__(self):
+        return hash((self.code, self.message))
+
+    @staticmethod
+    def from_error(error):
+        for exc_class in _EXCEPTIONS:
+            if exc_class.supports_code(error.code):
+                return exc_class(
+                    code=error.code, message=error.message, data=error.data
+                )
+
+        return JsonRpcException(code=error.code, message=error.message, data=error.data)
+
+    @classmethod
+    def supports_code(cls, code):
+        # Defaults to UnknownErrorCode
+        return getattr(cls, "CODE", -32001) == code
+
+    def to_dict(self):
+        exception_dict = {
+            "code": self.code,
+            "message": self.message,
+        }
+        if self.data is not None:
+            exception_dict["data"] = str(self.data)
+        return exception_dict
+
+
+class JsonRpcInternalError(JsonRpcException):
+    CODE = -32603
+    MESSAGE = "Internal Error"
+
+    @classmethod
+    def of(cls, exc_info):
+        exc_type, exc_value, exc_tb = exc_info
+        return cls(
+            message="".join(
+                traceback.format_exception_only(exc_type, exc_value)
+            ).strip(),
+            data={"traceback": traceback.format_tb(exc_tb)},
+        )
+
+
+class JsonRpcInvalidParams(JsonRpcException):
+    CODE = -32602
+    MESSAGE = "Invalid Params"
+
+
+class JsonRpcInvalidRequest(JsonRpcException):
+    CODE = -32600
+    MESSAGE = "Invalid Request"
+
+
+class JsonRpcMethodNotFound(JsonRpcException):
+    CODE = -32601
+    MESSAGE = "Method Not Found"
+
+    @classmethod
+    def of(cls, method):
+        return cls(message=cls.MESSAGE + ": " + method)
+
+
+class JsonRpcParseError(JsonRpcException):
+    CODE = -32700
+    MESSAGE = "Parse Error"
+
+
+class JsonRpcRequestCancelled(JsonRpcException):
+    CODE = -32800
+    MESSAGE = "Request Cancelled"
+
+
+class JsonRpcContentModified(JsonRpcException):
+    CODE = -32801
+    MESSAGE = "Content Modified"
+
+
+class JsonRpcServerNotInitialized(JsonRpcException):
+    CODE = -32002
+    MESSAGE = "ServerNotInitialized"
+
+
+class JsonRpcUnknownErrorCode(JsonRpcException):
+    CODE = -32001
+    MESSAGE = "UnknownErrorCode"
+
+
+class JsonRpcReservedErrorRangeStart(JsonRpcException):
+    CODE = -32099
+    MESSAGE = "jsonrpcReservedErrorRangeStart"
+
+
+class JsonRpcReservedErrorRangeEnd(JsonRpcException):
+    CODE = -32000
+    MESSAGE = "jsonrpcReservedErrorRangeEnd"
+
+
+class LspReservedErrorRangeStart(JsonRpcException):
+    CODE = -32899
+    MESSAGE = "lspReservedErrorRangeStart"
+
+
+class LspReservedErrorRangeEnd(JsonRpcException):
+    CODE = -32800
+    MESSAGE = "lspReservedErrorRangeEnd"
+
+
+class JsonRpcServerError(JsonRpcException):
+    def __init__(self, message, code, data=None):
+        if not _is_server_error_code(code):
+            raise ValueError("Error code should be in range -32099 - -32000")
+        super().__init__(message=message, code=code, data=data)
+
+    @classmethod
+    def supports_code(cls, code):
+        return _is_server_error_code(code)
+
+
+def _is_server_error_code(code):
+    return -32099 <= code <= -32000
+
+
+_EXCEPTIONS: Set[Type[JsonRpcException]] = {
+    JsonRpcInternalError,
+    JsonRpcInvalidParams,
+    JsonRpcInvalidRequest,
+    JsonRpcMethodNotFound,
+    JsonRpcParseError,
+    JsonRpcRequestCancelled,
+    JsonRpcServerError,
+}
+
+
+class PyglsError(Exception):
+    pass
+
+
+class CommandAlreadyRegisteredError(PyglsError):
+    def __init__(self, command_name):
+        self.command_name = command_name
+
+    def __repr__(self):
+        return f'Command "{self.command_name}" is already registered.'
+
+
+class FeatureAlreadyRegisteredError(PyglsError):
+    def __init__(self, feature_name):
+        self.feature_name = feature_name
+
+    def __repr__(self):
+        return f'Feature "{self.feature_name}" is already registered.'
+
+
+class FeatureRequestError(PyglsError):
+    pass
+
+
+class FeatureNotificationError(PyglsError):
+    pass
+
+
+class MethodTypeNotRegisteredError(PyglsError):
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return f'"{self.name}" is not added to `pygls.lsp.LSP_METHODS_MAP`.'
+
+
+class ThreadDecoratorError(PyglsError):
+    pass
+
+
+class ValidationError(PyglsError):
+    def __init__(self, errors=None):
+        self.errors = errors or []
+
+    def __repr__(self):
+        opt_errs = "\n-".join([e for e in self.errors])
+        return f"Missing options: {opt_errs}"

jaclang/vendor/pygls/feature_manager.py

@@ -0,0 +1,241 @@
+############################################################################
+# Copyright(c) Open Law Library. All rights reserved.                      #
+# See ThirdPartyNotices.txt in the project root for additional notices.    #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+import asyncio
+import functools
+import inspect
+import itertools
+import logging
+from typing import Any, Callable, Dict, Optional, get_type_hints
+
+from jaclang.vendor.pygls.constants import (
+    ATTR_COMMAND_TYPE,
+    ATTR_EXECUTE_IN_THREAD,
+    ATTR_FEATURE_TYPE,
+    ATTR_REGISTERED_NAME,
+    ATTR_REGISTERED_TYPE,
+    PARAM_LS,
+)
+from jaclang.vendor.pygls.exceptions import (
+    CommandAlreadyRegisteredError,
+    FeatureAlreadyRegisteredError,
+    ThreadDecoratorError,
+    ValidationError,
+)
+from jaclang.vendor.pygls.lsp import get_method_options_type, is_instance
+
+logger = logging.getLogger(__name__)
+
+
+def assign_help_attrs(f, reg_name, reg_type):
+    setattr(f, ATTR_REGISTERED_NAME, reg_name)
+    setattr(f, ATTR_REGISTERED_TYPE, reg_type)
+
+
+def assign_thread_attr(f):
+    setattr(f, ATTR_EXECUTE_IN_THREAD, True)
+
+
+def get_help_attrs(f):
+    return getattr(f, ATTR_REGISTERED_NAME, None), getattr(
+        f, ATTR_REGISTERED_TYPE, None
+    )
+
+
+def has_ls_param_or_annotation(f, annotation):
+    """Returns true if callable has first parameter named `ls` or type of
+    annotation"""
+    try:
+        sig = inspect.signature(f)
+        first_p = next(itertools.islice(sig.parameters.values(), 0, 1))
+        return first_p.name == PARAM_LS or get_type_hints(f)[first_p.name] == annotation
+    except Exception:
+        return False
+
+
+def is_thread_function(f):
+    return getattr(f, ATTR_EXECUTE_IN_THREAD, False)
+
+
+def wrap_with_server(f, server):
+    """Returns a new callable/coroutine with server as first argument."""
+    if not has_ls_param_or_annotation(f, type(server)):
+        return f
+
+    if asyncio.iscoroutinefunction(f):
+
+        async def wrapped(*args, **kwargs):
+            return await f(server, *args, **kwargs)
+
+    else:
+        wrapped = functools.partial(f, server)
+        if is_thread_function(f):
+            assign_thread_attr(wrapped)
+
+    return wrapped
+
+
+class FeatureManager:
+    """A class for managing server features.
+
+    Attributes:
+        _builtin_features(dict): Predefined set of lsp methods
+        _feature_options(dict): Registered feature's options
+        _features(dict): Registered features
+        _commands(dict): Registered commands
+        server(LanguageServer): Reference to the language server
+                                If passed, server will be passed to registered
+                                features/commands with first parameter:
+                                    1. ls - parameter naming convention
+                                    2. name: LanguageServer - add typings
+    """
+
+    def __init__(self, server=None):
+        self._builtin_features = {}
+        self._feature_options = {}
+        self._features = {}
+        self._commands = {}
+        self.server = server
+
+    def add_builtin_feature(self, feature_name: str, func: Callable) -> None:
+        """Registers builtin (predefined) feature."""
+        self._builtin_features[feature_name] = func
+        logger.info("Registered builtin feature %s", feature_name)
+
+    @property
+    def builtin_features(self) -> Dict:
+        """Returns server builtin features."""
+        return self._builtin_features
+
+    def command(self, command_name: str) -> Callable:
+        """Decorator used to register custom commands.
+
+        Example:
+            @ls.command('myCustomCommand')
+        """
+
+        def decorator(f):
+            # Validate
+            if command_name is None or command_name.strip() == "":
+                logger.error("Missing command name.")
+                raise ValidationError("Command name is required.")
+
+            # Check if not already registered
+            if command_name in self._commands:
+                logger.error('Command "%s" is already registered.', command_name)
+                raise CommandAlreadyRegisteredError(command_name)
+
+            assign_help_attrs(f, command_name, ATTR_COMMAND_TYPE)
+
+            wrapped = wrap_with_server(f, self.server)
+            # Assign help attributes for thread decorator
+            assign_help_attrs(wrapped, command_name, ATTR_COMMAND_TYPE)
+
+            self._commands[command_name] = wrapped
+
+            logger.info('Command "%s" is successfully registered.', command_name)
+
+            return f
+
+        return decorator
+
+    @property
+    def commands(self) -> Dict:
+        """Returns registered custom commands."""
+        return self._commands
+
+    def feature(
+        self,
+        feature_name: str,
+        options: Optional[Any] = None,
+    ) -> Callable:
+        """Decorator used to register LSP features.
+
+        Example:
+            @ls.feature('textDocument/completion', CompletionItems(trigger_characters=['.']))
+        """
+
+        def decorator(f):
+            # Validate
+            if feature_name is None or feature_name.strip() == "":
+                logger.error("Missing feature name.")
+                raise ValidationError("Feature name is required.")
+
+            # Add feature if not exists
+            if feature_name in self._features:
+                logger.error('Feature "%s" is already registered.', feature_name)
+                raise FeatureAlreadyRegisteredError(feature_name)
+
+            assign_help_attrs(f, feature_name, ATTR_FEATURE_TYPE)
+
+            wrapped = wrap_with_server(f, self.server)
+            # Assign help attributes for thread decorator
+            assign_help_attrs(wrapped, feature_name, ATTR_FEATURE_TYPE)
+
+            self._features[feature_name] = wrapped
+
+            if options:
+                options_type = get_method_options_type(feature_name)
+                if options_type and not is_instance(options, options_type):
+                    raise TypeError(
+                        (
+                            f'Options of method "{feature_name}"'
+                            f" should be instance of type {options_type}"
+                        )
+                    )
+                self._feature_options[feature_name] = options
+
+            logger.info('Registered "%s" with options "%s"', feature_name, options)
+
+            return f
+
+        return decorator
+
+    @property
+    def feature_options(self) -> Dict:
+        """Returns feature options for registered features."""
+        return self._feature_options
+
+    @property
+    def features(self) -> Dict:
+        """Returns registered features"""
+        return self._features
+
+    def thread(self) -> Callable:
+        """Decorator that mark function to execute it in a thread."""
+
+        def decorator(f):
+            if asyncio.iscoroutinefunction(f):
+                raise ThreadDecoratorError(
+                    f'Thread decorator cannot be used with async functions "{f.__name__}"'
+                )
+
+            # Allow any decorator order
+            try:
+                reg_name = getattr(f, ATTR_REGISTERED_NAME)
+                reg_type = getattr(f, ATTR_REGISTERED_TYPE)
+
+                if reg_type is ATTR_FEATURE_TYPE:
+                    assign_thread_attr(self.features[reg_name])
+                elif reg_type is ATTR_COMMAND_TYPE:
+                    assign_thread_attr(self.commands[reg_name])
+
+            except AttributeError:
+                assign_thread_attr(f)
+
+            return f
+
+        return decorator