lionagi 0.16.2__py3-none-any.whl → 0.16.3__py3-none-any.whl

lionagi/models/note.py

@@ -1,387 +0,0 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import ItemsView, Iterator, ValuesView
-from typing import Any, TypeAlias
-
-from pydantic import BaseModel, ConfigDict, Field, field_serializer
-from typing_extensions import override
-
-from lionagi.libs.nested.flatten import flatten
-from lionagi.utils import UNDEFINED, copy, to_list
-
-IndiceType: TypeAlias = str | list[str | int]
-
-
-class Note(BaseModel):
-    """Container for managing nested dictionary data structures.
-
-    A flexible container that provides deep nested data access, dictionary-like
-    interface, flattening capabilities, and update operations for managing
-    complex nested data structures.
-
-    Args:
-        **kwargs: Key-value pairs for initial content.
-
-    Attributes:
-        content: Nested dictionary structure.
-        model_config: Configuration allowing arbitrary types.
-
-    Examples:
-        >>> note = Note(
-        ...     user={
-        ...         "name": "John",
-        ...         "settings": {
-        ...             "theme": "dark"
-        ...         }
-        ...     }
-        ... )
-        >>>
-        >>> # Access nested data
-        >>> name = note.get(["user", "name"])
-        >>> theme = note["user"]["settings"]["theme"]
-        >>>
-        >>> # Update nested structure
-        >>> note.update(["user", "settings"], {"language": "en"})
-    """
-
-    content: dict[str, Any] = Field(
-        default_factory=dict
-    )  # Nested data structure
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        use_enum_values=True,
-        populate_by_name=True,
-    )
-
-    def __init__(self, **kwargs: Any) -> None:
-        """Initialize Note with dictionary data.
-
-        Args:
-            **kwargs: Key-value pairs that will form the initial nested
-                dictionary structure.
-        """
-        super().__init__()
-        self.content = kwargs
-
-    @field_serializer("content")
-    def _serialize_content(self, value: Any) -> dict[str, Any]:
-        """Serialize content to dictionary format.
-
-        Args:
-            value: Content to serialize
-
-        Returns:
-            Deep copy of content dictionary
-        """
-        output_dict = copy(value, deep=True)
-        return output_dict
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert Note to dictionary, excluding undefined values.
-
-        Returns:
-            Dictionary representation with UNDEFINED values removed
-        """
-        out = copy(self.content)
-        for k, v in self.content.items():
-            if v is UNDEFINED:
-                out.pop(k)
-        return out
-
-    def pop(
-        self,
-        indices: IndiceType,
-        /,
-        default: Any = UNDEFINED,
-    ) -> Any:
-        """Remove and return item from nested structure.
-
-        Removes and returns the value at the specified path in the nested
-        structure. If the path doesn't exist and no default is provided,
-        raises KeyError.
-
-        Args:
-            indices: Path to the item to remove, can be a string for top-level
-                keys or a list for nested access.
-            default: Value to return if the path is not found. If not provided
-                and path is not found, raises KeyError.
-
-        Returns:
-            The value that was removed, or the default value if provided and
-            path not found.
-
-        Raises:
-            KeyError: If the path is not found and no default value is provided.
-        """
-        from lionagi.libs.nested.npop import npop
-
-        indices = to_list(indices, flatten=True, dropna=True)
-        return npop(self.content, indices, default)
-
-    def insert(self, indices: IndiceType, value: Any, /) -> None:
-        """Insert value into nested structure at specified indices.
-
-        Args:
-            indices: Path where to insert
-            value: Value to insert
-        """
-        from lionagi.libs.nested.ninsert import ninsert
-
-        indices = to_list(indices, flatten=True, dropna=True)
-        ninsert(self.content, indices, value)
-
-    def set(self, indices: IndiceType, value: Any, /) -> None:
-        """Set value in nested structure at specified indices.
-
-        Args:
-            indices: Path where to set
-            value: Value to set
-        """
-        indices = to_list(indices, flatten=True, dropna=True)
-        if self.get(indices, None) is None:
-            self.insert(indices, value)
-        else:
-            from lionagi.libs.nested.nset import nset
-
-            nset(self.content, indices, value)
-
-    def get(
-        self,
-        indices: IndiceType,
-        /,
-        default: Any = UNDEFINED,
-    ) -> Any:
-        """Get value from nested structure at specified indices.
-
-        Retrieves the value at the specified path in the nested structure.
-        If the path doesn't exist and no default is provided, raises KeyError.
-
-        Args:
-            indices: Path to the value, can be a string for top-level keys
-                or a list for nested access.
-            default: Value to return if the path is not found. If not provided
-                and path is not found, raises KeyError.
-
-        Returns:
-            The value at the specified path, or the default value if provided
-            and path not found.
-
-        Raises:
-            KeyError: If the path is not found and no default value is provided.
-        """
-        from lionagi.libs.nested.nget import nget
-
-        indices = to_list(indices, flatten=True, dropna=True)
-        return nget(self.content, indices, default)
-
-    def keys(self, /, flat: bool = False, **kwargs: Any) -> list:
-        """Get keys of the Note.
-
-        Args:
-            flat: If True, return flattened keys
-            kwargs: Additional flattening options
-
-        Returns:
-            List of keys, optionally flattened
-        """
-        if flat:
-            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
-            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
-            return flatten(self.content, **kwargs).keys()
-        return list(self.content.keys())
-
-    def values(self, /, flat: bool = False, **kwargs: Any) -> ValuesView:
-        """Get values of the Note.
-
-        Returns either a view of top-level values or, if flat=True, a view
-        of all values in the flattened nested structure.
-
-        Args:
-            flat: If True, returns values from all levels of the nested
-                structure. If False, returns only top-level values.
-            kwargs: Additional options for flattening behavior when flat=True.
-                Common options include coerce_keys and coerce_sequence.
-
-        Returns:
-            A ValuesView object containing either top-level values or all
-            values from the flattened structure if flat=True.
-        """
-        if flat:
-            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
-            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
-            return flatten(self.content, **kwargs).values()
-        return self.content.values()
-
-    def items(self, /, flat: bool = False, **kwargs: Any) -> ItemsView:
-        """Get items of the Note.
-
-        Args:
-            flat: If True, return flattened items
-            kwargs: Additional flattening options
-
-        Returns:
-            View of items, optionally flattened
-        """
-        if flat:
-            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
-            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
-            return flatten(self.content, **kwargs).items()
-        return self.content.items()
-
-    def clear(self) -> None:
-        """Clear all content."""
-        self.content.clear()
-
-    def update(
-        self,
-        indices: IndiceType,
-        value: Any,
-    ) -> None:
-        """Update nested structure at specified indices.
-
-        Updates the value at the specified path in the nested structure.
-        The behavior depends on the existing value and the update value:
-        - If path doesn't exist: creates it with value (wrapped in list if scalar)
-        - If existing is list: extends with value if list, appends if scalar
-        - If existing is dict: updates with value if dict, raises error if not
-
-        Args:
-            indices: Path to the location to update, can be a string for
-                top-level keys or a list for nested access.
-            value: The new value to set. Must be compatible with existing
-                value type (dict for dict, any value for list).
-
-        Raises:
-            ValueError: If trying to update a dictionary with a non-dictionary
-                value.
-        """
-        existing = None
-        if not indices:
-            existing = self.content
-        else:
-            existing = self.get(indices, None)
-
-        if existing is None:
-            if not isinstance(value, (list, dict)):
-                value = [value]
-            self.set(indices, value)
-
-        if isinstance(existing, list):
-            if isinstance(value, list):
-                existing.extend(value)
-            else:
-                existing.append(value)
-
-        elif isinstance(existing, dict):
-            if isinstance(value, self.__class__):
-                value = value.content
-
-            if isinstance(value, dict):
-                existing.update(value)
-            else:
-                raise ValueError(
-                    "Cannot update a dictionary with a non-dictionary value."
-                )
-
-    @classmethod
-    def from_dict(cls, kwargs: Any) -> "Note":
-        """Create Note instance from dictionary.
-
-        Args:
-            kwargs: Dictionary to initialize with
-
-        Returns:
-            New Note instance
-        """
-        return cls(**kwargs)
-
-    def __contains__(self, indices: IndiceType) -> bool:
-        """Check if indices exist in content.
-
-        Implements the 'in' operator for checking path existence in the nested
-        structure.
-
-        Args:
-            indices: Path to check, can be a string for top-level keys or a
-                list for nested access.
-
-        Returns:
-            True if the path exists in the nested structure, False otherwise.
-        """
-        return self.content.get(indices, UNDEFINED) is not UNDEFINED
-
-    def __len__(self) -> int:
-        """Get length of content.
-
-        Implements len() function to return the number of top-level keys in
-        the nested structure.
-
-        Returns:
-            The number of top-level keys in the content dictionary.
-        """
-        return len(self.content)
-
-    def __iter__(self) -> Iterator[str]:
-        """Get iterator over content.
-
-        Returns:
-            Iterator over top-level keys
-        """
-        return iter(self.content)
-
-    def __next__(self) -> str:
-        """Get next item from content iterator.
-
-        Returns:
-            Next key in iteration
-        """
-        return next(iter(self.content))
-
-    @override
-    def __str__(self) -> str:
-        """Get string representation of content.
-
-        Implements str() function to provide a simple string representation
-        of the Note's content. Uses the standard dictionary string format.
-
-        Returns:
-            A string representation of the content dictionary, showing its
-            current state.
-        """
-        return str(self.content)
-
-    @override
-    def __repr__(self) -> str:
-        """Get detailed string representation of content.
-
-        Returns:
-            Detailed string representation of content dict
-        """
-        return repr(self.content)
-
-    def __getitem__(self, indices: IndiceType) -> Any:
-        """Get item using index notation.
-
-        Args:
-            indices: Path to value
-
-        Returns:
-            Value at path
-
-        Raises:
-            KeyError: If path not found
-        """
-        indices = to_list(indices, flatten=True, dropna=True)
-        return self.get(indices)
-
-    def __setitem__(self, indices: IndiceType, value: Any) -> None:
-        """Set item using index notation.
-
-        Args:
-            indices: Path where to set
-            value: Value to set
-        """
-        self.set(indices, value)

lionagi/service/connections/providers/claude_code_.py

@@ -1,299 +0,0 @@
-# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import warnings
-
-from pydantic import BaseModel
-
-from lionagi import ln
-from lionagi.libs.schema.as_readable import as_readable
-from lionagi.service.connections.endpoint import Endpoint
-from lionagi.service.connections.endpoint_config import EndpointConfig
-from lionagi.utils import to_dict, to_list
-
-from ...third_party.claude_code import (
-    CLAUDE_CODE_OPTION_PARAMS,
-    HAS_CLAUDE_CODE_SDK,
-    ClaudeCodeRequest,
-    ClaudePermission,
-    stream_cc_sdk_events,
-)
-
-__all__ = (
-    "ClaudeCodeRequest",
-    "CLAUDE_CODE_OPTION_PARAMS",  # backward compatibility
-    "ClaudePermission",  # backward compatibility
-    "ClaudeCodeEndpoint",
-)
-
-
-# --------------------------------------------------------------------------- SDK endpoint
-
-_get_config = lambda: EndpointConfig(
-    name="claude_code",
-    provider="claude_code",
-    base_url="internal",
-    endpoint="query",
-    request_options=ClaudeCodeRequest,
-    timeout=3000,
-    api_key="dummy-key",
-)
-
-
-ENDPOINT_CONFIG = _get_config()  # backward compatibility
-
-
-class ClaudeCodeEndpoint(Endpoint):
-    """Direct Python-SDK (non-CLI) endpoint - unchanged except for bug-fixes."""
-
-    def __init__(self, config: EndpointConfig = None, **kwargs):
-        if not HAS_CLAUDE_CODE_SDK:
-            raise ImportError(
-                "claude_code_sdk is not installed. "
-                "Please install it with `uv pip install lionagi[claude_code_sdk]`."
-            )
-        warnings.warn(
-            "The claude_code `query` endpoint is deprecated. Use `query_cli` endpoint instead.",
-            DeprecationWarning,
-        )
-
-        config = config or _get_config()
-        super().__init__(config=config, **kwargs)
-
-    def create_payload(self, request: dict | BaseModel, **kwargs):
-        req_dict = {**self.config.kwargs, **to_dict(request), **kwargs}
-        messages = req_dict.pop("messages")
-        req_obj = ClaudeCodeRequest.create(messages=messages, **req_dict)
-        return {"request": req_obj}, {}
-
-    async def stream(self, request: dict | BaseModel, **kwargs):
-        payload, _ = self.create_payload(request, **kwargs)
-        async for chunk in stream_cc_sdk_events(payload["request"]):
-            yield chunk
-
-    def _parse_claude_code_response(self, responses: list) -> dict:
-        """Parse Claude Code responses into a clean chat completions-like format.
-
-        Claude Code returns a list of messages:
-        - SystemMessage: initialization info
-        - AssistantMessage(s): actual assistant responses with content blocks
-        - UserMessage(s): for tool use interactions
-        - ResultMessage: final result with metadata
-
-        When Claude Code uses tools, the ResultMessage.result may be None.
-        In that case, we need to look at the tool results in UserMessages.
-        """
-        results = {
-            "session_id": None,
-            "model": "claude-code",
-            "result": "",
-            "tool_uses": [],
-            "tool_results": [],
-            "is_error": False,
-            "num_turns": None,
-            "total_cost_usd": None,
-            "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0,
-            },
-        }
-        from claude_code_sdk import types as cc_types
-
-        for response in responses:
-            if isinstance(response, cc_types.SystemMessage):
-                results["session_id"] = response.data.get("session_id")
-                results["model"] = response.data.get("model", "claude-code")
-            if isinstance(
-                response, cc_types.AssistantMessage | cc_types.UserMessage
-            ):
-                for block in to_list(
-                    response.content,
-                    flatten=True,
-                    flatten_tuple_set=True,
-                    dropna=True,
-                ):
-                    if isinstance(block, cc_types.TextBlock):
-                        results["result"] += block.text.strip() + "\n"
-
-                    if isinstance(block, cc_types.ToolUseBlock):
-                        entry = {
-                            "id": block.id,
-                            "name": block.name,
-                            "input": block.input,
-                        }
-                        results["tool_uses"].append(entry)
-
-                    if isinstance(block, cc_types.ToolResultBlock):
-                        results["tool_results"].append(
-                            {
-                                "tool_use_id": block.tool_use_id,
-                                "content": block.content,
-                                "is_error": block.is_error,
-                            }
-                        )
-
-            if isinstance(response, cc_types.ResultMessage):
-                if response.result:
-                    results["result"] = str(response.result).strip()
-                results["usage"] = response.usage
-                results["is_error"] = response.is_error
-                results["total_cost_usd"] = response.total_cost_usd
-                results["num_turns"] = response.num_turns
-                results["duration_ms"] = response.duration_ms
-                results["duration_api_ms"] = response.duration_api_ms
-
-        return results
-
-    async def _call(
-        self,
-        payload: dict,
-        headers: dict,
-        **kwargs,
-    ):
-        from claude_code_sdk import query as sdk_query
-        from claude_code_sdk import types as cc_types
-
-        responses = []
-        request: ClaudeCodeRequest = payload["request"]
-        system: cc_types.SystemMessage = None
-
-        # 1. stream the Claude Code response
-        async for chunk in self._stream_claude_code(**payload):
-            if request.verbose_output:
-                _display_message(chunk, theme=request.cli_display_theme)
-
-            if isinstance(chunk, cc_types.SystemMessage):
-                system = chunk
-            responses.append(chunk)
-
-        # 2. If the last response is not a ResultMessage and auto_finish is True,
-        #   we need to query Claude Code again to get the final result message.
-        if request.auto_finish and not isinstance(
-            responses[-1], cc_types.ResultMessage
-        ):
-            options = request.as_claude_options()
-            options.continue_conversation = True
-            options.max_turns = 1
-            if system:
-                options.resume = (
-                    system.data.get("session_id", None) if system else None
-                )
-
-            async for chunk in sdk_query(
-                prompt="Please provide a the final result message only",
-                options=options,
-            ):
-                if isinstance(chunk, cc_types.ResultMessage):
-                    if request.verbose_output:
-                        str_ = _verbose_output(chunk)
-                        if str_:
-                            as_readable(
-                                str_,
-                                md=True,
-                                display_str=True,
-                                format_curly=True,
-                                max_panel_width=100,
-                                theme=request.cli_display_theme,
-                            )
-
-                    responses.append(chunk)
-
-
-def _display_message(chunk, theme):
-    from claude_code_sdk import types as cc_types
-
-    if isinstance(
-        chunk,
-        cc_types.SystemMessage
-        | cc_types.AssistantMessage
-        | cc_types.UserMessage,
-    ):
-        str_ = _verbose_output(chunk)
-        if str_:
-            if str_.startswith("Claude:"):
-                as_readable(
-                    str_,
-                    md=True,
-                    display_str=True,
-                    max_panel_width=100,
-                    theme=theme,
-                )
-            else:
-                as_readable(
-                    str_,
-                    format_curly=True,
-                    display_str=True,
-                    max_panel_width=100,
-                    theme=theme,
-                )
-
-    if isinstance(chunk, cc_types.ResultMessage):
-        str_ = _verbose_output(chunk)
-        as_readable(
-            str_,
-            md=True,
-            display_str=True,
-            format_curly=True,
-            max_panel_width=100,
-            theme=theme,
-        )
-
-
-def _verbose_output(res) -> str:
-    from claude_code_sdk import types as cc_types
-
-    str_ = ""
-    if isinstance(res, cc_types.SystemMessage):
-        str_ = f"Claude Code Session Started: {res.data.get('session_id', 'unknown')}"
-        str_ += f"\nModel: {res.data.get('model', 'claude-code')}\n---"
-        return str_
-
-    if isinstance(res, cc_types.AssistantMessage | cc_types.UserMessage):
-        for block in to_list(
-            res.content, flatten=True, flatten_tuple_set=True, dropna=True
-        ):
-            if isinstance(block, cc_types.TextBlock):
-                text = (
-                    block.text.strip() if isinstance(block.text, str) else ""
-                )
-                str_ += f"Claude:\n{text}"
-
-            if isinstance(block, cc_types.ToolUseBlock):
-                inp_ = None
-
-                if isinstance(block.input, dict | list):
-                    inp_ = ln.json_dumps(
-                        block.input,
-                        pretty=True,
-                        sort_keys=True,
-                        append_newline=True,
-                    )
-                else:
-                    inp_ = str(block.input)
-
-                input = inp_[:200] + "..." if len(inp_) > 200 else inp_
-                str_ += (
-                    f"Tool Use: {block.name} - {block.id}\n  - Input: {input}"
-                )
-
-            if isinstance(block, cc_types.ToolResultBlock):
-                content = str(block.content)
-                content = (
-                    content[:200] + "..." if len(content) > 200 else content
-                )
-                str_ += (
-                    f"Tool Result: {block.tool_use_id}\n  - Content: {content}"
-                )
-        return str_
-
-    if isinstance(res, cc_types.ResultMessage):
-        str_ += f"Session Completion - {res.session_id}"
-        str_ += f"\nResult: {res.result or 'No result'}"
-        str_ += f"\n- Cost: ${res.total_cost_usd:.4f} USD"
-        str_ += f"\n- Duration: {res.duration_ms} ms (API: {res.duration_api_ms} ms)"
-        str_ += f"\n- Turns: {res.num_turns}"
-        return str_