chainlit 2.7.0__py3-none-any.whl → 2.7.1__py3-none-any.whl

chainlit/llama_index/__init__.py

@@ -1,6 +0,0 @@
-from chainlit.utils import check_module_version
-
-if not check_module_version("llama_index.core", "0.10.15"):
-    raise ValueError(
-        "Expected LlamaIndex version >= 0.10.15. Run `pip install llama_index --upgrade`"
-    )

chainlit/llama_index/callbacks.py

@@ -1,206 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-from literalai import ChatGeneration, CompletionGeneration, GenerationMessage
-from llama_index.core.callbacks import TokenCountingHandler
-from llama_index.core.callbacks.schema import CBEventType, EventPayload
-from llama_index.core.llms import ChatMessage, ChatResponse, CompletionResponse
-from llama_index.core.tools.types import ToolMetadata
-
-from chainlit.context import context_var
-from chainlit.element import Text
-from chainlit.step import Step, StepType
-from chainlit.utils import utc_now
-
-DEFAULT_IGNORE = [
-    CBEventType.CHUNKING,
-    CBEventType.SYNTHESIZE,
-    CBEventType.EMBEDDING,
-    CBEventType.NODE_PARSING,
-    CBEventType.TREE,
-]
-
-
-class LlamaIndexCallbackHandler(TokenCountingHandler):
-    """Base callback handler that can be used to track event starts and ends."""
-
-    steps: Dict[str, Step]
-
-    def __init__(
-        self,
-        event_starts_to_ignore: List[CBEventType] = DEFAULT_IGNORE,
-        event_ends_to_ignore: List[CBEventType] = DEFAULT_IGNORE,
-    ) -> None:
-        """Initialize the base callback handler."""
-        super().__init__(
-            event_starts_to_ignore=event_starts_to_ignore,
-            event_ends_to_ignore=event_ends_to_ignore,
-        )
-
-        self.steps = {}
-
-    def _get_parent_id(self, event_parent_id: Optional[str] = None) -> Optional[str]:
-        if event_parent_id and event_parent_id in self.steps:
-            return event_parent_id
-        elif context_var.get().current_step:
-            return context_var.get().current_step.id
-        else:
-            return None
-
-    def on_event_start(
-        self,
-        event_type: CBEventType,
-        payload: Optional[Dict[str, Any]] = None,
-        event_id: str = "",
-        parent_id: str = "",
-        **kwargs: Any,
-    ) -> str:
-        """Run when an event starts and return id of event."""
-        step_type: StepType = "undefined"
-        step_name: str = event_type.value
-        step_input: Optional[Dict[str, Any]] = payload
-        if event_type == CBEventType.FUNCTION_CALL:
-            step_type = "tool"
-            if payload:
-                metadata: Optional[ToolMetadata] = payload.get(EventPayload.TOOL)
-                if metadata:
-                    step_name = getattr(metadata, "name", step_name)
-                step_input = payload.get(EventPayload.FUNCTION_CALL)
-        elif event_type == CBEventType.RETRIEVE:
-            step_type = "tool"
-        elif event_type == CBEventType.QUERY:
-            step_type = "tool"
-        elif event_type == CBEventType.LLM:
-            step_type = "llm"
-        else:
-            return event_id
-
-        step = Step(
-            name=step_name,
-            type=step_type,
-            parent_id=self._get_parent_id(parent_id),
-            id=event_id,
-        )
-
-        self.steps[event_id] = step
-        step.start = utc_now()
-        step.input = step_input or {}
-        context_var.get().loop.create_task(step.send())
-        return event_id
-
-    def on_event_end(
-        self,
-        event_type: CBEventType,
-        payload: Optional[Dict[str, Any]] = None,
-        event_id: str = "",
-        **kwargs: Any,
-    ) -> None:
-        """Run when an event ends."""
-        step = self.steps.get(event_id, None)
-
-        if payload is None or step is None:
-            return
-
-        step.end = utc_now()
-
-        if event_type == CBEventType.FUNCTION_CALL:
-            response = payload.get(EventPayload.FUNCTION_OUTPUT)
-            if response:
-                step.output = f"{response}"
-                context_var.get().loop.create_task(step.update())
-
-        elif event_type == CBEventType.QUERY:
-            response = payload.get(EventPayload.RESPONSE)
-            source_nodes = getattr(response, "source_nodes", None)
-            if source_nodes:
-                source_refs = ", ".join(
-                    [f"Source {idx}" for idx, _ in enumerate(source_nodes)]
-                )
-                step.elements = [
-                    Text(
-                        name=f"Source {idx}",
-                        content=source.text or "Empty node",
-                        display="side",
-                    )
-                    for idx, source in enumerate(source_nodes)
-                ]
-                step.output = f"Retrieved the following sources: {source_refs}"
-                context_var.get().loop.create_task(step.update())
-
-        elif event_type == CBEventType.RETRIEVE:
-            sources = payload.get(EventPayload.NODES)
-            if sources:
-                source_refs = ", ".join(
-                    [f"Source {idx}" for idx, _ in enumerate(sources)]
-                )
-                step.elements = [
-                    Text(
-                        name=f"Source {idx}",
-                        display="side",
-                        content=source.node.get_text() or "Empty node",
-                    )
-                    for idx, source in enumerate(sources)
-                ]
-                step.output = f"Retrieved the following sources: {source_refs}"
-            context_var.get().loop.create_task(step.update())
-
-        elif event_type == CBEventType.LLM:
-            formatted_messages = payload.get(EventPayload.MESSAGES)  # type: Optional[List[ChatMessage]]
-            formatted_prompt = payload.get(EventPayload.PROMPT)
-            response = payload.get(EventPayload.RESPONSE)
-
-            if formatted_messages:
-                messages = [
-                    GenerationMessage(
-                        role=m.role.value,  # type: ignore
-                        content=m.content or "",
-                    )
-                    for m in formatted_messages
-                ]
-            else:
-                messages = None
-
-            if isinstance(response, ChatResponse):
-                content = response.message.content or ""
-            elif isinstance(response, CompletionResponse):
-                content = response.text
-            else:
-                content = ""
-
-            step.output = content
-
-            token_count = self.total_llm_token_count or None
-            raw_response = response.raw if response else None
-            model = getattr(raw_response, "model", None)
-
-            if messages and isinstance(response, ChatResponse):
-                msg: ChatMessage = response.message
-                step.generation = ChatGeneration(
-                    model=model,
-                    messages=messages,
-                    message_completion=GenerationMessage(
-                        role=msg.role.value,  # type: ignore
-                        content=content,
-                    ),
-                    token_count=token_count,
-                )
-            elif formatted_prompt:
-                step.generation = CompletionGeneration(
-                    model=model,
-                    prompt=formatted_prompt,
-                    completion=content,
-                    token_count=token_count,
-                )
-
-            context_var.get().loop.create_task(step.update())
-
-        else:
-            step.output = payload
-            context_var.get().loop.create_task(step.update())
-
-        self.steps.pop(event_id, None)
-
-    def _noop(self, *args, **kwargs):
-        pass
-
-    start_trace = _noop
-    end_trace = _noop

