Add Support for the New OpenAI Library (#12)

* Add tool helper class

* Add more tests

* Add example to readme

* Fix black

* Add changelog file and upgrade version

Author: jakecyr

.github/workflows/test-application.yml

@@ -34,4 +34,4 @@ jobs:
       - name: Test Coverage
         run: |
           poetry run coverage run --source openai_function_calling -m pytest
-          poetry run coverage report --fail-under=90 --show-missing
+          poetry run coverage report --fail-under=95 --show-missing

CHANGELOG.md

@@ -0,0 +1,50 @@
+# Release Notes
+
+## 2.0.0
+
+* Upgrade to the latest OpenAI version that changes from function calling to tools.
+* Add the `ToolHelpers` class.
+
+## 1.2.0
+
+* Increase compatible Python version range to include 3.9
+
+## 1.1.0
+
+* Adds the ability to automatically infer a function's definition along with it's parameters automatically from a function reference.
+
+## 1.0.1
+
+* Added the to_dict method back to the Function class and marked it as deprecated. It will be removed in future versions.
+
+## 1.0.0
+
+* Renamed to_dict to to_json_schema.
+* Added additional validation conditions when creating and converting Parameters and Functions to JSON schema.
+* Add ruff.toml file with additional checks and fixed all linting errors.
+* Added additional docstrings.
+* Added py.typed file for mypy.
+
+## 0.6.0
+
+* Add new parameter to Parameter class array_item_type to specify the type of array items if type is set to array
+
+## 0.5.0
+
+* Remove the openai dependency since it isn't required to use the package. It must now be installed separately.
+
+## 0.4.0
+
+* Fix bugs in the Parameter class related to required_parameters and add unit tests.
+
+## 0.3.0
+
+* Update the examples link in the README to point to GitHub instead of being relative.
+
+## 0.2.0
+
+* Update README to include details about setting the OpenAI API key and link to the examples
+
+## 0.1.0
+
+* Initial release

README.md

@@ -23,7 +23,7 @@ Automatically infer your function name, description, and parameters given a refe
 
 ```python
 from typing import Any, Callable
-from openai_function_calling import FunctionInferer
+from openai_function_calling import FunctionInferrer
 import openai
 import json
 
@@ -39,11 +39,11 @@ def get_tomorrows_weather(location: str, unit: str = "fahrenheit") -> str:
     return f"Tomorrow it will be rainy in {location} and 60 degrees {unit}."
 
 # Infer the function definitions.
-get_current_weather_function = FunctionInferer.infer_from_function_reference(
+get_current_weather_function = FunctionInferrer.infer_from_function_reference(
     get_current_weather
 )
 
-get_tomorrows_weather_function = FunctionInferer.infer_from_function_reference(
+get_tomorrows_weather_function = FunctionInferrer.infer_from_function_reference(
     get_tomorrows_weather
 )
 
@@ -99,6 +99,45 @@ get_current_weather_function = Function(
 get_current_weather_function_schema = get_current_weather_function.to_json_schema()
 ```
 
+### Convert Functions to OpenAI Compatible JSON
+
+```python
+from openai import OpenAI
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionUserMessageParam,
+)
+from openai_function_calling.tool_helpers import ToolHelpers
+
+
+# Define our functions.
+def get_current_weather(location: str, unit: str) -> str:
+    """Get the current weather and return a summary."""
+    return f"It is currently sunny in {location} and 75 degrees {unit}."
+
+
+def get_tomorrows_weather(location: str, unit: str) -> str:
+    """Get tomorrow's weather and return a summary."""
+    return f"It will be rainy tomorrow in {location} and around 65 degrees {unit}."
+
+
+openai_client = OpenAI()
+
+# Send the query and our function context to OpenAI.
+response: ChatCompletion = openai_client.chat.completions.create(
+    model="gpt-3.5-turbo-1106",
+    messages=[
+        ChatCompletionUserMessageParam(
+            role="user", content="What's the weather in Boston MA?"
+        ),
+    ],
+    tools=ToolHelpers.infer_from_function_refs(
+        [get_current_weather, get_tomorrows_weather]
+    ),
+    tool_choice="auto",
+)
+```
+
 ## Examples
 
 To run the examples, set the environment variable `OPENAI_API_KEY` to your OpenAI API key. For example:

examples/weather_functions.py

@@ -9,8 +9,15 @@
 from typing import Any
 
 import openai
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionMessageToolCall,
+    ChatCompletionUserMessageParam,
+)
 
