glchat-plugin 0.0.0__py3-none-any.whl

glchat_plugin/pipeline/pipeline_plugin.py

@@ -0,0 +1,126 @@
+"""Base Pipeline Builder Plugin.
+
+This module defines the base class for pipeline builder plugins.
+
+Authors:
+    Samuel Lusandi (samuel.lusandi@gdplabs.id)
+    Hermes Vincentius Gani (hermes.v.gani@gdplabs.id)
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Generic, Type, TypeVar
+
+from bosa_core.plugin.plugin import Plugin
+from gllm_inference.catalog.catalog import BaseCatalog
+from gllm_pipeline.pipeline.pipeline import Pipeline
+
+from glchat_plugin.pipeline.pipeline_handler import PipelineHandler
+
+PipelineState = TypeVar("PipelineState")
+PipelinePresetConfig = TypeVar("PipelinePresetConfig", bound="BasePipelinePresetConfig")
+PipelineRuntimeConfig = TypeVar("PipelineRuntimeConfig", bound="BaseModel")
+
+
+@Plugin.for_handler(PipelineHandler)
+class PipelineBuilderPlugin(Plugin, Generic[PipelineState, PipelinePresetConfig], ABC):
+    """Base class for pipeline builder plugins.
+
+    This class combines the Plugin architecture with the Pipeline Builder functionality.
+
+    Attributes:
+        name (str): The name of the plugin.
+        description (str): The description of the plugin.
+        version (str): The version of the plugin.
+        catalog (BaseCatalog): The catalog instance.
+        additional_config_class (Type[PipelineRuntimeConfig] | None): The additional runtime configuration class.
+        preset_config_class (Type[PipelinePresetConfig] | None): The preset configuration class.
+    """
+
+    name: str
+    description: str = "Pipeline builder plugin"
+    version: str = "0.0.0"
+
+    catalog: BaseCatalog[Any]
+
+    additional_config_class: Type[PipelineRuntimeConfig] | None = None
+    preset_config_class: Type[PipelinePresetConfig] | None = None
+
+    @classmethod
+    def get_preset_config_class(cls) -> Type[PipelinePresetConfig]:
+        """Get the preset_config_class.
+
+        Returns:
+            Type[PipelinePresetConfig]: The pipeline preset config class.
+
+        Raises:
+            NotImplementedError: If the preset_config_class is not defined.
+        """
+        if cls.preset_config_class is None:
+            raise NotImplementedError(f"{cls.__name__} must define a `preset_config_class` attribute.")
+        return cls.preset_config_class
+
+    @abstractmethod
+    def build_initial_state(
+        self,
+        request_config: dict[str, Any],
+        pipeline_config: dict[str, Any],
+        **kwargs: Any,
+    ) -> PipelineState:
+        """Build the initial pipeline state.
+
+        Args:
+            request_config (dict[str, Any]): Request configuration.
+            pipeline_config (dict[str, Any]): Pipeline configuration.
+            kwargs (Any): Additional state arguments.
+
+        Returns:
+            PipelineState: Initial pipeline state.
+        """
+        pass
+
+    @abstractmethod
+    async def build(
+        self,
+        pipeline_config: dict[str, Any],
+    ) -> Pipeline:
+        """Build a pipeline instance.
+
+        Args:
+            pipeline_config (dict[str, Any]): Pipeline configuration including model name and other settings.
+
+        Returns:
+            Pipeline: Built pipeline instance.
+        """
+        pass
+
+    async def cleanup(self):
+        """Cleanup the pipeline resources, if needed."""
+        pass
+
+    def build_additional_runtime_config(
+        self,
+        pipeline_config: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Build additional runtime configuration.
+
+        Args:
+            pipeline_config (dict[str, Any]): Pipeline configuration.
+
+        Returns:
+            dict[str, Any]: Additional runtime configuration.
+        """
+        if not self.additional_config_class:
+            return {}
+
+        config = self.additional_config_class(**pipeline_config)
+        return config.model_dump(exclude_none=True)
+
+    def get_config(self) -> dict[str, Any]:
+        """Get the pipeline configuration.
+
+        Returns:
+            dict[str, Any]: Pipeline configuration.
+        """
+        if self.preset_config_class:
+            return self.preset_config_class().model_dump()
+        return {}

