github-haystack 1.0.0__py3-none-any.whl

haystack_integrations/tools/github/file_editor_tool.py

@@ -0,0 +1,128 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Callable, Dict, Optional, Union
+
+from haystack.core.serialization import generate_qualified_class_name
+from haystack.tools import ComponentTool
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+from haystack_integrations.components.connectors.github.file_editor import GitHubFileEditor
+from haystack_integrations.prompts.github.file_editor_prompt import FILE_EDITOR_PROMPT, FILE_EDITOR_SCHEMA
+from haystack_integrations.tools.github.utils import deserialize_handlers, serialize_handlers
+
+
+class GitHubFileEditorTool(ComponentTool):
+    """
+    A tool for editing files in GitHub repositories.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = "file_editor",
+        description: Optional[str] = FILE_EDITOR_PROMPT,
+        parameters: Optional[Dict[str, Any]] = FILE_EDITOR_SCHEMA,
+        github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
+        repo: Optional[str] = None,
+        branch: str = "main",
+        raise_on_failure: bool = True,
+        outputs_to_string: Optional[Dict[str, Union[str, Callable[[Any], str]]]] = None,
+        inputs_from_state: Optional[Dict[str, str]] = None,
+        outputs_to_state: Optional[Dict[str, Dict[str, Union[str, Callable]]]] = None,
+    ):
+        """
+        Initialize the GitHub file editor tool.
+
+        :param name: Optional name for the tool.
+        :param description: Optional description.
+        :param parameters: Optional JSON schema defining the parameters expected by the Tool.
+        :param github_token: GitHub personal access token for API authentication
+        :param repo: Default repository in owner/repo format
+        :param branch: Default branch to work with
+        :param raise_on_failure: If True, raises exceptions on API errors
+        :param outputs_to_string:
+            Optional dictionary defining how a tool outputs should be converted into a string.
+            If the source is provided only the specified output key is sent to the handler.
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "source": "docs", "handler": format_documents
+            }
+        :param inputs_from_state:
+            Optional dictionary mapping state keys to tool parameter names.
+            Example: {"repository": "repo"} maps state's "repository" to tool's "repo" parameter.
+        :param outputs_to_state:
+            Optional dictionary defining how tool outputs map to keys within state as well as optional handlers.
+            If the source is provided only the specified output key is sent to the handler.
+            Example: {
+                "documents": {"source": "docs", "handler": custom_handler}
+            }
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "documents": {"handler": custom_handler}
+            }
+        """
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.github_token = github_token
+        self.repo = repo
+        self.branch = branch
+        self.raise_on_failure = raise_on_failure
+        self.outputs_to_string = outputs_to_string
+        self.inputs_from_state = inputs_from_state
+        self.outputs_to_state = outputs_to_state
+
+        file_editor = GitHubFileEditor(
+            github_token=github_token,
+            repo=repo,
+            branch=branch,
+            raise_on_failure=raise_on_failure,
+        )
+        super().__init__(
+            component=file_editor,
+            name=name,
+            description=description,
+            parameters=parameters,
+            outputs_to_string=outputs_to_string,
+            inputs_from_state=inputs_from_state,
+            outputs_to_state=outputs_to_state,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the tool to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialized = {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters,
+            "github_token": self.github_token.to_dict() if self.github_token else None,
+            "repo": self.repo,
+            "branch": self.branch,
+            "raise_on_failure": self.raise_on_failure,
+            "outputs_to_string": self.outputs_to_string,
+            "inputs_from_state": self.inputs_from_state,
+            "outputs_to_state": self.outputs_to_state,
+        }
+
+        serialize_handlers(serialized, self.outputs_to_state, self.outputs_to_string)
+        return {"type": generate_qualified_class_name(type(self)), "data": serialized}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GitHubFileEditorTool":
+        """
+        Deserializes the tool from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized tool.
+        """
+        inner_data = data["data"]
+        deserialize_secrets_inplace(inner_data, keys=["github_token"])
+        deserialize_handlers(inner_data)
+        return cls(**inner_data)

haystack_integrations/tools/github/issue_commenter_tool.py

@@ -0,0 +1,123 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Callable, Dict, Optional, Union
+
+from haystack.core.serialization import generate_qualified_class_name
+from haystack.tools import ComponentTool
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+from haystack_integrations.components.connectors.github.issue_commenter import GitHubIssueCommenter
+from haystack_integrations.prompts.github.issue_commenter_prompt import ISSUE_COMMENTER_PROMPT, ISSUE_COMMENTER_SCHEMA
+from haystack_integrations.tools.github.utils import deserialize_handlers, serialize_handlers
+
+
+class GitHubIssueCommenterTool(ComponentTool):
+    """
+    A tool for commenting on GitHub issues.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = "issue_commenter",
+        description: Optional[str] = ISSUE_COMMENTER_PROMPT,
+        parameters: Optional[Dict[str, Any]] = ISSUE_COMMENTER_SCHEMA,
+        github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
+        raise_on_failure: bool = True,
+        retry_attempts: int = 2,
+        outputs_to_string: Optional[Dict[str, Union[str, Callable[[Any], str]]]] = None,
+        inputs_from_state: Optional[Dict[str, str]] = None,
+        outputs_to_state: Optional[Dict[str, Dict[str, Union[str, Callable]]]] = None,
+    ):
+        """
+        Initialize the GitHub issue commenter tool.
+
+        :param name: Optional name for the tool.
+        :param description: Optional description.
+        :param parameters: Optional JSON schema defining the parameters expected by the Tool.
+        :param github_token: GitHub personal access token for API authentication
+        :param raise_on_failure: If True, raises exceptions on API errors
+        :param retry_attempts: Number of retry attempts for failed requests
+        :param outputs_to_string:
+            Optional dictionary defining how a tool outputs should be converted into a string.
+            If the source is provided only the specified output key is sent to the handler.
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "source": "docs", "handler": format_documents
+            }
+        :param inputs_from_state:
+            Optional dictionary mapping state keys to tool parameter names.
+            Example: {"repository": "repo"} maps state's "repository" to tool's "repo" parameter.
+        :param outputs_to_state:
+            Optional dictionary defining how tool outputs map to keys within state as well as optional handlers.
+            If the source is provided only the specified output key is sent to the handler.
+            Example: {
+                "documents": {"source": "docs", "handler": custom_handler}
+            }
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "documents": {"handler": custom_handler}
+            }
+        """
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.github_token = github_token
+        self.raise_on_failure = raise_on_failure
+        self.retry_attempts = retry_attempts
+        self.outputs_to_string = outputs_to_string
+        self.inputs_from_state = inputs_from_state
+        self.outputs_to_state = outputs_to_state
+
+        issue_commenter = GitHubIssueCommenter(
+            github_token=github_token,
+            raise_on_failure=raise_on_failure,
+            retry_attempts=retry_attempts,
+        )
+        super().__init__(
+            component=issue_commenter,
+            name=name,
+            description=description,
+            parameters=parameters,
+            outputs_to_string=outputs_to_string,
+            inputs_from_state=inputs_from_state,
+            outputs_to_state=outputs_to_state,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the tool to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialized = {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters,
+            "github_token": self.github_token.to_dict() if self.github_token else None,
+            "raise_on_failure": self.raise_on_failure,
+            "retry_attempts": self.retry_attempts,
+            "outputs_to_string": self.outputs_to_string,
+            "inputs_from_state": self.inputs_from_state,
+            "outputs_to_state": self.outputs_to_state,
+        }
+
+        serialize_handlers(serialized, self.outputs_to_state, self.outputs_to_string)
+        return {"type": generate_qualified_class_name(type(self)), "data": serialized}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GitHubIssueCommenterTool":
+        """
+        Deserializes the tool from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized tool.
+        """
+        inner_data = data["data"]
+        deserialize_secrets_inplace(inner_data, keys=["github_token"])
+        deserialize_handlers(inner_data)
+        return cls(**inner_data)

haystack_integrations/tools/github/issue_viewer_tool.py

@@ -0,0 +1,123 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Callable, Dict, Optional, Union
+
+from haystack.core.serialization import generate_qualified_class_name
+from haystack.tools import ComponentTool
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+from haystack_integrations.components.connectors.github.issue_viewer import GitHubIssueViewer
+from haystack_integrations.prompts.github.issue_viewer_prompt import ISSUE_VIEWER_PROMPT, ISSUE_VIEWER_SCHEMA
+from haystack_integrations.tools.github.utils import deserialize_handlers, serialize_handlers
+
+
+class GitHubIssueViewerTool(ComponentTool):
+    """
+    A tool for viewing GitHub issues.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = "issue_viewer",
+        description: Optional[str] = ISSUE_VIEWER_PROMPT,
+        parameters: Optional[Dict[str, Any]] = ISSUE_VIEWER_SCHEMA,
+        github_token: Optional[Secret] = None,
+        raise_on_failure: bool = True,
+        retry_attempts: int = 2,
+        outputs_to_string: Optional[Dict[str, Union[str, Callable[[Any], str]]]] = None,
+        inputs_from_state: Optional[Dict[str, str]] = None,
+        outputs_to_state: Optional[Dict[str, Dict[str, Union[str, Callable]]]] = None,
+    ):
+        """
+        Initialize the GitHub issue viewer tool.
+
+        :param name: Optional name for the tool.
+        :param description: Optional description.
+        :param parameters: Optional JSON schema defining the parameters expected by the Tool.
+        :param github_token: Optional GitHub personal access token for API authentication
+        :param raise_on_failure: If True, raises exceptions on API errors
+        :param retry_attempts: Number of retry attempts for failed requests
+        :param outputs_to_string:
+            Optional dictionary defining how a tool outputs should be converted into a string.
+            If the source is provided only the specified output key is sent to the handler.
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "source": "docs", "handler": format_documents
+            }
+        :param inputs_from_state:
+            Optional dictionary mapping state keys to tool parameter names.
+            Example: {"repository": "repo"} maps state's "repository" to tool's "repo" parameter.
+        :param outputs_to_state:
+            Optional dictionary defining how tool outputs map to keys within state as well as optional handlers.
+            If the source is provided only the specified output key is sent to the handler.
+            Example: {
+                "documents": {"source": "docs", "handler": custom_handler}
+            }
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "documents": {"handler": custom_handler}
+            }
+        """
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.github_token = github_token
+        self.raise_on_failure = raise_on_failure
+        self.retry_attempts = retry_attempts
+        self.outputs_to_string = outputs_to_string
+        self.inputs_from_state = inputs_from_state
+        self.outputs_to_state = outputs_to_state
+
+        issue_viewer = GitHubIssueViewer(
+            github_token=github_token,
+            raise_on_failure=raise_on_failure,
+            retry_attempts=retry_attempts,
+        )
+        super().__init__(
+            component=issue_viewer,
+            name=name,
+            description=description,
+            parameters=parameters,
+            outputs_to_string=outputs_to_string,
+            inputs_from_state=inputs_from_state,
+            outputs_to_state=outputs_to_state,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the tool to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialized = {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters,
+            "github_token": self.github_token.to_dict() if self.github_token else None,
+            "raise_on_failure": self.raise_on_failure,
+            "retry_attempts": self.retry_attempts,
+            "outputs_to_string": self.outputs_to_string,
+            "inputs_from_state": self.inputs_from_state,
+            "outputs_to_state": self.outputs_to_state,
+        }
+
+        serialize_handlers(serialized, self.outputs_to_state, self.outputs_to_string)
+        return {"type": generate_qualified_class_name(type(self)), "data": serialized}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GitHubIssueViewerTool":
+        """
+        Deserializes the tool from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized tool.
+        """
+        inner_data = data["data"]
+        deserialize_secrets_inplace(inner_data, keys=["github_token"])
+        deserialize_handlers(inner_data)
+        return cls(**inner_data)

haystack_integrations/tools/github/pr_creator_tool.py

@@ -0,0 +1,117 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Callable, Dict, Optional, Union
+
+from haystack.core.serialization import generate_qualified_class_name
+from haystack.tools import ComponentTool
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+from haystack_integrations.components.connectors.github.pr_creator import GitHubPRCreator
+from haystack_integrations.prompts.github.pr_creator_prompt import PR_CREATOR_PROMPT, PR_CREATOR_SCHEMA
+from haystack_integrations.tools.github.utils import deserialize_handlers, serialize_handlers
+
+
+class GitHubPRCreatorTool(ComponentTool):
+    """
+    A tool for creating pull requests in GitHub repositories.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = "pr_creator",
+        description: Optional[str] = PR_CREATOR_PROMPT,
+        parameters: Optional[Dict[str, Any]] = PR_CREATOR_SCHEMA,
+        github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
+        raise_on_failure: bool = True,
+        outputs_to_string: Optional[Dict[str, Union[str, Callable[[Any], str]]]] = None,
+        inputs_from_state: Optional[Dict[str, str]] = None,
+        outputs_to_state: Optional[Dict[str, Dict[str, Union[str, Callable]]]] = None,
+    ):
+        """
+        Initialize the GitHub PR creator tool.
+
+        :param name: Optional name for the tool.
+        :param description: Optional description.
+        :param parameters: Optional JSON schema defining the parameters expected by the Tool.
+        :param github_token: GitHub personal access token for API authentication
+        :param raise_on_failure: If True, raises exceptions on API errors
+        :param outputs_to_string:
+            Optional dictionary defining how a tool outputs should be converted into a string.
+            If the source is provided only the specified output key is sent to the handler.
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "source": "docs", "handler": format_documents
+            }
+        :param inputs_from_state:
+            Optional dictionary mapping state keys to tool parameter names.
+            Example: {"repository": "repo"} maps state's "repository" to tool's "repo" parameter.
+        :param outputs_to_state:
+            Optional dictionary defining how tool outputs map to keys within state as well as optional handlers.
+            If the source is provided only the specified output key is sent to the handler.
+            Example: {
+                "documents": {"source": "docs", "handler": custom_handler}
+            }
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "documents": {"handler": custom_handler}
+            }
+        """
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.github_token = github_token
+        self.raise_on_failure = raise_on_failure
+        self.outputs_to_string = outputs_to_string
+        self.inputs_from_state = inputs_from_state
+        self.outputs_to_state = outputs_to_state
+
+        pr_creator = GitHubPRCreator(
+            github_token=github_token,
+            raise_on_failure=raise_on_failure,
+        )
+        super().__init__(
+            component=pr_creator,
+            name=name,
+            description=description,
+            parameters=parameters,
+            outputs_to_string=outputs_to_string,
+            inputs_from_state=inputs_from_state,
+            outputs_to_state=outputs_to_state,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the tool to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialized = {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters,
+            "github_token": self.github_token.to_dict() if self.github_token else None,
+            "raise_on_failure": self.raise_on_failure,
+            "outputs_to_string": self.outputs_to_string,
+            "inputs_from_state": self.inputs_from_state,
+            "outputs_to_state": self.outputs_to_state,
+        }
+        serialize_handlers(serialized, self.outputs_to_state, self.outputs_to_string)
+        return {"type": generate_qualified_class_name(type(self)), "data": serialized}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GitHubPRCreatorTool":
+        """
+        Deserializes the tool from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized tool.
+        """
+        inner_data = data["data"]
+        deserialize_secrets_inplace(inner_data, keys=["github_token"])
+        deserialize_handlers(inner_data)
+        return cls(**inner_data)

haystack_integrations/tools/github/repo_viewer_tool.py

@@ -0,0 +1,138 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Callable, Dict, Optional, Union
+
+from haystack.core.serialization import generate_qualified_class_name
+from haystack.tools import ComponentTool
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+from haystack_integrations.components.connectors.github.repo_viewer import GitHubRepoViewer
+from haystack_integrations.prompts.github.repo_viewer_prompt import REPO_VIEWER_PROMPT, REPO_VIEWER_SCHEMA
+from haystack_integrations.tools.github.utils import deserialize_handlers, message_handler, serialize_handlers
+
+
+class GitHubRepoViewerTool(ComponentTool):
+    """
+    A tool for viewing files and directories in GitHub repositories.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: Optional[str] = "repo_viewer",
+        description: Optional[str] = REPO_VIEWER_PROMPT,
+        parameters: Optional[Dict[str, Any]] = REPO_VIEWER_SCHEMA,
+        github_token: Optional[Secret] = None,
+        repo: Optional[str] = None,
+        branch: str = "main",
+        raise_on_failure: bool = True,
+        max_file_size: int = 1_000_000,  # 1MB default limit
+        outputs_to_string: Optional[Dict[str, Union[str, Callable[[Any], str]]]] = None,
+        inputs_from_state: Optional[Dict[str, str]] = None,
+        outputs_to_state: Optional[Dict[str, Dict[str, Union[str, Callable]]]] = None,
+    ):
+        """
+        Initialize the GitHub repository viewer tool.
+
+        :param name: Optional name for the tool.
+        :param description: Optional description.
+        :param parameters: Optional JSON schema defining the parameters expected by the Tool.
+        :param github_token: Optional GitHub personal access token for API authentication
+        :param repo: Default repository in owner/repo format
+        :param branch: Default branch to work with
+        :param raise_on_failure: If True, raises exceptions on API errors
+        :param max_file_size: Maximum file size in bytes to read
+        :param outputs_to_string:
+            Optional dictionary defining how a tool outputs should be converted into a string.
+            By default, truncates the document.content of the viewed files to 150,000 characters each.
+            If the source is provided only the specified output key is sent to the handler.
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "source": "docs", "handler": format_documents
+            }
+        :param inputs_from_state:
+            Optional dictionary mapping state keys to tool parameter names.
+            By default, the tool does not use any inputs from state.
+            Example: {"repository": "repo"} maps state's "repository" to tool's "repo" parameter.
+        :param outputs_to_state:
+            Optional dictionary defining how tool outputs map to keys within state as well as optional handlers.
+            By default, outputs the viewed files as documents to the state.
+            If the source is provided only the specified output key is sent to the handler.
+            Example: {
+                "documents": {"source": "docs", "handler": custom_handler}
+            }
+            If the source is omitted the whole tool result is sent to the handler.
+            Example: {
+                "documents": {"handler": custom_handler}
+            }
+        """
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.github_token = github_token
+        self.repo = repo
+        self.branch = branch
+        self.raise_on_failure = raise_on_failure
+        self.max_file_size = max_file_size
+
+        # Set default values for mutable parameters
+        self.outputs_to_string = outputs_to_string or {"source": "documents", "handler": message_handler}
+        self.inputs_from_state = inputs_from_state or {}
+        self.outputs_to_state = outputs_to_state or {"documents": {"source": "documents"}}
+
+        repo_viewer = GitHubRepoViewer(
+            github_token=github_token,
+            repo=repo,
+            branch=branch,
+            raise_on_failure=raise_on_failure,
+            max_file_size=max_file_size,
+        )
+        super().__init__(
+            component=repo_viewer,
+            name=name,
+            description=description,
+            parameters=parameters,
+            outputs_to_string=self.outputs_to_string,
+            inputs_from_state=self.inputs_from_state,
+            outputs_to_state=self.outputs_to_state,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the tool to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialized = {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters,
+            "github_token": self.github_token.to_dict() if self.github_token else None,
+            "repo": self.repo,
+            "branch": self.branch,
+            "raise_on_failure": self.raise_on_failure,
+            "max_file_size": self.max_file_size,
+            "outputs_to_string": self.outputs_to_string,
+            "inputs_from_state": self.inputs_from_state,
+            "outputs_to_state": self.outputs_to_state,
+        }
+
+        serialize_handlers(serialized, self.outputs_to_state, self.outputs_to_string)
+        return {"type": generate_qualified_class_name(type(self)), "data": serialized}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GitHubRepoViewerTool":
+        """
+        Deserializes the tool from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized tool.
+        """
+        inner_data = data["data"]
+        deserialize_secrets_inplace(inner_data, keys=["github_token"])
+        deserialize_handlers(inner_data)
+        return cls(**inner_data)