lm-deluge 0.0.69__py3-none-any.whl → 0.0.71__py3-none-any.whl

lm_deluge/__init__.py

@@ -4,7 +4,13 @@ from .prompt import Conversation, Message
 from .tool import Tool, ToolParams
 
 try:
-    from .mock_openai import MockAsyncOpenAI  # noqa
+    from .mock_openai import (  # noqa
+        APIError,
+        APITimeoutError,
+        BadRequestError,
+        MockAsyncOpenAI,
+        RateLimitError,
+    )
 
     _has_openai = True
 except ImportError:
@@ -24,4 +30,12 @@ __all__ = [
 ]
 
 if _has_openai:
-    __all__.append("MockAsyncOpenAI")
+    __all__.extend(
+        [
+            "MockAsyncOpenAI",
+            "APIError",
+            "APITimeoutError",
+            "BadRequestError",
+            "RateLimitError",
+        ]
+    )

lm_deluge/mock_openai.py

@@ -25,20 +25,30 @@ import uuid
 from typing import Any, AsyncIterator, Literal, Union, overload
 
 try:
+    from openai import (
+        APIError,
+        APITimeoutError,
+        BadRequestError,
+        RateLimitError,
+    )
+    from openai.types import Completion
     from openai.types.chat import (
         ChatCompletion,
         ChatCompletionChunk,
         ChatCompletionMessage,
         ChatCompletionMessageToolCall,
     )
-    from openai.types.chat.chat_completion import Choice as CompletionChoice
+    from openai.types.chat.chat_completion import Choice as ChatCompletionChoice
     from openai.types.chat.chat_completion_chunk import (
         Choice as ChunkChoice,
+    )
+    from openai.types.chat.chat_completion_chunk import (
         ChoiceDelta,
         ChoiceDeltaToolCall,
         ChoiceDeltaToolCallFunction,
     )
     from openai.types.chat.chat_completion_message_tool_call import Function
+    from openai.types.completion_choice import CompletionChoice as TextCompletionChoice
     from openai.types.completion_usage import CompletionUsage
 except ImportError:
     raise ImportError(
@@ -46,56 +56,70 @@ except ImportError:
         "Install it with: pip install lm-deluge[openai]"
     )
 
-from lm_deluge.client import LLMClient
-from lm_deluge.prompt import Conversation, Message, Part, Text, ToolCall, ToolResult
+# Re-export exceptions for compatibility
+__all__ = [
+    "MockAsyncOpenAI",
+    "APIError",
+    "APITimeoutError",
+    "BadRequestError",
+    "RateLimitError",
+]
 
+from lm_deluge.client import LLMClient, _LLMClient
+from lm_deluge.prompt import CachePattern, Conversation, Message, Text, ToolCall
+from lm_deluge.tool import Tool
 
-def _messages_to_conversation(messages: list[dict[str, Any]]) -> Conversation:
-    """Convert OpenAI messages format to lm-deluge Conversation."""
-    conv_messages = []
-
-    for msg in messages:
-        role = msg["role"]
-        content = msg.get("content")
-        tool_calls = msg.get("tool_calls")
-        tool_call_id = msg.get("tool_call_id")
-
-        parts: list[Part] = []
-
-        # Handle regular content
-        if content:
-            if isinstance(content, str):
-                parts.append(Text(content))
-            elif isinstance(content, list):
-                # Multi-part content (text, images, etc.)
-                for item in content:
-                    if item.get("type") == "text":
-                        parts.append(Text(item["text"]))
-                    # Could add image support here later
-
-        # Handle tool calls (from assistant)
-        if tool_calls:
-            for tc in tool_calls:
-                # Parse arguments from JSON string to dict
-                args_str = tc["function"]["arguments"]
-                args_dict = (
-                    json.loads(args_str) if isinstance(args_str, str) else args_str
-                )
-                parts.append(
-                    ToolCall(
-                        id=tc["id"],
-                        name=tc["function"]["name"],
-                        arguments=args_dict,
-                    )
-                )
 
-        # Handle tool results (from tool role)
-        if role == "tool" and tool_call_id:
-            parts.append(ToolResult(tool_call_id=tool_call_id, result=content or ""))
+def _openai_tools_to_lm_deluge(tools: list[dict[str, Any]]) -> list[Tool]:
+    """
+    Convert OpenAI tool format to lm-deluge Tool objects.
+
+    OpenAI format:
+        {
+            "type": "function",
+            "function": {
+                "name": "get_weather",
+                "description": "Get weather",
+                "parameters": {
+                    "type": "object",
+                    "properties": {...},
+                    "required": [...]
+                }
+            }
+        }
+
+    lm-deluge format:
+        Tool(
+            name="get_weather",
+            description="Get weather",
+            parameters={...properties...},
+            required=[...]
+        )
+    """
+    lm_tools = []
+    for tool in tools:
+        if tool.get("type") == "function":
+            func = tool["function"]
+            params_schema = func.get("parameters", {})
 
