sqlsaber 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

sqlsaber/clients/models.py

@@ -1,282 +0,0 @@
-"""Data models for LLM client requests and responses."""
-
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any
-
-
-class MessageRole(str, Enum):
-    """Message roles in a conversation."""
-
-    USER = "user"
-    ASSISTANT = "assistant"
-    SYSTEM = "system"
-
-
-class ContentType(str, Enum):
-    """Content block types."""
-
-    TEXT = "text"
-    IMAGE = "image"
-    TOOL_USE = "tool_use"
-    TOOL_RESULT = "tool_result"
-
-
-class ToolChoiceType(str, Enum):
-    """Tool choice types."""
-
-    AUTO = "auto"
-    ANY = "any"
-    TOOL = "tool"
-    NONE = "none"
-
-
-class StopReason(str, Enum):
-    """Stop reasons for message completion."""
-
-    END_TURN = "end_turn"
-    MAX_TOKENS = "max_tokens"
-    STOP_SEQUENCE = "stop_sequence"
-    TOOL_USE = "tool_use"
-
-
-@dataclass
-class ContentBlock:
-    """A content block in a message."""
-
-    type: ContentType
-    content: str | dict[str, Any]
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary format."""
-        if self.type == ContentType.TEXT:
-            return {"type": "text", "text": self.content}
-        elif self.type == ContentType.TOOL_USE:
-            return {
-                "type": "tool_use",
-                "id": self.content["id"],
-                "name": self.content["name"],
-                "input": self.content["input"],
-            }
-        elif self.type == ContentType.TOOL_RESULT:
-            return {
-                "type": "tool_result",
-                "tool_use_id": self.content["tool_use_id"],
-                "content": self.content["content"],
-            }
-        else:
-            return {"type": self.type.value, **self.content}
-
-
-@dataclass
-class Message:
-    """A message in a conversation."""
-
-    role: MessageRole
-    content: str | list[ContentBlock]
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary format for API requests."""
-        if isinstance(self.content, str):
-            return {"role": self.role.value, "content": self.content}
-        else:
-            return {
-                "role": self.role.value,
-                "content": [block.to_dict() for block in self.content],
-            }
-
-
-@dataclass
-class ToolDefinition:
-    """Definition of a tool that can be called."""
-
-    name: str
-    description: str
-    input_schema: dict[str, Any]
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary format for API requests."""
-        return {
-            "name": self.name,
-            "description": self.description,
-            "input_schema": self.input_schema,
-        }
-
-
-@dataclass
-class ToolChoice:
-    """Tool choice configuration."""
-
-    type: ToolChoiceType
-    name: str | None = None
-    disable_parallel_tool_use: bool = False
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary format for API requests."""
-        result = {"type": self.type.value}
-        if self.name:
-            result["name"] = self.name
-        if self.disable_parallel_tool_use:
-            result["disable_parallel_tool_use"] = True
-        return result
-
-
-@dataclass
-class CreateMessageRequest:
-    """Request to create a message."""
-
-    model: str
-    messages: list[Message]
-    max_tokens: int
-    system: str | None = None
-    tools: list[ToolDefinition] | None = None
-    tool_choice: ToolChoice | None = None
-    temperature: float | None = None
-    stream: bool = False
-    stop_sequences: list[str] | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary format for API requests."""
-        data = {
-            "model": self.model,
-            "messages": [msg.to_dict() for msg in self.messages],
-            "max_tokens": self.max_tokens,
-        }
-
-        if self.system:
-            data["system"] = self.system
-        if self.tools:
-            data["tools"] = [tool.to_dict() for tool in self.tools]
-        if self.tool_choice:
-            data["tool_choice"] = self.tool_choice.to_dict()
-        if self.temperature is not None:
-            data["temperature"] = self.temperature
-        if self.stream:
-            data["stream"] = True
-        if self.stop_sequences:
-            data["stop_sequences"] = self.stop_sequences
-
-        return data
-
-
-@dataclass
-class Usage:
-    """Token usage information."""
-
-    input_tokens: int
-    output_tokens: int
-
-
-@dataclass
-class MessageResponse:
-    """Response from message creation."""
-
-    id: str
-    model: str
-    role: MessageRole
-    content: list[ContentBlock]
-    stop_reason: StopReason
-    stop_sequence: str | None
-    usage: Usage
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "MessageResponse":
-        """Create from API response dictionary."""
-        content_blocks = []
-        for block_data in data["content"]:
-            if block_data["type"] == "text":
-                content_blocks.append(
-                    ContentBlock(ContentType.TEXT, block_data["text"])
-                )
-            elif block_data["type"] == "tool_use":
-                content_blocks.append(
-                    ContentBlock(
-                        ContentType.TOOL_USE,
-                        {
-                            "id": block_data["id"],
-                            "name": block_data["name"],
-                            "input": block_data["input"],
-                        },
-                    )
-                )
-
-        return cls(
-            id=data["id"],
-            model=data["model"],
-            role=MessageRole(data["role"]),
-            content=content_blocks,
-            stop_reason=StopReason(data["stop_reason"]),
-            stop_sequence=data.get("stop_sequence"),
-            usage=Usage(
-                input_tokens=data["usage"]["input_tokens"],
-                output_tokens=data["usage"]["output_tokens"],
-            ),
-        )
-
-
-# Stream event types and data models for streaming
-@dataclass
-class StreamEventData:
-    """Base class for stream event data."""
-
-    pass
-
-
-@dataclass
-class TextDeltaData(StreamEventData):
-    """Text delta stream event data."""
-
-    text: str
-
-
-@dataclass
-class ToolUseStartData(StreamEventData):
-    """Tool use start stream event data."""
-
-    id: str
-    name: str
-
-
-@dataclass
-class ToolUseInputData(StreamEventData):
-    """Tool use input stream event data."""
-
-    partial_json: str
-
-
-@dataclass
-class MessageStartData(StreamEventData):
-    """Message start stream event data."""
-
-    message: dict[str, Any]
-
-
-@dataclass
-class MessageDeltaData(StreamEventData):
-    """Message delta stream event data."""
-
-    delta: dict[str, Any]
-    usage: dict[str, Any] | None = None
-
-
-@dataclass
-class ContentBlockStartData(StreamEventData):
-    """Content block start stream event data."""
-
-    index: int
-    content_block: dict[str, Any]
-
-
-@dataclass
-class ContentBlockDeltaData(StreamEventData):
-    """Content block delta stream event data."""
-
-    index: int
-    delta: dict[str, Any]
-
-
-@dataclass
-class ContentBlockStopData(StreamEventData):
-    """Content block stop stream event data."""
-
-    index: int

sqlsaber/clients/streaming.py

@@ -1,257 +0,0 @@
-"""Streaming adapters and utilities for LLM clients."""
-
-import asyncio
-import json
-import logging
-from typing import Any, AsyncIterator
-
-logger = logging.getLogger(__name__)
-
-
-class AnthropicStreamAdapter:
-    """Adapter to convert raw Anthropic stream events to standardized format.
-
-    This adapter converts the raw SSE events from Anthropic API into objects
-    that match the structure expected by the current AnthropicSQLAgent.
-    """
-
-    def __init__(self):
-        self.content_blocks: list[dict[str, Any]] = []
-        self.tool_use_blocks: list[dict[str, Any]] = []
-
-    async def process_stream(
-        self,
-        raw_stream: AsyncIterator[dict[str, Any]],
-        cancellation_token: asyncio.Event | None = None,
-    ) -> AsyncIterator[Any]:
-        """Process raw stream events and yield adapted events.
-
-        Args:
-            raw_stream: Raw stream events from the API
-            cancellation_token: Optional cancellation token
-
-        Yields:
-            Adapted stream events that match the SDK format
-        """
-        async for raw_event in raw_stream:
-            # Check for cancellation
-            if cancellation_token is not None and cancellation_token.is_set():
-                return
-
-            # Convert raw event to SDK-like event
-            adapted_event = self._adapt_event(raw_event)
-            if adapted_event:
-                yield adapted_event
-
-    def _adapt_event(self, raw_event: dict[str, Any]) -> Any | None:
-        """Adapt a raw stream event to match SDK format.
-
-        Args:
-            raw_event: Raw event from the API
-
-        Returns:
-            Adapted event object or None if event should be filtered
-        """
-        event_type = raw_event.get("type")
-        event_data = raw_event.get("data", {})
-
-        if event_type == "ping":
-            # Create a ping event object
-            return PingEvent()
-
-        elif event_type == "message_start":
-            # Create message start event
-            return MessageStartEvent(event_data.get("message", {}))
-
-        elif event_type == "content_block_start":
-            # Create content block start event
-            index = event_data.get("index", 0)
-            content_block = event_data.get("content_block", {})
-
-            # Initialize content blocks list if needed
-            while len(self.content_blocks) <= index:
-                self.content_blocks.append({"type": "text", "text": ""})
-
-            if content_block.get("type") == "tool_use":
-                # Add to tool use blocks tracking
-                tool_block = {
-                    "id": content_block.get("id"),
-                    "name": content_block.get("name"),
-                    "input": {},
-                    "_partial": "",
-                }
-                self.tool_use_blocks.append(tool_block)
-
-            return ContentBlockStartEvent(index, content_block)
-
-        elif event_type == "content_block_delta":
-            # Create content block delta event
-            index = event_data.get("index", 0)
-            delta = event_data.get("delta", {})
-
-            # Update content blocks tracking
-            if index < len(self.content_blocks):
-                if delta.get("type") == "text_delta":
-                    self.content_blocks[index]["text"] += delta.get("text", "")
-                elif delta.get("type") == "input_json_delta":
-                    # Update tool use input tracking
-                    if self.tool_use_blocks:
-                        current_tool = self.tool_use_blocks[-1]
-                        current_tool["_partial"] += delta.get("partial_json", "")
-                        try:
-                            current_tool["input"] = json.loads(current_tool["_partial"])
-                        except json.JSONDecodeError:
-                            pass  # Partial JSON, continue accumulating
-
-            return ContentBlockDeltaEvent(index, delta)
-
-        elif event_type == "content_block_stop":
-            # Create content block stop event
-            index = event_data.get("index", 0)
-            return ContentBlockStopEvent(index)
-
-        elif event_type == "message_delta":
-            # Create message delta event
-            delta = event_data.get("delta", {})
-            usage = event_data.get("usage", {})
-            return MessageDeltaEvent(delta, usage)
-
-        elif event_type == "message_stop":
-            # Finalize tool blocks
-            self._finalize_tool_blocks()
-            return MessageStopEvent()
-
-        elif event_type == "error":
-            # Create error event
-            return ErrorEvent(event_data)
-
-        else:
-            # Unknown event type, log and ignore
-            logger.debug(f"Unknown event type: {event_type}")
-            return None
-
-    def _finalize_tool_blocks(self):
-        """Finalize tool use blocks by cleaning up and adding to content blocks."""
-        for block in self.tool_use_blocks:
-            block["type"] = "tool_use"
-            if "_partial" in block:
-                del block["_partial"]
-            self.content_blocks.append(block)
-
-    def get_stop_reason(self) -> str:
-        """Get the stop reason based on current state."""
-        if self.tool_use_blocks:
-            return "tool_use"
-        return "stop"
-
-    def get_content_blocks(self) -> list[dict[str, Any]]:
-        """Get the current content blocks."""
-        return self.content_blocks.copy()
-
-
-# Event classes that match the SDK structure
-class BaseStreamEvent:
-    """Base class for stream events."""
-
-    def __init__(self, event_type: str):
-        self.type = event_type
-
-
-class PingEvent(BaseStreamEvent):
-    """Ping event."""
-
-    def __init__(self):
-        super().__init__("ping")
-
-
-class MessageStartEvent(BaseStreamEvent):
-    """Message start event."""
-
-    def __init__(self, message: dict[str, Any]):
-        super().__init__("message_start")
-        self.message = message
-
-
-class ContentBlockStartEvent(BaseStreamEvent):
-    """Content block start event."""
-
-    def __init__(self, index: int, content_block: dict[str, Any]):
-        super().__init__("content_block_start")
-        self.index = index
-        self.content_block = MockContentBlock(content_block)
-
-
-class ContentBlockDeltaEvent(BaseStreamEvent):
-    """Content block delta event."""
-
-    def __init__(self, index: int, delta: dict[str, Any]):
-        super().__init__("content_block_delta")
-        self.index = index
-        self.delta = MockDelta(delta)
-
-
-class ContentBlockStopEvent(BaseStreamEvent):
-    """Content block stop event."""
-
-    def __init__(self, index: int):
-        super().__init__("content_block_stop")
-        self.index = index
-
-
-class MessageDeltaEvent(BaseStreamEvent):
-    """Message delta event."""
-
-    def __init__(self, delta: dict[str, Any], usage: dict[str, Any]):
-        super().__init__("message_delta")
-        self.delta = delta
-        self.usage = usage
-
-
-class MessageStopEvent(BaseStreamEvent):
-    """Message stop event."""
-
-    def __init__(self):
-        super().__init__("message_stop")
-
-
-class ErrorEvent(BaseStreamEvent):
-    """Error event."""
-
-    def __init__(self, error_data: dict[str, Any]):
-        super().__init__("error")
-        self.error = error_data
-
-
-# Mock classes to match SDK object structure
-class MockContentBlock:
-    """Mock content block object that matches SDK structure."""
-
-    def __init__(self, data: dict[str, Any]):
-        self.type = data.get("type")
-        self.id = data.get("id")
-        self.name = data.get("name")
-        self.input = data.get("input", {})
-
-
-class MockDelta:
-    """Mock delta object that matches SDK structure."""
-
-    def __init__(self, data: dict[str, Any]):
-        self.data = data
-        # Set attributes based on delta type
-        if data.get("type") == "text_delta":
-            self.text = data.get("text", "")
-        elif data.get("type") == "input_json_delta":
-            self.partial_json = data.get("partial_json", "")
-
-    def __getattr__(self, name):
-        """Allow access to any attribute from the data."""
-        return self.data.get(name)
-
-
-class StreamingResponse:
-    """Response object for streaming that matches the current agent's expectations."""
-
-    def __init__(self, content: list[dict[str, Any]], stop_reason: str):
-        self.content = content
-        self.stop_reason = stop_reason