-from openai_function_calling import Function, FunctionDict, JsonSchemaType, Parameter
+from openai_function_calling import Function, JsonSchemaType, Parameter
+from openai_function_calling.tool_helpers import ToolHelpers
 
 
 # Define our functions.
@@ -44,41 +51,44 @@ def get_tomorrows_weather(location: str, unit: str) -> str:
     parameters=[location_parameter, unit_parameter],
 )
 
-get_current_weather_function_dict: FunctionDict = (
-    get_current_weather_function.to_json_schema()
-)
-get_tomorrows_weather_function_dict: FunctionDict = (
-    get_tomorrows_weather_function.to_json_schema()
-)
-
 
 # Send the query and our function context to OpenAI.
-response: Any = openai.ChatCompletion.create(
+response: ChatCompletion = openai.chat.completions.create(
     model="gpt-3.5-turbo-0613",
     messages=[
-        {
-            "role": "user",
-            "content": "What will the weather be tomorrow in Boston MA in celsius?",
-        },
+        ChatCompletionUserMessageParam(
+            role="user",
+            content="What's the weather tomorrow in Boston MA in fahrenheit?",
+        ),
     ],
-    functions=[get_current_weather_function_dict, get_tomorrows_weather_function_dict],
-    function_call="auto",  # Auto is the default.
+    tools=ToolHelpers.from_functions(
+        [
+            get_current_weather_function,
+            get_tomorrows_weather_function,
+        ]
+    ),
+    tool_choice="auto",  # Auto is the default.
 )
 
-response_message = response["choices"][0]["message"]
+response_message: ChatCompletionMessage = response.choices[0].message
+
 
 # Check if GPT wants to call a function.
-if response_message.get("function_call"):
+if response_message.tool_calls is not None:
     # Call the function.
     available_functions: dict[str, Callable] = {
         "get_current_weather": get_current_weather,
         "get_tomorrows_weather": get_tomorrows_weather,
     }
 
-    function_name = response_message["function_call"]["name"]
-    function_args = json.loads(response_message["function_call"]["arguments"])
-    function_to_call: Callable = available_functions[function_name]
-    function_response: Any = function_to_call(**function_args)
+    tool_call: ChatCompletionMessageToolCall = response_message.tool_calls[0]
+    function = tool_call.function
+    arguments: str = function.arguments
+    function_name: str = tool_call.function.name
+
+    function_args: dict = json.loads(arguments)
+    function_reference: Callable = available_functions[function_name]
+    function_response: Any = function_reference(**function_args)
 
     print(f"Called {function_name} with response: '{function_response!s}'.")
 else:

examples/weather_functions_infer.py

@@ -8,9 +8,17 @@
 from collections.abc import Callable
 from typing import Any
 
-import openai
+from openai import OpenAI
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionUserMessageParam,
+)
+from openai.types.chat.chat_completion_message_tool_call import (
+    ChatCompletionMessageToolCall,
+)
 
-from openai_function_calling import FunctionInferer
+from openai_function_calling.tool_helpers import ToolHelpers
 
 
 # Define our functions.
@@ -24,42 +32,40 @@ def get_tomorrows_weather(location: str, unit: str) -> str:
     return f"It will be rainy tomorrow in {location} and around 65 degrees {unit}."
 
 
-get_current_weather_schema = FunctionInferer.infer_from_function_reference(
-    get_current_weather,
-).to_json_schema()
-
-get_tomorrows_weather_schema = FunctionInferer.infer_from_function_reference(
-    get_tomorrows_weather,
-).to_json_schema()
-
+openai_client = OpenAI()
 
 # Send the query and our function context to OpenAI.
