shinychat 0.0.1a0__py3-none-any.whl

shinychat/_chat_bookmark.py

@@ -0,0 +1,110 @@
+import importlib.util
+from typing import Any, Awaitable, Callable, Protocol, runtime_checkable
+
+from htmltools import TagChild
+from shiny.types import Jsonifiable
+
+chatlas_is_installed = importlib.util.find_spec("chatlas") is not None
+
+
+def is_chatlas_chat_client(client: Any) -> bool:
+    if not chatlas_is_installed:
+        return False
+    import chatlas
+
+    return isinstance(client, chatlas.Chat)
+
+
+@runtime_checkable
+class ClientWithState(Protocol):
+    async def get_state(self) -> Jsonifiable: ...
+
+    """
+    Retrieve JSON-like representation of chat client state.
+
+    This method is used to retrieve the state of the client object when saving a bookmark.
+
+    Returns
+    -------
+    :
+        A JSON-like representation of the current state of the client. It is not required to be a JSON string but something that can be serialized to JSON without further conversion.
+    """
+
+    async def set_state(self, state: Jsonifiable): ...
+
+    """
+    Method to set the chat client state.
+
+    This method is used to restore the state of the client when the app is restored from
+    a bookmark.
+
+    Parameters
+    ----------
+    state
+        The value to infer the state from. This value will be the JSON capable value
+        returned by the `get_state()` method (after a round trip through JSON
+        serialization and unserialization).
+    """
+
+
+CancelCallback = Callable[[], None]
+
+
+class BookmarkCancelCallback:
+    def __init__(self, cancel: CancelCallback):
+        self.cancel = cancel
+
+    def __call__(self):
+        self.cancel()
+
+    def tagify(self) -> TagChild:
+        return ""
+
+
+# Chatlas specific implementation
+def get_chatlas_state(
+    client: Any,
+) -> Callable[[], Awaitable[Jsonifiable]]:
+    from chatlas import Chat, Turn
+
+    assert isinstance(client, Chat)
+
+    async def get_state() -> Jsonifiable:
+        turns: list[Turn[Any]] = client.get_turns()
+        return {
+            "version": 1,
+            "turns": [turn.model_dump(mode="json") for turn in turns],
+        }
+
+    return get_state
+
+
+def set_chatlas_state(
+    client: Any,
+) -> Callable[[Jsonifiable], Awaitable[None]]:
+    from chatlas import Chat, Turn
+
+    assert isinstance(client, Chat)
+
+    # TODO-future: Use pydantic model for validation
+    # instead of manual validation
+    async def set_state(value: Jsonifiable) -> None:
+        if not isinstance(value, dict):
+            raise ValueError("Chatlas bookmark value was not a dictionary")
+
+        version = value.get("version")
+        if version != 1:
+            raise ValueError(f"Unsupported Chatlas bookmark version: {version}")
+        turns_arr = value.get("turns")
+
+        if not isinstance(turns_arr, list):
+            raise ValueError(
+                "Chatlas bookmark value was not a list of chat message information"
+            )
+
+        turns: list[Turn[Any]] = [
+            Turn.model_validate(turn_obj) for turn_obj in turns_arr
+        ]
+        client.set_turns(turns)  # pyright: ignore[reportUnknownMemberType]
+
+    return set_state

shinychat/_chat_normalize.py