sqlsaber/models/events.py

@@ -1,28 +0,0 @@
-"""Event models for streaming and responses."""
-
-from typing import Any
-
-
-class StreamEvent:
-    """Event emitted during streaming processing."""
-
-    def __init__(self, event_type: str, data: Any = None):
-        # 'tool_use', 'text', 'query_result', 'plot_result', 'error', 'processing'
-        self.type = event_type
-        self.data = data
-
-
-class SQLResponse:
-    """Response from the SQL agent."""
-
-    def __init__(
-        self,
-        query: str | None = None,
-        explanation: str = "",
-        results: list[dict[str, Any]] | None = None,
-        error: str | None = None,
-    ):
-        self.query = query
-        self.explanation = explanation
-        self.results = results
-        self.error = error

sqlsaber-0.14.0.dist-info/RECORD

@@ -1,51 +0,0 @@
-sqlsaber/__init__.py,sha256=HjS8ULtP4MGpnTL7njVY45NKV9Fi4e_yeYuY-hyXWQc,73
-sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
-sqlsaber/agents/__init__.py,sha256=LWeSeEUE4BhkyAYFF3TE-fx8TtLud3oyEtyB8ojFJgo,167
-sqlsaber/agents/anthropic.py,sha256=xH4xY1lq5idDgY8Vklgu5hGLoKLHWQMMfPgjvQjfG7I,23615
-sqlsaber/agents/base.py,sha256=9A-iceb93eHrQHTdLoeSicP3ZqDHOFTx3Fe5OvHvUkg,14093
-sqlsaber/agents/mcp.py,sha256=FKtXgDrPZ2-xqUYCw2baI5JzrWekXaC5fjkYW1_Mg50,827
-sqlsaber/agents/streaming.py,sha256=LaSeMTlxuJFRArJVqDly5-_KgcePiCCKPKfMxfB4oGs,521
-sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
-sqlsaber/cli/auth.py,sha256=1yvawtS5NGj9dWMRZ8I5T6sqBiRqZpPsjEPrJSQBJAs,4979
-sqlsaber/cli/commands.py,sha256=VX7pqQnf-85A9zkjXqzytVNeCG8KO0mB2TyIEzB4sh8,6241
-sqlsaber/cli/completers.py,sha256=HsUPjaZweLSeYCWkAcgMl8FylQ1xjWBWYTEL_9F6xfU,6430
-sqlsaber/cli/database.py,sha256=tJ8rqGrafZpg3VgDmSiq7eZoPscoGAW3XLTYGoQw8LE,12910
-sqlsaber/cli/display.py,sha256=HtXwPe3VPUh2EJpyvpJVWyisCanu9O7w-rkqq7Y4UaY,9791
-sqlsaber/cli/interactive.py,sha256=7RjUMMPJ49RUuUGn-gP6vgiW6Ccvin9mzmRL-9p6eto,8171
-sqlsaber/cli/memory.py,sha256=OufHFJFwV0_GGn7LvKRTJikkWhV1IwNIUDOxFPHXOaQ,7794
-sqlsaber/cli/models.py,sha256=HByezaeKqj65GzB_FmWuugjkgTq2Pvab_mzNZnHxya0,7690
-sqlsaber/cli/streaming.py,sha256=WfhFd5ntq2HStpJZwWJ0C5uyXKc3aU14eo8HdjzW1o0,3767
-sqlsaber/clients/__init__.py,sha256=jcMoVsT92U6nQrfotCp1h0ggskJPAcgeYarqQl1qEBg,171
-sqlsaber/clients/anthropic.py,sha256=umRmuzpmJdYO7hO3biAZXO9T_sb6Vv010o6zqn03is8,9947
-sqlsaber/clients/base.py,sha256=RLFJ3NV75Z6keiu9mnh9zrMZK1HwdeUby0e3oeJMtyw,935
-sqlsaber/clients/exceptions.py,sha256=6OoCSxvuA13I3dML2Zngygl9MdaObISh1UHvBB3yUq0,3408
-sqlsaber/clients/models.py,sha256=fOvnkW8NQSdn8Oqfk3-5dP4TylLh7C9wOvuNQYw184A,7016
-sqlsaber/clients/streaming.py,sha256=CwdoocLAyW_GjZm2XcLb33Sa99w5fyb7dU-27FFpePQ,8319
-sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
-sqlsaber/config/api_keys.py,sha256=wnWlYy26AkkevZ1Vln6avYRBDLPRzfrHkj-fPojkxaQ,3624
-sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
-sqlsaber/config/database.py,sha256=c6q3l4EvoBch1ckYHA70hf6L7fSOY-sItnLCpvJiPrA,11357
-sqlsaber/config/oauth_flow.py,sha256=A3bSXaBLzuAfXV2ZPA94m9NV33c2MyL6M4ii9oEkswQ,10291
-sqlsaber/config/oauth_tokens.py,sha256=C9z35hyx-PvSAYdC1LNf3rg9_wsEIY56hkEczelbad0,6015
-sqlsaber/config/settings.py,sha256=gKhGlErzsBk39RoRSy1b8pb-bN2K7HIaPaBgbJDhY4M,4753
-sqlsaber/conversation/__init__.py,sha256=xa-1gX6NsZpVGg_LDrsZAtDtsDo5FZc1SO8gwtm_IPk,302
-sqlsaber/conversation/manager.py,sha256=LDfmKGIMvTzsL7S0aXGWw6Ve54CHIeTGLU4qwes2NgU,7046
-sqlsaber/conversation/models.py,sha256=fq4wpIB2yxLCQtsXhdpDji4FpscG2ayrOBACrNvgF14,3510
-sqlsaber/conversation/storage.py,sha256=phpGEnZjXVFTmV5PalCKZpiO9VFHubMMfWA9OJCDbwc,11626
-sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
-sqlsaber/database/connection.py,sha256=sZVGNMzMwiM11GrsLLPwR8A5ugzJ5O0TCdkrt0KVRuI,15123
-sqlsaber/database/resolver.py,sha256=RPXF5EoKzvQDDLmPGNHYd2uG_oNICH8qvUjBp6iXmNY,3348
-sqlsaber/database/schema.py,sha256=OC93dnZkijCoVNqb6itSpQ2XsiZ85PjVUW-VZDwrPrk,25989
-sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
-sqlsaber/mcp/mcp.py,sha256=YH4crygqb5_Y94nsns6d-26FZCTlDPOh3tf-ghihzDM,4440
-sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
-sqlsaber/memory/manager.py,sha256=p3fybMVfH-E4ApT1ZRZUnQIWSk9dkfUPCyfkmA0HALs,2739
-sqlsaber/memory/storage.py,sha256=ne8szLlGj5NELheqLnI7zu21V8YS4rtpYGGC7tOmi-s,5745
-sqlsaber/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
-sqlsaber/models/events.py,sha256=89SXKb5GGpH01yTr2kPEBhzp9xv35RFIYuFdAZSIPoE,721
-sqlsaber/models/types.py,sha256=w-zk81V2dtveuteej36_o1fDK3So428j3P2rAejU62U,862
-sqlsaber-0.14.0.dist-info/METADATA,sha256=xAj3wcH-3OJWud9grNykoiHhuVp2LIdMV5bbxNUQOEk,6877
-sqlsaber-0.14.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.14.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
-sqlsaber-0.14.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.14.0.dist-info/RECORD,,