glchat_plugin/storage/__init__.py

@@ -0,0 +1 @@
+"""Module for glchat_plugin storage interface."""

glchat_plugin/storage/base_anonymizer_storage.py

@@ -0,0 +1,58 @@
+"""Interface for Anonymizer Storage.
+
+Authors:
+    Hermes Vincentius Gani (hermes.v.gani@gdplabs.id)
+
+References:
+    None
+"""
+
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+AnonymizerMapping = TypeVar("AnonymizerMapping")
+MappingDataType = TypeVar("MappingDataType")
+
+
+class BaseAnonymizerStorage(ABC):
+    """Interface for anonymizer storage that defines methods for managing anonymizer mappings."""
+
+    @abstractmethod
+    def get_mappings_by_conversation_id(self, conversation_id: str) -> list[AnonymizerMapping]:
+        """Retrieve anonymizer mappings by conversation ID.
+
+        Args:
+            conversation_id (str): The ID of the conversation.
+
+        Returns:
+            list[AnonymizerMapping]: A list of anonymizer mappings associated with the conversation ID.
+        """
+        pass
+
+    @abstractmethod
+    def create_mapping(
+        self, conversation_id: str, pii_type: str, anonymized_value: str, pii_value: str
+    ) -> AnonymizerMapping:
+        """Create a new anonymizer mapping.
+
+        Args:
+            conversation_id (str): The ID of the conversation.
+            pii_type (str): The type of personally identifiable information (PII).
+            anonymized_value (str): The anonymized value of the PII.
+            pii_value (str): The original PII value.
+
+        Returns:
+            AnonymizerMapping: The created anonymizer mapping.
+        """
+        pass
+
+    @abstractmethod
+    def update_mapping(self, conversation_id: str, is_anonymized: bool, mapping_data_type: MappingDataType) -> None:
+        """Update the mappings for a specific conversation with new anonymizer mappings.
+
+        Args:
+            conversation_id (str): The unique identifier for the conversation.
+            is_anonymized (bool): The flag to determine if the message is anonymized.
+            mapping_data_type (MappingDataType): A dictionary of new anonymizer mappings to update for deanonymization.
+        """
+        pass

glchat_plugin/storage/base_chat_history_storage.py

