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

jaclang/vendor/pygls/capabilities.py

@@ -0,0 +1,502 @@
+############################################################################
+# 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 functools import reduce
+from typing import Any, Dict, List, Optional, Set, Union
+import logging
+
+from jaclang.vendor.pygls.lsprotocol.types import (
+    INLAY_HINT_RESOLVE,
+    TEXT_DOCUMENT_CODE_ACTION,
+    TEXT_DOCUMENT_CODE_LENS,
+    TEXT_DOCUMENT_COMPLETION,
+    TEXT_DOCUMENT_DECLARATION,
+    TEXT_DOCUMENT_DEFINITION,
+    TEXT_DOCUMENT_DIAGNOSTIC,
+    TEXT_DOCUMENT_DOCUMENT_COLOR,
+    TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT,
+    TEXT_DOCUMENT_DOCUMENT_LINK,
+    TEXT_DOCUMENT_DOCUMENT_SYMBOL,
+    TEXT_DOCUMENT_FOLDING_RANGE,
+    TEXT_DOCUMENT_FORMATTING,
+    TEXT_DOCUMENT_HOVER,
+    TEXT_DOCUMENT_IMPLEMENTATION,
+    TEXT_DOCUMENT_INLAY_HINT,
+    TEXT_DOCUMENT_INLINE_VALUE,
+    TEXT_DOCUMENT_ON_TYPE_FORMATTING,
+    TEXT_DOCUMENT_RANGE_FORMATTING,
+    TEXT_DOCUMENT_REFERENCES,
+    TEXT_DOCUMENT_RENAME,
+    TEXT_DOCUMENT_SELECTION_RANGE,
+    TEXT_DOCUMENT_SIGNATURE_HELP,
+    TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY,
+    TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY,
+    TEXT_DOCUMENT_DID_CLOSE,
+    TEXT_DOCUMENT_DID_OPEN,
+    TEXT_DOCUMENT_DID_SAVE,
+    TEXT_DOCUMENT_LINKED_EDITING_RANGE,
+    TEXT_DOCUMENT_MONIKER,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA,
+    TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE,
+    TEXT_DOCUMENT_WILL_SAVE,
+    TEXT_DOCUMENT_WILL_SAVE_WAIT_UNTIL,
+    TEXT_DOCUMENT_TYPE_DEFINITION,
+    WORKSPACE_DIAGNOSTIC,
+    WORKSPACE_DID_CREATE_FILES,
+    WORKSPACE_DID_DELETE_FILES,
+    WORKSPACE_DID_RENAME_FILES,
+    WORKSPACE_SYMBOL,
+    WORKSPACE_SYMBOL_RESOLVE,
+    WORKSPACE_WILL_CREATE_FILES,
+    WORKSPACE_WILL_DELETE_FILES,
+    WORKSPACE_WILL_RENAME_FILES,
+    InlayHintOptions,
+    PositionEncodingKind,
+)
+from jaclang.vendor.pygls.lsprotocol.types import (
+    ClientCapabilities,
+    CodeLensOptions,
+    CompletionOptions,
+    DocumentLinkOptions,
+    ExecuteCommandOptions,
+    ImplementationOptions,
+    NotebookDocumentSyncOptions,
+    SemanticTokensOptions,
+    SemanticTokensRegistrationOptions,
+    SemanticTokensOptionsFullType1,
+    ServerCapabilities,
+    ServerCapabilitiesWorkspaceType,
+    SignatureHelpOptions,
+    TextDocumentSyncKind,
+    TextDocumentSyncOptions,
+    TypeDefinitionOptions,
+    FileOperationOptions,
+    WorkspaceFoldersServerCapabilities,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_capability(
+    client_capabilities: ClientCapabilities, field: str, default: Any = None
+) -> Any:
+    """Check if ClientCapabilities has some nested value without raising
+    AttributeError.
+    e.g. get_capability('text_document.synchronization.will_save')
+    """
+    try:
+        value = reduce(getattr, field.split("."), client_capabilities)
+    except AttributeError:
+        return default
+
+    # If we reach the desired leaf value but it's None, return the default.
+    return default if value is None else value
+
+
+class ServerCapabilitiesBuilder:
+    """Create `ServerCapabilities` instance depending on builtin and user registered
+    features.
+    """
+
+    def __init__(
+        self,
+        client_capabilities: ClientCapabilities,
+        features: Set[str],
+        feature_options: Dict[str, Any],
+        commands: List[str],
+        text_document_sync_kind: TextDocumentSyncKind,
+        notebook_document_sync: Optional[NotebookDocumentSyncOptions] = None,
+    ):
+        self.client_capabilities = client_capabilities
+        self.features = features
+        self.feature_options = feature_options
+        self.commands = commands
+        self.text_document_sync_kind = text_document_sync_kind
+        self.notebook_document_sync = notebook_document_sync
+
+        self.server_cap = ServerCapabilities()
+
+    def _provider_options(self, feature, default=True):
+        if feature in self.features:
+            return self.feature_options.get(feature, default)
+        return None
+
+    def _with_text_document_sync(self):
+        open_close = (
+            TEXT_DOCUMENT_DID_OPEN in self.features
+            or TEXT_DOCUMENT_DID_CLOSE in self.features
+        )
+        will_save = (
+            get_capability(
+                self.client_capabilities, "text_document.synchronization.will_save"
+            )
+            and TEXT_DOCUMENT_WILL_SAVE in self.features
+        )
+        will_save_wait_until = (
+            get_capability(
+                self.client_capabilities,
+                "text_document.synchronization.will_save_wait_until",
+            )
+            and TEXT_DOCUMENT_WILL_SAVE_WAIT_UNTIL in self.features
+        )
+        if TEXT_DOCUMENT_DID_SAVE in self.features:
+            save = self.feature_options.get(TEXT_DOCUMENT_DID_SAVE, True)
+        else:
+            save = False
+
+        self.server_cap.text_document_sync = TextDocumentSyncOptions(
+            open_close=open_close,
+            change=self.text_document_sync_kind,
+            will_save=will_save,
+            will_save_wait_until=will_save_wait_until,
+            save=save,
+        )
+
+        return self
+
+    def _with_notebook_document_sync(self):
+        if self.client_capabilities.notebook_document is None:
+            return self
+
+        self.server_cap.notebook_document_sync = self.notebook_document_sync
+        return self
+
+    def _with_completion(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_COMPLETION, default=CompletionOptions()
+        )
+        if value is not None:
+            self.server_cap.completion_provider = value
+        return self
+
+    def _with_hover(self):
+        value = self._provider_options(TEXT_DOCUMENT_HOVER)
+        if value is not None:
+            self.server_cap.hover_provider = value
+        return self
+
+    def _with_signature_help(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_SIGNATURE_HELP, default=SignatureHelpOptions()
+        )
+        if value is not None:
+            self.server_cap.signature_help_provider = value
+        return self
+
+    def _with_declaration(self):
+        value = self._provider_options(TEXT_DOCUMENT_DECLARATION)
+        if value is not None:
+            self.server_cap.declaration_provider = value
+        return self
+
+    def _with_definition(self):
+        value = self._provider_options(TEXT_DOCUMENT_DEFINITION)
+        if value is not None:
+            self.server_cap.definition_provider = value
+        return self
+
+    def _with_type_definition(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_TYPE_DEFINITION, default=TypeDefinitionOptions()
+        )
+        if value is not None:
+            self.server_cap.type_definition_provider = value
+        return self
+
+    def _with_inlay_hints(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_INLAY_HINT, default=InlayHintOptions()
+        )
+        if value is not None:
+            value.resolve_provider = INLAY_HINT_RESOLVE in self.features
+            self.server_cap.inlay_hint_provider = value
+        return self
+
+    def _with_implementation(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_IMPLEMENTATION, default=ImplementationOptions()
+        )
+        if value is not None:
+            self.server_cap.implementation_provider = value
+        return self
+
+    def _with_references(self):
+        value = self._provider_options(TEXT_DOCUMENT_REFERENCES)
+        if value is not None:
+            self.server_cap.references_provider = value
+        return self
+
+    def _with_document_highlight(self):
+        value = self._provider_options(TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT)
+        if value is not None:
+            self.server_cap.document_highlight_provider = value
+        return self
+
+    def _with_document_symbol(self):
+        value = self._provider_options(TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+        if value is not None:
+            self.server_cap.document_symbol_provider = value
+        return self
+
+    def _with_code_action(self):
+        value = self._provider_options(TEXT_DOCUMENT_CODE_ACTION)
+        if value is not None:
+            self.server_cap.code_action_provider = value
+        return self
+
+    def _with_code_lens(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_CODE_LENS, default=CodeLensOptions()
+        )
+        if value is not None:
+            self.server_cap.code_lens_provider = value
+        return self
+
+    def _with_document_link(self):
+        value = self._provider_options(
+            TEXT_DOCUMENT_DOCUMENT_LINK, default=DocumentLinkOptions()
+        )
+        if value is not None:
+            self.server_cap.document_link_provider = value
+        return self
+
+    def _with_color(self):
+        value = self._provider_options(TEXT_DOCUMENT_DOCUMENT_COLOR)
+        if value is not None:
+            self.server_cap.color_provider = value
+        return self
+
+    def _with_document_formatting(self):
+        value = self._provider_options(TEXT_DOCUMENT_FORMATTING)
+        if value is not None:
+            self.server_cap.document_formatting_provider = value
+        return self
+
+    def _with_document_range_formatting(self):
+        value = self._provider_options(TEXT_DOCUMENT_RANGE_FORMATTING)
+        if value is not None:
+            self.server_cap.document_range_formatting_provider = value
+        return self
+
+    def _with_document_on_type_formatting(self):
+        value = self._provider_options(TEXT_DOCUMENT_ON_TYPE_FORMATTING)
+        if value is not None:
+            self.server_cap.document_on_type_formatting_provider = value
+        return self
+
+    def _with_rename(self):
+        value = self._provider_options(TEXT_DOCUMENT_RENAME)
+        if value is not None:
+            self.server_cap.rename_provider = value
+        return self
+
+    def _with_folding_range(self):
+        value = self._provider_options(TEXT_DOCUMENT_FOLDING_RANGE)
+        if value is not None:
+            self.server_cap.folding_range_provider = value
+        return self
+
+    def _with_execute_command(self):
+        self.server_cap.execute_command_provider = ExecuteCommandOptions(
+            commands=self.commands
+        )
+        return self
+
+    def _with_selection_range(self):
+        value = self._provider_options(TEXT_DOCUMENT_SELECTION_RANGE)
+        if value is not None:
+            self.server_cap.selection_range_provider = value
+        return self
+
+    def _with_call_hierarchy(self):
+        value = self._provider_options(TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY)
+        if value is not None:
+            self.server_cap.call_hierarchy_provider = value
+        return self
+
+    def _with_type_hierarchy(self):
+        value = self._provider_options(TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY)
+        if value is not None:
+            self.server_cap.type_hierarchy_provider = value
+        return self
+
+    def _with_semantic_tokens(self):
+        providers = [
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA,
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE,
+        ]
+
+        for provider in providers:
+            value = self._provider_options(provider, None)
+            if value:
+                break
+
+        if value is None:
+            return self
+
+        if isinstance(value, SemanticTokensRegistrationOptions):
+            self.server_cap.semantic_tokens_provider = value
+            return self
+
+        full_support: Union[bool, SemanticTokensOptionsFullType1] = (
+            TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL in self.features
+        )
+
+        if TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL_DELTA in self.features:
+            full_support = SemanticTokensOptionsFullType1(delta=True)
+
+        options = SemanticTokensOptions(
+            legend=value,
+            full=full_support or None,
+            range=TEXT_DOCUMENT_SEMANTIC_TOKENS_RANGE in self.features or None,
+        )
+
+        if options.full or options.range:
+            self.server_cap.semantic_tokens_provider = options
+
+        return self
+
+    def _with_linked_editing_range(self):
+        value = self._provider_options(TEXT_DOCUMENT_LINKED_EDITING_RANGE)
+        if value is not None:
+            self.server_cap.linked_editing_range_provider = value
+        return self
+
+    def _with_moniker(self):
+        value = self._provider_options(TEXT_DOCUMENT_MONIKER)
+        if value is not None:
+            self.server_cap.moniker_provider = value
+        return self
+
+    def _with_workspace_symbol(self):
+        value = self._provider_options(WORKSPACE_SYMBOL)
+        if value is not None:
+            value.resolve_provider = self._provider_options(WORKSPACE_SYMBOL_RESOLVE)
+            self.server_cap.workspace_symbol_provider = value
+        return self
+
+    def _with_workspace_capabilities(self):
+        # File operations
+        file_operations = FileOperationOptions()
+        operations = [
+            (WORKSPACE_WILL_CREATE_FILES, "will_create"),
+            (WORKSPACE_DID_CREATE_FILES, "did_create"),
+            (WORKSPACE_WILL_DELETE_FILES, "will_delete"),
+            (WORKSPACE_DID_DELETE_FILES, "did_delete"),
+            (WORKSPACE_WILL_RENAME_FILES, "will_rename"),
+            (WORKSPACE_DID_RENAME_FILES, "did_rename"),
+        ]
+
+        for method_name, capability_name in operations:
+            client_supports_method = get_capability(
+                self.client_capabilities, f"workspace.file_operations.{capability_name}"
+            )
+
+            if client_supports_method:
+                value = self._provider_options(method_name, None)
+                setattr(file_operations, capability_name, value)
+
+        self.server_cap.workspace = ServerCapabilitiesWorkspaceType(
+            workspace_folders=WorkspaceFoldersServerCapabilities(
+                supported=True,
+                change_notifications=True,
+            ),
+            file_operations=file_operations,
+        )
+        return self
+
+    def _with_diagnostic_provider(self):
+        value = self._provider_options(TEXT_DOCUMENT_DIAGNOSTIC)
+        if value is not None:
+            value.workspace_diagnostics = self._provider_options(WORKSPACE_DIAGNOSTIC)
+            self.server_cap.diagnostic_provider = value
+        return self
+
+    def _with_inline_value_provider(self):
+        value = self._provider_options(TEXT_DOCUMENT_INLINE_VALUE)
+        if value is not None:
+            self.server_cap.inline_value_provider = value
+        return self
+
+    def _with_position_encodings(self):
+        self.server_cap.position_encoding = PositionEncodingKind.Utf16
+
+        general = self.client_capabilities.general
+        if general is None:
+            return self
+
+        encodings = general.position_encodings
+        if encodings is None:
+            return self
+
+        if PositionEncodingKind.Utf16 in encodings:
+            return self
+
+        if PositionEncodingKind.Utf32 in encodings:
+            self.server_cap.position_encoding = PositionEncodingKind.Utf32
+            return self
+
+        if PositionEncodingKind.Utf8 in encodings:
+            self.server_cap.position_encoding = PositionEncodingKind.Utf8
+            return self
+
+        logger.warning(f"Unknown `PositionEncoding`s: {encodings}")
+
+        return self
+
+    def _build(self):
+        return self.server_cap
+
+    def build(self):
+        return (
+            self._with_text_document_sync()
+            ._with_notebook_document_sync()
+            ._with_completion()
+            ._with_hover()
+            ._with_signature_help()
+            ._with_declaration()
+            ._with_definition()
+            ._with_type_definition()
+            ._with_inlay_hints()
+            ._with_implementation()
+            ._with_references()
+            ._with_document_highlight()
+            ._with_document_symbol()
+            ._with_code_action()
+            ._with_code_lens()
+            ._with_document_link()
+            ._with_color()
+            ._with_document_formatting()
+            ._with_document_range_formatting()
+            ._with_document_on_type_formatting()
+            ._with_rename()
+            ._with_folding_range()
+            ._with_execute_command()
+            ._with_selection_range()
+            ._with_call_hierarchy()
+            ._with_type_hierarchy()
+            ._with_semantic_tokens()
+            ._with_linked_editing_range()
+            ._with_moniker()
+            ._with_workspace_symbol()
+            ._with_workspace_capabilities()
+            ._with_diagnostic_provider()
+            ._with_inline_value_provider()
+            ._with_position_encodings()
+            ._build()
+        )

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"