Merge branch 'develop' of https://github.com/atasoglu/toolsgen

Author: atasoglu

CHANGELOG.md

@@ -8,6 +8,12 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 
 Nothing yet.
 
+## [0.5.1] - 2025-01-11
+### Removed
+- Removed redundant `create_structured_completion()` function from `core.client` module
+  - Function was unused in the codebase; structured outputs are implemented directly in `judge.py`
+  - Cleaned up unused imports and test cases
+
 ## [0.5.0] - 2025-01-11
 ### Added
 - Hugging Face Hub integration for direct dataset uploads

pyproject.toml

@@ -13,7 +13,7 @@ toolsgen = ["prompts/*.txt"]
 
 [project]
 name = "toolsgen"
-version = "0.5.0"
+version = "0.5.1"
 description = "Generate tool-calling datasets from OpenAI-compatible tool specs"
 readme = "README.md"
 requires-python = ">=3.9"

src/toolsgen/core/__init__.py

@@ -1,6 +1,6 @@
 """Core dataset generation package."""
 
-from .client import create_openai_client, create_structured_completion
+from .client import create_openai_client
 from .config import GenerationConfig, ModelConfig, RoleBasedModelConfig
 from .generator import generate_dataset
 from .io import append_record_jsonl, load_tool_specs, write_dataset_jsonl
@@ -12,7 +12,6 @@
     "RoleBasedModelConfig",
     # Client
     "create_openai_client",
-    "create_structured_completion",
     # Generator
     "generate_dataset",
     # I/O

src/toolsgen/core/client.py

@@ -3,11 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Dict, List, Optional
-
 from openai import OpenAI
-from pydantic import BaseModel
-
 from .config import ModelConfig
 
 
@@ -40,46 +36,3 @@ def create_openai_client(model_config: ModelConfig) -> OpenAI:
         params.update(model_config.openai_params)
 
     return OpenAI(**params)
-
-
-def create_structured_completion(
-    client: OpenAI,
-    model: str,
-    messages: List[Dict[str, Any]],
-    response_model: type[BaseModel],
-    temperature: float = 0.7,
-    max_tokens: Optional[int] = None,
-) -> BaseModel:
-    """Create a chat completion with structured output.
-
-    Args:
-        client: OpenAI client instance.
-        model: Model name to use.
-        messages: List of message dictionaries.
-        response_model: Pydantic model class for response structure.
-        temperature: Sampling temperature.
-        max_tokens: Maximum tokens to generate.
-
-    Returns:
-        Instance of response_model populated with API response.
-    """
-    response = client.chat.completions.create(
-        model=model,
-        messages=messages,
-        temperature=temperature,
-        max_tokens=max_tokens,
-        response_format={
-            "type": "json_schema",
-            "json_schema": {
-                "name": response_model.__name__,
-                "schema": response_model.model_json_schema(),
-                "strict": True,
-            },
-        },
-    )
-
-    content = response.choices[0].message.content
-    if not content:
-        raise ValueError("LLM returned empty content")
-
-    return response_model.model_validate_json(content)

tests/test_client.py

@@ -2,12 +2,9 @@
 
 from __future__ import annotations
 
-from unittest.mock import MagicMock, patch
-
 import pytest
-from pydantic import BaseModel
 
-from toolsgen.core.client import create_openai_client, create_structured_completion
+from toolsgen.core.client import create_openai_client
 from toolsgen.core.config import ModelConfig
 
 
@@ -70,96 +67,3 @@ def test_create_openai_client_with_openai_params(
 
     assert client.timeout == 120.0
     assert client.max_retries == 3
-
-
-@patch("toolsgen.core.client.OpenAI")
-def test_create_structured_completion_success(mock_openai_class: MagicMock) -> None:
-    """Test successful structured completion."""
-
-    # Define a test response model
-    class TestResponse(BaseModel):
-        message: str
-        count: int
-
-    # Mock OpenAI client and response
-    mock_client = MagicMock()
-    mock_response = MagicMock()
-    mock_response.choices[0].message.content = '{"message": "hello", "count": 42}'
-    mock_client.chat.completions.create.return_value = mock_response
-
-    messages = [{"role": "user", "content": "Test"}]
-    result = create_structured_completion(
-        client=mock_client,
-        model="gpt-4",
-        messages=messages,
-        response_model=TestResponse,
-        temperature=0.7,
-        max_tokens=100,
-    )
-
-    assert isinstance(result, TestResponse)
-    assert result.message == "hello"
-    assert result.count == 42
-
-    # Verify the API was called correctly
-    mock_client.chat.completions.create.assert_called_once()
-    call_kwargs = mock_client.chat.completions.create.call_args.kwargs
-    assert call_kwargs["model"] == "gpt-4"
-    assert call_kwargs["temperature"] == 0.7
-    assert call_kwargs["max_tokens"] == 100
-    assert call_kwargs["response_format"]["type"] == "json_schema"
-
-
-@patch("toolsgen.core.client.OpenAI")
-def test_create_structured_completion_empty_content(
-    mock_openai_class: MagicMock,
-) -> None:
-    """Test structured completion fails with empty content."""
-
-    class TestResponse(BaseModel):
-        message: str
-
-    mock_client = MagicMock()
-    mock_response = MagicMock()
-    mock_response.choices[0].message.content = None
-    mock_client.chat.completions.create.return_value = mock_response
-
-    messages = [{"role": "user", "content": "Test"}]
-
-    with pytest.raises(ValueError, match="LLM returned empty content"):
-        create_structured_completion(
-            client=mock_client,
-            model="gpt-4",
-            messages=messages,
-            response_model=TestResponse,
-        )
-
-
-@patch("toolsgen.core.client.OpenAI")
-def test_create_structured_completion_with_schema(mock_openai_class: MagicMock) -> None:
-    """Test that structured completion uses correct JSON schema."""
-
-    class TestResponse(BaseModel):
-        value: str
-
-    mock_client = MagicMock()
-    mock_response = MagicMock()
-    mock_response.choices[0].message.content = '{"value": "test"}'
-    mock_client.chat.completions.create.return_value = mock_response
-
-    messages = [{"role": "user", "content": "Test"}]
-    create_structured_completion(
-        client=mock_client,
-        model="gpt-4",
-        messages=messages,
-        response_model=TestResponse,
-    )
-
-    # Verify schema was passed correctly
-    call_kwargs = mock_client.chat.completions.create.call_args.kwargs
-    assert "response_format" in call_kwargs
-    response_format = call_kwargs["response_format"]
-    assert response_format["type"] == "json_schema"
-    assert response_format["json_schema"]["name"] == "TestResponse"
-    assert response_format["json_schema"]["strict"] is True
-    assert "schema" in response_format["json_schema"]