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

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

jaclang/vendor/pygls/lsp/__init__.py

@@ -0,0 +1,139 @@
+############################################################################
+# 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.                                           #
+############################################################################
+from typing import Any, Callable, List, Optional, Union
+
+from jaclang.vendor.pygls.lsprotocol.types import (
+    ALL_TYPES_MAP,
+    METHOD_TO_TYPES,
+    TEXT_DOCUMENT_DID_SAVE,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE,
+    WORKSPACE_DID_CREATE_FILES,
+    WORKSPACE_DID_DELETE_FILES,
+    WORKSPACE_DID_RENAME_FILES,
+    WORKSPACE_WILL_CREATE_FILES,
+    WORKSPACE_WILL_DELETE_FILES,
+    WORKSPACE_WILL_RENAME_FILES,
+    FileOperationRegistrationOptions,
+    SaveOptions,
+    SemanticTokensLegend,
+    SemanticTokensRegistrationOptions,
+    ShowDocumentResult,
+)
+from typeguard import check_type
+
+from jaclang.vendor.pygls.exceptions import MethodTypeNotRegisteredError
+
+ConfigCallbackType = Callable[[List[Any]], None]
+ShowDocumentCallbackType = Callable[[ShowDocumentResult], None]
+
+METHOD_TO_OPTIONS = {
+    TEXT_DOCUMENT_DID_SAVE: SaveOptions,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL: Union[
+        SemanticTokensLegend, SemanticTokensRegistrationOptions
+    ],
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA: Union[
+        SemanticTokensLegend, SemanticTokensRegistrationOptions
+    ],
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE: Union[
+        SemanticTokensLegend, SemanticTokensRegistrationOptions
+    ],
+    WORKSPACE_DID_CREATE_FILES: FileOperationRegistrationOptions,
+    WORKSPACE_DID_DELETE_FILES: FileOperationRegistrationOptions,
+    WORKSPACE_DID_RENAME_FILES: FileOperationRegistrationOptions,
+    WORKSPACE_WILL_CREATE_FILES: FileOperationRegistrationOptions,
+    WORKSPACE_WILL_DELETE_FILES: FileOperationRegistrationOptions,
+    WORKSPACE_WILL_RENAME_FILES: FileOperationRegistrationOptions,
+}
+
+
+def get_method_registration_options_type(
+    method_name, lsp_methods_map=METHOD_TO_TYPES
+) -> Optional[Any]:
+    """The type corresponding with a method's options when dynamically registering
+    capability for it."""
+
+    try:
+        return lsp_methods_map[method_name][3]
+    except KeyError:
+        raise MethodTypeNotRegisteredError(method_name)
+
+
+def get_method_options_type(
+    method_name, lsp_options_map=METHOD_TO_OPTIONS, lsp_methods_map=METHOD_TO_TYPES
+) -> Optional[Any]:
+    """Return the type corresponding with a method's ``ServerCapabilities`` fields.
+
+    In the majority of cases this simply means returning the ``<MethodName>Options``
+    type, which we can easily derive from the method's
+    ``<MethodName>RegistrationOptions`` type.
+
+    However, where the options are more involved (such as semantic tokens) and
+    ``pygls`` does some extra work to help derive the options for the user the type
+    has to be provided via the ``lsp_options_map``
+
+    Arguments:
+        method_name:
+            The lsp method name to retrieve the options for
+
+        lsp_options_map:
+            The map used to override the default options type finding behavior
+
+        lsp_methods_map:
+            The standard map used to look up the various method types.
+    """
+
+    options_type = lsp_options_map.get(method_name, None)
+    if options_type is not None:
+        return options_type
+
+    registration_type = get_method_registration_options_type(
+        method_name, lsp_methods_map
+    )
+    if registration_type is None:
+        return None
+
+    type_name = registration_type.__name__.replace("Registration", "")
+    options_type = ALL_TYPES_MAP.get(type_name, None)
+
+    if options_type is None:
+        raise MethodTypeNotRegisteredError(method_name)
+
+    return options_type
+
+
+def get_method_params_type(method_name, lsp_methods_map=METHOD_TO_TYPES):
+    try:
+        return lsp_methods_map[method_name][2]
+    except KeyError:
+        raise MethodTypeNotRegisteredError(method_name)
+
+
+def get_method_return_type(method_name, lsp_methods_map=METHOD_TO_TYPES):
+    try:
+        return lsp_methods_map[method_name][1]
+    except KeyError:
+        raise MethodTypeNotRegisteredError(method_name)
+
+
+def is_instance(o, t):
+    try:
+        check_type(o, t)
+        return True
+    except TypeError:
+        return False