-response: Any = openai.ChatCompletion.create(
-    model="gpt-3.5-turbo-0613",
+response: ChatCompletion = openai_client.chat.completions.create(
+    model="gpt-3.5-turbo-1106",
     messages=[
-        {
-            "role": "user",
-            "content": "What will the weather be tomorrow in Boston MA in celsius?",
-        },
+        ChatCompletionUserMessageParam(
+            role="user", content="What's the weather in Boston MA?"
+        ),
     ],
-    functions=[get_current_weather_schema, get_tomorrows_weather_schema],
-    function_call="auto",  # Auto is the default.
+    tools=ToolHelpers.infer_from_function_refs(
+        [get_current_weather, get_tomorrows_weather]
+    ),
+    tool_choice="auto",
 )
 
-response_message = response["choices"][0]["message"]
+response_message: ChatCompletionMessage = response.choices[0].message
 
 # Check if GPT wants to call a function.
-if response_message.get("function_call"):
+if response_message.tool_calls is not None:
     # Call the function.
     available_functions: dict[str, Callable] = {
         "get_current_weather": get_current_weather,
         "get_tomorrows_weather": get_tomorrows_weather,
     }
 
-    function_name = response_message["function_call"]["name"]
-    function_args = json.loads(response_message["function_call"]["arguments"])
-    function_to_call: Callable = available_functions[function_name]
-    function_response: Any = function_to_call(**function_args)
+    tool_call: ChatCompletionMessageToolCall = response_message.tool_calls[0]
+    function = tool_call.function
+    arguments: str = function.arguments
+    function_name: str = tool_call.function.name
+
+    function_args: dict = json.loads(arguments)
+    function_reference: Callable = available_functions[function_name]
+    function_response: Any = function_reference(**function_args)
 
     print(f"Called {function_name} with response: '{function_response!s}'.")
 else:

openai_function_calling/__init__.py

@@ -1,16 +1,15 @@
 """OpenAI Function Calling Package."""
 
-from openai_function_calling.function import Function, FunctionDict, ParametersDict
-from openai_function_calling.function_inferer import FunctionInferer
+from openai_function_calling.function import Function, FunctionDict
+from openai_function_calling.function_inferrer import FunctionInferrer
 from openai_function_calling.json_schema_type import JsonSchemaType
 from openai_function_calling.parameter import Parameter, ParameterDict
 
 __all__: list[str] = [
     "Function",
     "FunctionDict",
-    "ParametersDict",
     "Parameter",
     "ParameterDict",
     "JsonSchemaType",
-    "FunctionInferer",
+    "FunctionInferrer",
 ]

openai_function_calling/function.py

@@ -1,11 +1,10 @@
 """Define the Function class and related objects."""
 
-
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, TypedDict
 
-from typing_extensions import NotRequired, deprecated
+from typing_extensions import NotRequired, deprecated  # type: ignore[attr-defined]
 
 from openai_function_calling.json_schema_type import JsonSchemaType
 

…nai_function_calling/function_inferer.py …ai_function_calling/function_inferrer.pyopenai_function_calling/function_inferer.py renamed to openai_function_calling/function_inferrer.py openai_function_calling/function_inferer.py renamed to openai_function_calling/function_inferrer.py

@@ -1,4 +1,4 @@
-"""Function inferer class definition."""
+"""Function inferrer class definition."""
 
 import inspect
 from collections.abc import Callable
@@ -12,7 +12,7 @@
 from openai_function_calling.parameter import Parameter
 
 
-class FunctionInferer:
+class FunctionInferrer:
     """Class to help inferring a function definition from a reference."""
 
     @staticmethod
@@ -27,13 +27,13 @@ def infer_from_function_reference(function_reference: Callable) -> Function:
         Return:
             An instance of Function with inferred values.
         """
-        inferred_from_annotations: Function = FunctionInferer._infer_from_annotations(
+        inferred_from_annotations: Function = FunctionInferrer._infer_from_annotations(
             function_reference
         )
-        inferred_from_docstring: Function = FunctionInferer._infer_from_docstring(
+        inferred_from_docstring: Function = FunctionInferrer._infer_from_docstring(
             function_reference
         )
-        inferred_from_inspection: Function = FunctionInferer._infer_from_inspection(
+        inferred_from_inspection: Function = FunctionInferrer._infer_from_inspection(
             function_reference
         )
 

openai_function_calling/parameter.py

@@ -6,7 +6,7 @@
 
 from openai_function_calling.json_schema_type import JsonSchemaType
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from typing_extensions import NotRequired