@@ -0,0 +1,356 @@
+"""Interface for Chat History Storage.
+
+Authors:
+    Hermes Vincentius Gani (hermes.v.gani@gdplabs.id)
+
+References:
+    None
+"""
+
+from abc import ABC, abstractmethod
+from datetime import datetime
+from enum import StrEnum
+from typing import Any
+
+from typing_extensions import TypeVar
+
+from glchat_plugin.storage.base_anonymizer_storage import AnonymizerMapping
+
+Conversation = TypeVar("Conversation")
+Message = TypeVar("Message")
+ConversationDocument = TypeVar("ConversationDocument")
+
+
+class MessageRole(StrEnum):
+    """Enum for Message Type."""
+
+    USER = "USER"
+    AI = "AI"
+
+
+class DocumentStatus(StrEnum):
+    """Enum for ConversationDocument Status."""
+
+    PROCESSING = "processing"
+    DONE = "done"
+    FAILED = "failed"
+
+
+class BaseChatHistoryStorage(ABC):
+    """Interface for chat history storage that defines methods for managing chat conversations and messages."""
+
+    @abstractmethod
+    def create_conversation(
+        self, user_id: str, conversation_title: str, chatbot_id: str, **kwargs: Any
+    ) -> Conversation:
+        """Create a new conversation.
+
+        Args:
+            user_id (str): The ID of the user.
+            conversation_title (str): The title of the conversation.
+            chatbot_id (str): The ID of the chatbot.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            Conversation: The created conversation.
+        """
+        pass
+
+    @abstractmethod
+    def get_conversation(self, user_id: str, conversation_id: str, **kwargs: Any) -> Conversation | None:
+        """Retrieve a specific conversation by its ID.
+
+        Args:
+            user_id (str): The ID of the user.
+            conversation_id (str): The ID of the conversation.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            Conversation | None: The conversation if found, otherwise None.
+        """
+        pass
+
+    @abstractmethod
+    def get_conversations(
+        self,
+        user_id: str,
+        query: str = "",
+        chatbot_ids: list[str] | None = None,
+        cursor: str | None = None,
+        limit: int | None = None,
+        **kwargs: Any,
+    ) -> list[Conversation]:
+        """Retrieve a list of conversations for a user.
+
+        Args:
+            user_id (str): The ID of the user.
+            query (str, optional): A search query to filter conversations. Defaults to "".
+            chatbot_ids (list[str] | None, optional): A list of chatbot IDs to filter conversations. Defaults to None.
+            cursor (str | None, optional): A cursor for pagination. Defaults to None.
+            limit (int | None, optional): The maximum number of conversations to retrieve. Defaults to None.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            list[Conversation]: A list of conversations.
+        """
+        pass
+
+    @abstractmethod
+    def rename_conversation(self, user_id: str, conversation_id: str, new_title: str, **kwargs: Any) -> Conversation:
+        """Rename an existing conversation.
+
+        Args:
+            user_id (str): The ID of the user.
+            conversation_id (str): The ID of the conversation.
+            new_title (str): The new title of the conversation.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            Conversation: The updated conversation.
+        """
+        pass
+
+    @abstractmethod
+    def delete_conversation(self, user_id: str, conversation_id: str, **kwargs: Any) -> None:
+        """Delete a conversation by its ID.
+
+        Args:
+            user_id (str): The ID of the user.
+            conversation_id (str): The ID of the conversation.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def delete_conversations(self, user_id: str, chatbot_id: str, **kwargs: Any) -> None:
+        """Delete all conversations associated with a chatbot.
+
+        Args:
+            user_id (str): The ID of the user.
+            chatbot_id (str): The ID of the chatbot.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def save_message(
+        self,
+        user_id: str,
+        conversation_id: str,
+        message_list: list[Any],
+        attachments: dict[str, Any] | None,
+        **kwargs: Any,
+    ) -> list[Message]:
+        """Save a list of messages to a conversation.
+
+        Args:
+            user_id (str): The ID of the user.
+            conversation_id (str): The ID of the conversation.
+            message_list (list[Any]): A list of messages to save.
+            attachments (dict[str, Any] | None): Attachments associated with the messages.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            list[Message]: The saved messages.
+        """
+        pass
+
+    @abstractmethod
+    def get_message_by_id(self, message_id: str, **kwargs: Any) -> Message:
+        """Retrieve a specific message by its ID.
+
+        Args:
+            message_id (str): The ID of the message.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            Message: The message.
+        """
+        pass
+
+    @abstractmethod
+    def get_messages_by_ids(self, message_ids: list[str], **kwargs: Any) -> list[Message]:
+        """Retrieve messages by their IDs.
+
+        Args:
+            message_ids (list[str]): A list of message IDs.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            list[Message]: A list of messages.
+        """
+        pass
+
+    @abstractmethod
+    def get_messages(
+        self,
+        user_id: str,
+        conversation_id: str,
+        limit: int | None = None,
+        max_timestamp: datetime | None = None,
+        **kwargs: Any,
+    ) -> list[Message]:
+        """Retrieve messages from a conversation.
+
+        Args:
+            user_id (str): The ID of the user.
+            conversation_id (str): The ID of the conversation.
+            limit (int | None, optional): The maximum number of messages to retrieve. Defaults to None.
+            max_timestamp (datetime | None, optional): The maximum timestamp for the messages. Defaults to None.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            list[Message]: A list of messages.
+        """
+        pass
+
+    @abstractmethod
+    def update_message_metadata(self, message_id: str, metadata_: dict[str, Any], **kwargs: Any) -> Message:
+        """Update the metadata of a message.
+
+        Args:
+            message_id (str): The ID of the message.
+            metadata_ (dict[str, Any]): The metadata to update.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            Message: The updated message.
+        """
+        pass
+
+    @abstractmethod
+    def delete_messages(self, user_id: str, message_ids: list[str], chatbot_ids: list[str], **kwargs: Any) -> None:
+        """Delete messages by their IDs.
+
+        Args:
+            user_id (str): The ID of the user.
+            message_ids (list[str]): A list of message IDs to delete.
+            chatbot_ids (list[str]): A list of chatbot IDs associated with the messages.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def create_conversation_document(
+        self, conversation_id: str, status: str = DocumentStatus.PROCESSING.value, file_hash: str = "", **kwargs: Any
+    ) -> ConversationDocument:
+        """Create a new conversation document.
+
+        Args:
+            conversation_id (str): The ID of the conversation.
+            status (str, optional): The status of the document. Defaults to DocumentStatus.PROCESSING.value.
+            file_hash (str, optional): The hash of the file. Defaults to "".
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            ConversationDocument: The created conversation document.
+        """
+        pass
+
+    @abstractmethod
+    def get_conversation_document(self, document_id: str, **kwargs: Any) -> ConversationDocument:
+        """Retrieve a conversation document by its ID.
+
+        Args:
+            document_id (str): The ID of the document.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            ConversationDocument: The conversation document.
+        """
+        pass
+
+    @abstractmethod
+    def update_conversation_document(
+        self,
+        document_id: str,
+        status: str,
+        number_of_chunks: int,
+        message: str | None,
+        object_key: str | None,
+        **kwargs: Any,
+    ) -> ConversationDocument:
+        """Update a conversation document.
+
+        Args:
+            document_id (str): The ID of the document.
+            status (str): The status of the document.
+            number_of_chunks (int): The number of chunks in the document.
+            message (str | None, optional): A message associated with the document. Defaults to None.
+            object_key (str | None, optional): The object key of the document. Defaults to None.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            ConversationDocument: The updated conversation document.
+        """
+        pass
+
+    @abstractmethod
+    def save_feedback(self, user_id: str, message_id: str, feedback: str, **kwargs: Any) -> None:
+        """Save feedback for a message.
+
+        Args:
+            user_id (str): The ID of the user.
+            message_id (str): The ID of the message.
+            feedback (str): The feedback content.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            None
+        """
+        pass
+
+    @abstractmethod
+    def get_deanonymized_message(
+        self,
+        user_id: str,
+        conversation_id: str,
+        message_id: str,
+        is_anonymized: bool,
+        mappings: list[AnonymizerMapping],
+        **kwargs: Any,
+    ) -> Message:
+        """Retrieve a deanonymized message.
+
+        Args:
+            user_id (str): The ID of the user.
+            conversation_id (str): The ID of the conversation.
+            message_id (str): The ID of the message.
+            is_anonymized (bool): Whether the message is anonymized.
+            mappings (list[AnonymizerMapping]): A list of anonymizer mappings.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            Message: The deanonymized message.
+        """
+        pass
+
+    @abstractmethod
+    def get_deanonymized_messages(
+        self,
+        messages: list[Message],
+        is_anonymized: bool,
+        mappings: list[AnonymizerMapping] | None = None,
+        **kwargs: Any,
+    ) -> list[Message]:
+        """Retrieve a list of deanonymized messages.
+
+        Args:
+            messages (list[Message]): A list of messages.
+            is_anonymized (bool): Whether the messages are anonymized.
+            mappings (list[AnonymizerMapping] | None, optional): A list of anonymizer mappings. Defaults to None.
+            kwargs (Any): Additional arguments.
+
+        Returns:
+            list[Message]: A list of deanonymized messages.
+        """
+        pass

glchat_plugin/tools/__init__.py

@@ -0,0 +1,21 @@
+"""Tool plugin system for GLLM Agents.
+
+This module provides a plugin system for tools, allowing dynamic marking and preparation of tools
+similar to VSCode's extension model. Tools can be decorated with metadata while remaining independent
+from the core registration mechanism.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from glchat_plugin.tools.decorators import (
+    get_plugin_metadata,
+    is_tool_plugin,
+    tool_plugin,
+)
+
+__all__ = [
+    "tool_plugin",
+    "is_tool_plugin",
+    "get_plugin_metadata",
+]