chainlit/logger.py

@@ -1,16 +0,0 @@
-import logging
-import sys
-
-logging.basicConfig(
-    level=logging.INFO,
-    stream=sys.stdout,
-    format="%(asctime)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-)
-
-logging.getLogger("socketio").setLevel(logging.ERROR)
-logging.getLogger("engineio").setLevel(logging.ERROR)
-logging.getLogger("numexpr").setLevel(logging.ERROR)
-
-
-logger = logging.getLogger("chainlit")

chainlit/markdown.py

@@ -1,57 +0,0 @@
-import os
-from pathlib import Path
-from typing import Optional
-
-from chainlit.logger import logger
-
-from ._utils import is_path_inside
-
-# Default chainlit.md file created if none exists
-DEFAULT_MARKDOWN_STR = """# Welcome to Chainlit! 🚀🤖
-
-Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
-
-## Useful Links 🔗
-
-- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
-- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬
-
-We can't wait to see what you create with Chainlit! Happy coding! 💻😊
-
-## Welcome screen
-
-To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.
-"""
-
-
-def init_markdown(root: str):
-    """Initialize the chainlit.md file if it doesn't exist."""
-    chainlit_md_file = os.path.join(root, "chainlit.md")
-
-    if not os.path.exists(chainlit_md_file):
-        with open(chainlit_md_file, "w", encoding="utf-8") as f:
-            f.write(DEFAULT_MARKDOWN_STR)
-            logger.info(f"Created default chainlit markdown file at {chainlit_md_file}")
-
-
-def get_markdown_str(root: str, language: str) -> Optional[str]:
-    """Get the chainlit.md file as a string."""
-    root_path = Path(root)
-    translated_chainlit_md_path = root_path / f"chainlit_{language}.md"
-    default_chainlit_md_path = root_path / "chainlit.md"
-
-    if (
-        is_path_inside(translated_chainlit_md_path, root_path)
-        and translated_chainlit_md_path.is_file()
-    ):
-        chainlit_md_path = translated_chainlit_md_path
-    else:
-        chainlit_md_path = default_chainlit_md_path
-        logger.warning(
-            f"Translated markdown file for {language} not found. Defaulting to chainlit.md."
-        )
-
-    if chainlit_md_path.is_file():
-        return chainlit_md_path.read_text(encoding="utf-8")
-    else:
-        return None

chainlit/mcp.py

@@ -1,99 +0,0 @@
-import shlex
-from typing import Dict, Literal, Optional, Union
-
-from pydantic import BaseModel
-
-from chainlit.config import config
-
-
-class StdioMcpConnection(BaseModel):
-    name: str
-    command: str
-    args: list[str]
-    clientType: Literal["stdio"] = "stdio"
-
-
-class SseMcpConnection(BaseModel):
-    name: str
-    url: str
-    headers: Optional[Dict[str, str]] = None
-    clientType: Literal["sse"] = "sse"
-
-
-class HttpMcpConnection(BaseModel):
-    name: str
-    url: str
-    headers: Optional[Dict[str, str]] = None
-    clientType: Literal["streamable-http"] = "streamable-http"
-
-
-McpConnection = Union[StdioMcpConnection, SseMcpConnection, HttpMcpConnection]
-
-
-def validate_mcp_command(command_string: str):
-    """
-    Validates that a command string uses command in the allowed list as the executable and returns
-    the executable and list of arguments suitable for subprocess calls.
-
-    This function handles potential command prefixes, flags, and options
-    to ensure only commands in allowed list are allowed.
-
-    Args:
-        command_string (str): The full command string to validate
-
-    Returns:
-        tuple: (env, executable, args_list) where:
-            - env (dict): Environment variables as a dictionary
-            - executable (str): The executable name or path
-            - args_list (list): List of command arguments
-
-    Raises:
-        ValueError: If the command doesn't use an allowed executable
-    """
-    # Split the command string into parts while respecting quotes and escapes
-    # Using shlex.split provides POSIX-compatible parsing so that arguments
-    # wrapped in quotes (e.g. "--header \"Authorization: Bearer TOKEN\"")
-    # or environment variable assignments such as
-    # MY_VAR="value with spaces" are preserved as single list items.
-    # On Windows, shlex also works as long as posix=False is not required for
-    # our use-case (Chainlit targets POSIX-style shells for the MCP command).
-    try:
-        parts = shlex.split(command_string, posix=True)
-    except ValueError as exc:
-        # Provide a clearer error message when the command cannot be parsed
-        raise ValueError(f"Invalid command string: {exc}") from exc
-
-    if not parts:
-        raise ValueError("Empty command string")
-
-    # Look for the actual executable in the command
-    executable = None
-    executable_index = None
-    allowed_executables = config.features.mcp.stdio.allowed_executables
-    for i, part in enumerate(parts):
-        # Remove any path components to get the base executable name
-        base_exec = part.split("/")[-1].split("\\")[-1]
-        if allowed_executables is None or base_exec in allowed_executables:
-            executable = part
-            executable_index = i
-            break
-
-    if executable is None or executable_index is None:
-        raise ValueError(
-            f"Only commands in ({', '.join(allowed_executables)}) are allowed"
-            if allowed_executables
-            else "No allowed executables found"
-        )
-
-    # Return `executable` as the executable and everything after it as args
-    args_list = parts[executable_index + 1 :]
-    env_list = parts[:executable_index]
-    env = {}
-    for env_var in env_list:
-        if "=" in env_var:
-            key, value = env_var.split("=", 1)
-            env[key] = value
-        else:
-            raise ValueError(f"Invalid environment variable format: {env_var}")
-
-    return env, executable, args_list