@@ -0,0 +1,350 @@
+import sys
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Optional, cast
+
+from htmltools import HTML, Tagifiable
+
+from ._chat_types import ChatMessage
+
+if TYPE_CHECKING:
+    from anthropic.types import Message as AnthropicMessage
+    from anthropic.types import MessageStreamEvent
+
+    if sys.version_info >= (3, 9):
+        from google.generativeai.types.generation_types import (  # pyright: ignore[reportMissingTypeStubs]
+            GenerateContentResponse,
+        )
+    else:
+
+        class GenerateContentResponse:
+            text: str
+
+    from langchain_core.messages import BaseMessage, BaseMessageChunk
+    from openai.types.chat import ChatCompletion, ChatCompletionChunk
+
+
+class BaseMessageNormalizer(ABC):
+    @abstractmethod
+    def normalize(self, message: Any) -> ChatMessage:
+        pass
+
+    @abstractmethod
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        pass
+
+    @abstractmethod
+    def can_normalize(self, message: Any) -> bool:
+        pass
+
+    @abstractmethod
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        pass
+
+
+class StringNormalizer(BaseMessageNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast(Optional[str], message)
+        return ChatMessage(content=x or "", role="assistant")
+
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        x = cast(Optional[str], chunk)
+        return ChatMessage(content=x or "", role="assistant")
+
+    def can_normalize(self, message: Any) -> bool:
+        return isinstance(message, (str, HTML)) or message is None
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        return isinstance(chunk, (str, HTML)) or chunk is None
+
+
+class DictNormalizer(BaseMessageNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast("dict[str, Any]", message)
+        if "content" not in x:
+            raise ValueError("Message must have 'content' key")
+        return ChatMessage(content=x["content"], role=x.get("role", "assistant"))
+
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        x = cast("dict[str, Any]", chunk)
+        if "content" not in x:
+            raise ValueError("Message must have 'content' key")
+        return ChatMessage(content=x["content"], role=x.get("role", "assistant"))
+
+    def can_normalize(self, message: Any) -> bool:
+        return isinstance(message, dict)
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        return isinstance(chunk, dict)
+
+
+class TagifiableNormalizer(DictNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast("Tagifiable", message)
+        return super().normalize({"content": x})
+
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        x = cast("Tagifiable", chunk)
+        return super().normalize_chunk({"content": x})
+
+    def can_normalize(self, message: Any) -> bool:
+        return isinstance(message, Tagifiable)
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        return isinstance(chunk, Tagifiable)
+
+
+class LangChainNormalizer(BaseMessageNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast("BaseMessage", message)
+        if isinstance(x.content, list):  # type: ignore
+            raise ValueError(
+                "The `message.content` provided seems to represent numerous messages. "
+                "Consider iterating over `message.content` and calling .append_message() on each iteration."
+            )
+        return ChatMessage(content=x.content, role="assistant")
+
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        x = cast("BaseMessageChunk", chunk)
+        if isinstance(x.content, list):  # type: ignore
+            raise ValueError(
+                "The `message.content` provided seems to represent numerous messages. "
+                "Consider iterating over `message.content` and calling .append_message() on each iteration."
+            )
+        return ChatMessage(content=x.content, role="assistant")
+
+    def can_normalize(self, message: Any) -> bool:
+        try:
+            from langchain_core.messages import BaseMessage
+
+            return isinstance(message, BaseMessage)
+        except Exception:
+            return False
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        try:
+            from langchain_core.messages import BaseMessageChunk
+
+            return isinstance(chunk, BaseMessageChunk)
+        except Exception:
+            return False
+
+
+class OpenAINormalizer(StringNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast("ChatCompletion", message)
+        return super().normalize(x.choices[0].message.content)
+
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        x = cast("ChatCompletionChunk", chunk)
+        return super().normalize_chunk(x.choices[0].delta.content)
+
+    def can_normalize(self, message: Any) -> bool:
+        try:
+            from openai.types.chat import ChatCompletion
+
+            return isinstance(message, ChatCompletion)
+        except Exception:
+            return False
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        try:
+            from openai.types.chat import ChatCompletionChunk
+
+            return isinstance(chunk, ChatCompletionChunk)
+        except Exception:
+            return False
+
+
+class AnthropicNormalizer(BaseMessageNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast("AnthropicMessage", message)
+        content = x.content[0]
+        if content.type != "text":
+            raise ValueError(
+                f"Anthropic message type {content.type} not supported. "
+                "Only 'text' type is currently supported"
+            )
+        return ChatMessage(content=content.text, role="assistant")
+
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        x = cast("MessageStreamEvent", chunk)
+        content = ""
+        if x.type == "content_block_delta":
+            if x.delta.type != "text_delta":
+                raise ValueError(
+                    f"Anthropic message delta type {x.delta.type} not supported. "
+                    "Only 'text_delta' type is supported"
+                )
+            content = x.delta.text
+
+        return ChatMessage(content=content, role="assistant")
+
+    def can_normalize(self, message: Any) -> bool:
+        try:
+            from anthropic.types import Message as AnthropicMessage
+
+            return isinstance(message, AnthropicMessage)
+        except Exception:
+            return False
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        try:
+            from anthropic.types import (
+                RawContentBlockDeltaEvent,
+                RawContentBlockStartEvent,
+                RawContentBlockStopEvent,
+                RawMessageDeltaEvent,
+                RawMessageStartEvent,
+                RawMessageStopEvent,
+            )
+
+            # The actual MessageStreamEvent is a generic, so isinstance() can't
+            # be used to check the type. Instead, we manually construct the relevant
+            # union of relevant classes...
+            return (
+                isinstance(chunk, RawContentBlockDeltaEvent)
+                or isinstance(chunk, RawContentBlockStartEvent)
+                or isinstance(chunk, RawContentBlockStopEvent)
+                or isinstance(chunk, RawMessageDeltaEvent)
+                or isinstance(chunk, RawMessageStartEvent)
+                or isinstance(chunk, RawMessageStopEvent)
+            )
+        except Exception:
+            return False
+
+
+class GoogleNormalizer(BaseMessageNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast("GenerateContentResponse", message)
+        return ChatMessage(content=x.text, role="assistant")
+
+    def normalize_chunk(self, chunk: Any) -> ChatMessage:
+        x = cast("GenerateContentResponse", chunk)
+        return ChatMessage(content=x.text, role="assistant")
+
+    def can_normalize(self, message: Any) -> bool:
+        try:
+            import google.generativeai.types.generation_types as gtypes  # pyright: ignore[reportMissingTypeStubs, reportMissingImports]
+
+            return isinstance(
+                message,
+                gtypes.GenerateContentResponse,  # pyright: ignore[reportUnknownMemberType]
+            )
+        except Exception:
+            return False
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        return self.can_normalize(chunk)
+
+
+class OllamaNormalizer(DictNormalizer):
+    def normalize(self, message: Any) -> ChatMessage:
+        x = cast("dict[str, Any]", message["message"])
+        return super().normalize(x)
+
+    def normalize_chunk(self, chunk: "dict[str, Any]") -> ChatMessage:
+        msg = cast("dict[str, Any]", chunk["message"])
+        return super().normalize_chunk(msg)
+
+    def can_normalize(self, message: Any) -> bool:
+        try:
+            from ollama import ChatResponse
+
+            # Ollama<0.4 used TypedDict (now it uses pydantic)
+            # https://github.com/ollama/ollama-python/pull/276
+            if isinstance(ChatResponse, dict):
+                return "message" in message and super().can_normalize(
+                    message["message"]
+                )
+            else:
+                return isinstance(message, ChatResponse)
+        except Exception:
+            return False
+
+    def can_normalize_chunk(self, chunk: Any) -> bool:
+        return self.can_normalize(chunk)
+
+
+class NormalizerRegistry:
+    def __init__(self) -> None:
+        # Order of strategies matters (the 1st one that can normalize the message is used)
+        # So make sure to put the most specific strategies first
+        self._strategies: dict[str, BaseMessageNormalizer] = {
+            "openai": OpenAINormalizer(),
+            "anthropic": AnthropicNormalizer(),
+            "google": GoogleNormalizer(),
+            "langchain": LangChainNormalizer(),
+            "ollama": OllamaNormalizer(),
+            "tagify": TagifiableNormalizer(),
+            "dict": DictNormalizer(),
+            "string": StringNormalizer(),
+        }
+
+    def register(
+        self, provider: str, strategy: BaseMessageNormalizer, force: bool = False
+    ) -> None:
+        if provider in self._strategies:
+            if force:
+                del self._strategies[provider]
+            else:
+                raise ValueError(f"Provider {provider} already exists in registry")
+        # Update the strategies dict such that the new strategy is the first to be considered
+        self._strategies = {provider: strategy, **self._strategies}
+
+
+message_normalizer_registry = NormalizerRegistry()
+
+
+def register_custom_normalizer(
+    provider: str, normalizer: BaseMessageNormalizer, force: bool = False
+) -> None:
+    """
+    Register a custom normalizer for handling specific message types.
+
+    Parameters
+    ----------
+    provider : str
+        A unique identifier for this normalizer in the registry
+    normalizer : BaseMessageNormalizer
+        A normalizer instance that can handle your specific message type
+    force : bool, optional
+        Whether to override an existing normalizer with the same provider name,
+        by default False
+
+    Examples
+    --------
+    >>> class MyCustomMessage:
+    ...     def __init__(self, content):
+    ...         self.content = content
+    ...
+    >>> class MyCustomNormalizer(StringNormalizer):
+    ...     def normalize(self, message):
+    ...         return ChatMessage(content=message.content, role="assistant")
+    ...     def can_normalize(self, message):
+    ...         return isinstance(message, MyCustomMessage)
+    ...
+    >>> register_custom_normalizer("my_provider", MyCustomNormalizer())
+    """
+    message_normalizer_registry.register(provider, normalizer, force)
+
+
+def normalize_message(message: Any) -> ChatMessage:
+    strategies = message_normalizer_registry._strategies
+    for strategy in strategies.values():
+        if strategy.can_normalize(message):
+            return strategy.normalize(message)
+    raise ValueError(
+        f"Could not find a normalizer for message of type {type(message)}: {message}. "
+        "Consider registering a custom normalizer via shiny.ui._chat_types.registry.register()"
+    )
+
+
+def normalize_message_chunk(chunk: Any) -> ChatMessage:
+    strategies = message_normalizer_registry._strategies
+    for strategy in strategies.values():
+        if strategy.can_normalize_chunk(chunk):
+            return strategy.normalize_chunk(chunk)
+    raise ValueError(
+        f"Could not find a normalizer for message chunk of type {type(chunk)}: {chunk}. "
+        "Consider registering a custom normalizer via shiny.ui._chat_normalize.register_custom_normalizer()"
+    )

shinychat/_chat_provider_types.py

@@ -0,0 +1,127 @@
+import sys
+from typing import TYPE_CHECKING, Literal, Union
+
+from ._chat_types import ChatMessageDict
+
+if TYPE_CHECKING:
+    from anthropic.types import MessageParam as AnthropicMessage
+    from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+    from ollama import Message as OllamaMessage
+    from openai.types.chat import (
+        ChatCompletionAssistantMessageParam,
+        ChatCompletionSystemMessageParam,
+        ChatCompletionUserMessageParam,
+    )
+
+    if sys.version_info >= (3, 9):
+        import google.generativeai.types as gtypes  # pyright: ignore[reportMissingTypeStubs]
+
+        GoogleMessage = gtypes.ContentDict
+    else:
+        GoogleMessage = object
+
+    LangChainMessage = Union[AIMessage, HumanMessage, SystemMessage]
+    OpenAIMessage = Union[
+        ChatCompletionAssistantMessageParam,
+        ChatCompletionSystemMessageParam,
+        ChatCompletionUserMessageParam,
+    ]
+
+    ProviderMessage = Union[
+        AnthropicMessage, GoogleMessage, LangChainMessage, OpenAIMessage, OllamaMessage
+    ]
+else:
+    AnthropicMessage = GoogleMessage = LangChainMessage = OpenAIMessage = (
+        OllamaMessage
+    ) = ProviderMessage = object
+
+ProviderMessageFormat = Literal[
+    "anthropic",
+    "google",
+    "langchain",
+    "openai",
+    "ollama",
+]
+
+
+# TODO: use a strategy pattern to allow others to register
+# their own message formats
+def as_provider_message(
+    message: ChatMessageDict, format: ProviderMessageFormat
+) -> "ProviderMessage":
+    if format == "anthropic":
+        return as_anthropic_message(message)
+    if format == "google":
+        return as_google_message(message)
+    if format == "langchain":
+        return as_langchain_message(message)
+    if format == "openai":
+        return as_openai_message(message)
+    if format == "ollama":
+        return as_ollama_message(message)
+    raise ValueError(f"Unknown format: {format}")
+
+
+def as_anthropic_message(message: ChatMessageDict) -> "AnthropicMessage":
+    from anthropic.types import MessageParam as AnthropicMessage
+
+    if message["role"] == "system":
+        raise ValueError(
+            "Anthropic requires a system prompt to be specified in the `.create()` method"
+        )
+    return AnthropicMessage(content=message["content"], role=message["role"])
+
+
+def as_google_message(message: ChatMessageDict) -> "GoogleMessage":
+    if sys.version_info < (3, 9):
+        raise ValueError("Google requires Python 3.9")
+
+    import google.generativeai.types as gtypes  # pyright: ignore[reportMissingTypeStubs]
+
+    role = message["role"]
+
+    if role == "system":
+        raise ValueError(
+            "Google requires a system prompt to be specified in the `GenerativeModel()` constructor."
+        )
+    elif role == "assistant":
+        role = "model"
+    return gtypes.ContentDict(parts=[message["content"]], role=role)
+
+
+def as_langchain_message(message: ChatMessageDict) -> "LangChainMessage":
+    from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+
+    content = message["content"]
+    role = message["role"]
+    if role == "system":
+        return SystemMessage(content=content)
+    if role == "assistant":
+        return AIMessage(content=content)
+    if role == "user":
+        return HumanMessage(content=content)
+    raise ValueError(f"Unknown role: {message['role']}")
+
+
+def as_openai_message(message: ChatMessageDict) -> "OpenAIMessage":
+    from openai.types.chat import (
+        ChatCompletionAssistantMessageParam,
+        ChatCompletionSystemMessageParam,
+        ChatCompletionUserMessageParam,
+    )
+
+    content = message["content"]
+    role = message["role"]
+    if role == "system":
+        return ChatCompletionSystemMessageParam(content=content, role=role)
+    if role == "assistant":
+        return ChatCompletionAssistantMessageParam(content=content, role=role)
+    if role == "user":
+        return ChatCompletionUserMessageParam(content=content, role=role)
+    raise ValueError(f"Unknown role: {role}")
+
+
+def as_ollama_message(message: ChatMessageDict) -> "OllamaMessage":
+    from ollama import Message as OllamaMessage
+
+    return OllamaMessage(content=message["content"], role=message["role"])

shinychat/_chat_tokenizer.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import (
+    AbstractSet,
+    Any,
+    Collection,
+    Literal,
+    Protocol,
+    Union,
+    runtime_checkable,
+)
+
+
+# A duck type for tiktoken.Encoding
+class TiktokenEncoding(Protocol):
+    name: str
+
+    def encode(
+        self,
+        text: str,
+        *,
+        allowed_special: Union[Literal["all"], AbstractSet[str]] = set(),  # noqa: B006
+        disallowed_special: Union[Literal["all"], Collection[str]] = "all",
+    ) -> list[int]: ...
+
+
+# A duck type for tokenizers.Encoding
+@runtime_checkable
+class TokenizersEncoding(Protocol):
+    @property
+    def ids(self) -> list[int]: ...
+
+
+# A duck type for tokenizers.Tokenizer
+class TokenizersTokenizer(Protocol):
+    def encode(
+        self,
+        sequence: Any,
+        pair: Any = None,
+        is_pretokenized: bool = False,
+        add_special_tokens: bool = True,
+    ) -> TokenizersEncoding: ...
+
+
+TokenEncoding = Union[TiktokenEncoding, TokenizersTokenizer]
+
+
+def get_default_tokenizer() -> TokenizersTokenizer:
+    try:
+        from tokenizers import Tokenizer
+
+        return Tokenizer.from_pretrained("bert-base-cased")  # type: ignore
+    except ImportError:
+        raise ImportError(
+            "Failed to download a default tokenizer. "
+            "A tokenizer is required to impose `token_limits` on `chat.messages()`. "
+            "To get a generic default tokenizer, install the `tokenizers` "
+            "package (`pip install tokenizers`). "
+        )
+    except Exception as e:
+        raise RuntimeError(
+            "Failed to download a default tokenizer. "
+            "A tokenizer is required to impose `token_limits` on `chat.messages()`. "
+            "Try manually downloading a tokenizer using "
+            "`tokenizers.Tokenizer.from_pretrained()` and passing it to `ui.Chat()`."
+            f"Error: {e}"
+        ) from e