glchat_plugin/tools/decorators.py

@@ -0,0 +1,115 @@
+"""Tool Plugin Decorators for External Use.
+
+This module provides utilities for marking and preparing tool plugins using a decorator-based approach.
+The decorators and utilities can be used independently in external repositories, as they only add
+metadata to tool classes without creating any connections to a plugin registration system.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import inspect
+from typing import Any, Callable, Type
+
+from gllm_core.utils import LoggerManager
+from langchain_core.tools import BaseTool
+
+logger = LoggerManager().get_logger()
+
+
+def tool_plugin(
+    version: str = "1.0.0",
+) -> Callable[[Type[BaseTool]], Type[BaseTool]]:
+    """Decorator to mark a BaseTool class as a tool plugin.
+
+    This decorator adds metadata to the tool class that will be used by the
+    plugin system when the tool is loaded. It doesn't directly register
+    the tool with any system, allowing for use in external repositories.
+    The actual tool name and description are intended to be retrieved
+    from the tool instance at runtime.
+
+    Args:
+        version (str): Version of the plugin. Defaults to "1.0.0".
+
+    Returns:
+        Callable[[Type[BaseTool]], Type[BaseTool]]: A decorator function that wraps the tool class.
+
+    Example:
+        ```python
+        @tool_plugin(version="1.0.0")
+        class MyAwesomeTool(BaseTool):
+            name = "my_awesome_tool"
+            description = "Does something awesome"
+
+            def _run(self, **kwargs):
+                return "Awesome result!"
+        ```
+    """
+
+    def decorator(tool_class: Type[BaseTool]) -> Type[BaseTool]:
+        """Marks a BaseTool class as a plugin by adding metadata for discovery.
+
+        This decorator adds plugin metadata to the tool class and marks it for later discovery.
+        It validates that the decorated class is a subclass of BaseTool.
+
+        Args:
+            tool_class (Type[BaseTool]): The BaseTool class to be decorated with plugin metadata.
+
+        Returns:
+            Type[BaseTool]: The decorated BaseTool class with added plugin metadata.
+        """
+        if not issubclass(tool_class, BaseTool):
+            raise TypeError(f"{tool_class.__name__} is not a subclass of BaseTool")
+
+        # Store basic plugin metadata as class attributes for later discovery
+        tool_class._plugin_metadata = {
+            "version": version,
+            "tool_class": tool_class.__name__,
+            "module": tool_class.__module__,
+        }
+
+        # Mark the class as a decorated tool plugin for easy discovery
+        tool_class._is_tool_plugin = True
+
+        # Log the preparation (but don't require any specific logger)
+        try:
+            # Simplified logging message
+            logger.info(f"Marked tool class {tool_class.__name__} as plugin with version {version}")
+        except Exception:
+            # Ignore logging errors in standalone mode
+            pass
+
+        return tool_class
+
+    return decorator
+
+
+def is_tool_plugin(obj: Any) -> bool:
+    """Check if an object is a tool plugin.
+
+    Args:
+        obj (Any): The object to check.
+
+    Returns:
+        bool: True if the object is a decorated tool plugin, False otherwise.
+    """
+    return inspect.isclass(obj) and getattr(obj, "_is_tool_plugin", False) is True
+
+
+def get_plugin_metadata(tool_class: Type[BaseTool]) -> dict[str, Any]:
+    """Get the plugin metadata from a decorated tool class.
+
+    Args:
+        tool_class (Type[BaseTool]): The tool class to get metadata from.
+
+    Returns:
+        dict[str, Any]: A dictionary of plugin metadata.
+
+    Raises:
+        ValueError: If the tool class is not a decorated tool plugin.
+    """
+    if not is_tool_plugin(tool_class):
+        raise ValueError(f"{tool_class.__name__} is not a decorated tool plugin")
+
+    return getattr(tool_class, "_plugin_metadata", {})