-        conv_messages.append(Message(role=role, parts=parts))
+            # Extract properties and required from the parameters schema
+            properties = params_schema.get("properties", {})
+            required = params_schema.get("required", [])
 
-    return Conversation(messages=conv_messages)
+            lm_tool = Tool(
+                name=func["name"],
+                description=func.get("description"),
+                parameters=properties if properties else None,
+                required=required,
+            )
+            lm_tools.append(lm_tool)
+
+    return lm_tools
+
+
+def _messages_to_conversation(messages: list[dict[str, Any]]) -> Conversation:
+    """Convert OpenAI messages format to lm-deluge Conversation."""
+    return Conversation.from_openai_chat(messages)
 
 
 def _response_to_chat_completion(
@@ -114,7 +138,7 @@ def _response_to_chat_completion(
             role="assistant",
             content=response.error_message or "Error occurred",
         )
-        choice = CompletionChoice(
+        choice = ChatCompletionChoice(
             index=0,
             message=message,
             finish_reason="stop",  # or could use "error" but that's not standard
@@ -164,7 +188,7 @@ def _response_to_chat_completion(
     )
 
     # Create choice
-    choice = CompletionChoice(
+    choice = ChatCompletionChoice(
         index=0,
         message=message,
         finish_reason=response.finish_reason or "stop",
@@ -329,7 +353,7 @@ class MockCompletions:
             ChatCompletion (non-streaming) or AsyncIterator[ChatCompletionChunk] (streaming)
         """
         # Get or create client for this model
-        client = self._parent._get_or_create_client(model)
+        client: _LLMClient = self._parent._get_or_create_client(model)
 
         # Convert messages to Conversation
         conversation = _messages_to_conversation(messages)
@@ -360,29 +384,121 @@ class MockCompletions:
         # Convert tools if provided
         lm_tools = None
         if tools:
-            # For now, just pass through - lm-deluge will handle the format
-            lm_tools = tools
+            # Convert from OpenAI format to lm-deluge Tool objects
+            lm_tools = _openai_tools_to_lm_deluge(tools)
 
         # Execute request
         if stream:
-            # Streaming mode
-            request_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
-            # Note: client.stream() is an async generator, not a coroutine
-            # We can directly wrap it
-            stream_iter = client.stream(conversation, tools=lm_tools)
-            # Verify it's a generator, not a coroutine
-            if hasattr(stream_iter, "__anext__"):
-                return _AsyncStreamWrapper(stream_iter, model, request_id)
-            else:
-                # If it's a coroutine, we need to await it first
-                # But this shouldn't happen with the current implementation
-                raise TypeError(f"Expected async generator, got {type(stream_iter)}")
+            raise RuntimeError("streaming not supported")
         else:
             # Non-streaming mode
-            response = await client.start(conversation, tools=lm_tools)
+            response = await client.start(
+                conversation,
+                tools=lm_tools,  # type: ignore
+                cache=self._parent.cache_pattern,  # type: ignore
+            )
             return _response_to_chat_completion(response, model)
 
 
+class MockTextCompletions:
+    """Mock text completions resource for legacy completions API."""
+
+    def __init__(self, parent: "MockAsyncOpenAI"):
+        self._parent = parent
+
+    async def create(
+        self,
+        *,
+        model: str,
+        prompt: str | list[str],
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        top_p: float | None = None,
+        seed: int | None = None,
+        n: int | None = None,
+        stop: str | list[str] | None = None,
+        **kwargs: Any,
+    ) -> Completion:
+        """
+        Create a text completion using lm-deluge's LLMClient.
+
+        Args:
+            model: Model identifier
+            prompt: Text prompt or list of prompts
+            temperature: Sampling temperature
+            max_tokens: Max tokens to generate
+            top_p: Nucleus sampling parameter
+            seed: Random seed
+            n: Number of completions (currently ignored, always returns 1)
+            stop: Stop sequences
+            **kwargs: Other parameters
+
+        Returns:
+            Completion object
+        """
+        # Get or create client for this model
+        client: _LLMClient = self._parent._get_or_create_client(model)
+
+        # Handle single prompt
+        if isinstance(prompt, list):
+            # For now, just use the first prompt
+            prompt = prompt[0] if prompt else ""
+
+        # Convert prompt to Conversation
+        conversation = Conversation([Message(role="user", parts=[Text(prompt)])])
+
+        # Build sampling params
+        sampling_kwargs = {}
+        if temperature is not None:
+            sampling_kwargs["temperature"] = temperature
+        if max_tokens is not None:
+            sampling_kwargs["max_new_tokens"] = max_tokens
+        if top_p is not None:
+            sampling_kwargs["top_p"] = top_p
+        if seed is not None:
+            sampling_kwargs["seed"] = seed
+
+        # Create client with merged params if needed
+        if sampling_kwargs:
+            merged_params = {**self._parent._default_sampling_params, **sampling_kwargs}
+            client = self._parent._create_client_with_params(model, merged_params)
+
+        # Execute request
+        response = await client.start(conversation, cache=self._parent.cache_pattern)  # type: ignore
+
+        # Convert to Completion format
+        completion_text = None
+        if response.content:
+            text_parts = [p.text for p in response.content.parts if isinstance(p, Text)]
+            if text_parts:
+                completion_text = "".join(text_parts)
+
+        # Create choice
+        choice = TextCompletionChoice(
+            index=0,
+            text=completion_text or "",
+            finish_reason=response.finish_reason or "stop",  # type: ignore
+        )
+
+        # Create usage
+        usage = None
+        if response.usage:
+            usage = CompletionUsage(
+                prompt_tokens=response.usage.input_tokens,
+                completion_tokens=response.usage.output_tokens,
+                total_tokens=response.usage.input_tokens + response.usage.output_tokens,
+            )
+
+        return Completion(
+            id=f"cmpl-{uuid.uuid4().hex[:24]}",
+            choices=[choice],
+            created=int(time.time()),
+            model=model,
+            object="text_completion",
+            usage=usage,
+        )
+
+
 class MockChat:
     """Mock chat resource that provides access to completions."""
 
@@ -414,23 +530,52 @@ class MockAsyncOpenAI:
 
     Args:
         model: Default model to use (can be overridden in create())
+        api_key: API key (optional, for compatibility)
+        organization: Organization ID (optional, for compatibility)
+        project: Project ID (optional, for compatibility)
+        base_url: Base URL (defaults to OpenAI's URL for compatibility)
+        timeout: Request timeout (optional, for compatibility)
+        max_retries: Max retries (defaults to 2 for compatibility)
+        default_headers: Default headers (optional, for compatibility)
         temperature: Default temperature
         max_completion_tokens: Default max completion tokens
         top_p: Default top_p
+        seed: Default seed for deterministic sampling
         **kwargs: Additional parameters passed to LLMClient
     """
 
     def __init__(
         self,
         *,
-        model: str,
+        model: str | None = None,
+        api_key: str | None = None,
+        organization: str | None = None,
+        project: str | None = None,
+        base_url: str | None = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
+        default_headers: dict[str, str] | None = None,
+        http_client: Any | None = None,
         temperature: float | None = None,
         max_completion_tokens: int | None = None,
         top_p: float | None = None,
         seed: int | None = None,
+        cache_pattern: CachePattern | None = None,
         **kwargs: Any,
     ):
-        self._default_model = model
+        # OpenAI-compatible attributes
+        self.api_key = api_key
+        self.organization = organization
+        self.project = project
+        self.base_url = base_url or "https://api.openai.com/v1"
+        self.timeout = timeout
+        self.max_retries = max_retries or 2
+        self.default_headers = default_headers
+        self.http_client = http_client
+        self.cache_pattern = cache_pattern
+
+        # Internal attributes
+        self._default_model = model or "gpt-4o-mini"
         self._default_sampling_params = {}
 
         if temperature is not None:
@@ -449,10 +594,11 @@ class MockAsyncOpenAI:
         self._clients: dict[str, Any] = {}
 
         # Create the default client
-        self._clients[model] = self._create_client(model)
+        self._clients[self._default_model] = self._create_client(self._default_model)
 
         # Create nested resources
         self._chat = MockChat(self)
+        self._completions = MockTextCompletions(self)
 
     def _create_client(self, model: str) -> Any:
         """Create a new LLMClient for the given model."""
@@ -480,3 +626,18 @@ class MockAsyncOpenAI:
     def chat(self) -> MockChat:
         """Access the chat resource."""
         return self._chat
+
+    @property
+    def completions(self) -> MockTextCompletions:
+        """Access the text completions resource."""
+        return self._completions
+
+    async def close(self) -> None:
+        """
+        Close the client and clean up resources.
+
+        This is provided for compatibility with AsyncOpenAI's close() method.
+        Currently a no-op as LLMClient instances don't need explicit cleanup.
+        """
+        # No cleanup needed for LLMClient instances
+        pass

lm_deluge/prompt.py

@@ -848,14 +848,16 @@ class Conversation:
             if content is None:
                 return parts
             if isinstance(content, str):
-                parts.append(Text(content))
+                if content.strip():
+                    parts.append(Text(content))
                 return parts
 
             for block in content:
                 block_type = block.get("type")
                 if block_type in text_types:
                     text_value = block.get("text") or block.get(block_type) or ""
-                    parts.append(Text(text_value))
+                    if text_value.strip():
+                        parts.append(Text(text_value))
                 elif block_type in image_types:
                     parts.append(_to_image_from_url(block))
                 elif block_type in file_types:
@@ -1001,7 +1003,8 @@ class Conversation:
                             )
                         )
 
-            conversation_messages.append(Message(mapped_role, parts))
+            if parts:
+                conversation_messages.append(Message(mapped_role, parts))
 
         return cls(conversation_messages)
 

{lm_deluge-0.0.69.dist-info → lm_deluge-0.0.71.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.69
+Version: 0.0.71
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10

{lm_deluge-0.0.69.dist-info → lm_deluge-0.0.71.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lm_deluge/__init__.py,sha256=bGF2eVo60StVEGjt5lgVhSoJmYBlvQTUa8DR96sNh0w,558
+lm_deluge/__init__.py,sha256=zF5lAitfgJ8A28IXJ5BE9OUCqGOqSnGOWn3ZIlizNyY,822
 lm_deluge/batches.py,sha256=Km6QM5_7BlF2qEyo4WPlhkaZkpzrLqf50AaveHXQOoY,25127
 lm_deluge/cache.py,sha256=xO2AIYvP3tUpTMKQjwQQYfGRJSRi6e7sMlRhLjsS-u4,4873
 lm_deluge/cli.py,sha256=Ilww5gOw3J5v0NReq_Ra4hhxU4BCIJBl1oTGxJZKedc,12065
@@ -8,8 +8,8 @@ lm_deluge/embed.py,sha256=CO-TOlC5kOTAM8lcnicoG4u4K664vCBwHF1vHa-nAGg,13382
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
 lm_deluge/file.py,sha256=PTmlJQ-IaYcYUFun9V0bJ1NPVP84edJrR0hvCMWFylY,19697
 lm_deluge/image.py,sha256=5AMXmn2x47yXeYNfMSMAOWcnlrOxxOel-4L8QCJwU70,8928
-lm_deluge/mock_openai.py,sha256=OelIYWGBf5vBZXJOLaz54s5gE-HPIg1kPXARnv4NoKg,16592
-lm_deluge/prompt.py,sha256=Bgszws8-3GPefiVRa-Mht4tfyfoqD_hV5MX1nrbkJn0,63465
+lm_deluge/mock_openai.py,sha256=-u4kxSzwoxDt_2fLh5LaiqETnu0Jg_VDL7TWAAYHGNw,21762
+lm_deluge/prompt.py,sha256=b93ZZHlK9luujgilcnSkwoPCD-U6r1wLWXxWJ4D4ZIE,63578
 lm_deluge/request_context.py,sha256=cBayMFWupWhde2OjRugW3JH-Gin-WFGc6DK2Mb4Prdc,2576
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
 lm_deluge/tool.py,sha256=Kp2O5lDq_WVo_ASxjLQSHzVRbaxZkS6J0JIIskBjux0,28909
@@ -69,8 +69,8 @@ lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11
 lm_deluge/util/spatial.py,sha256=BsF_UKhE-x0xBirc-bV1xSKZRTUhsOBdGqsMKme20C8,4099
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-lm_deluge-0.0.69.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.69.dist-info/METADATA,sha256=BMFkIulQwTPBEtqViIDyY6RjaMH4hZBzC-4qTCXpGQY,13514
-lm_deluge-0.0.69.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.69.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.69.dist-info/RECORD,,
+lm_deluge-0.0.71.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.71.dist-info/METADATA,sha256=kgq3xiS7tMIbXpx5UkhCEA_yJAJvgGOPaie_ZlScTxQ,13514
+lm_deluge-0.0.71.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.71.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.71.dist-info/RECORD,,