Merge pull request #5 from comfuture/literal-type

drop "integer" in schema type

Author: comfuture

.github/workflows/ci.yml

@@ -16,17 +16,17 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
       with:
         python-version: ${{ matrix.python-version }}
+    - name: Set up uv
+      run: curl -LsSf https://astral.sh/uv/0.3.2/install.sh | sh
     - name: Install dependencies
-      run: |
-        python -m pip install pytest flit
-        flit install -s
+      run: uv sync --all-extras --dev
     - name: run test
-      run: pytest
+      run: uv run pytest

.github/workflows/python-publish.yml

@@ -21,17 +21,15 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v4
       with:
         python-version: '3.x'
+    - name: Set up uv
+      run: curl -LsSf https://astral.sh/uv/0.3.2/install.sh | sh
     - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install build
-    - name: Build package
-      run: python -m build
+      run: uvx --from build pyproject-build --installer uv
     - name: Publish package
       uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
       with:

README.md

@@ -89,6 +89,23 @@ schema = get_function_schema(get_weather, "claude")
 
 Please refer to the [Claude tool use](https://docs.anthropic.com/claude/docs/tool-use) documentation for more information.
 
+### Literal types can be used as Enum
+
+```python
+def get_weather(
+    city: Annotated[str, "The city to get the weather for"],
+    unit: Annotated[
+        Optional[Literal["celcius", "fahrenheit"]], # <- Literal type represents Enum
+        "The unit to return the temperature in",
+    ] = "celcius",
+) -> str:
+    """Returns the weather for the given city."""
+    return f"Weather for {city} is 20°C"
+```
+The schema will be generated as the same as the previous example.
+
+### Usage with OpenAI API
+
 You can use this schema to make a function call in OpenAI API:
 ```python
 import openai
@@ -118,12 +135,15 @@ result = openai.chat.completion.create(
     messages=[
         {"role": "user", "content": "What's the weather like in Seoul?"}
     ],
-    tools=[get_function_schema(get_weather)],
+    tools=[{
+      "type": "function",
+      "function": get_function_schema(get_weather)
+    }],
     tool_call="auto",
 )
 ```
 
-In claude api,
+### Usage with Anthropic Claude
 
 ```python
 import anthropic

function_schema/core.py

@@ -166,8 +166,8 @@ def guess_type(
         ]
 
         # number contains integer in JSON schema
-        if "number" in _types and "integer" in _types:
-            _types.remove("integer")
+        # deduplicate
+        _types = list(set(_types))
 
         if len(_types) == 1:
             return _types[0]
@@ -191,10 +191,10 @@ def guess_type(
         return "string"
     if issubclass(T, bool):
         return "boolean"
-    if issubclass(T, float):
+    if issubclass(T, (float, int)):
         return "number"
-    elif issubclass(T, int):
-        return "integer"
+    # elif issubclass(T, int):
+    #     return "integer"
     if T.__name__ == "list":
         return "array"
     if T.__name__ == "dict":

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "function-schema"
-version = "0.3.4"
+version = "0.3.6"
 requires-python = ">= 3.9"
 description = "A small utility to generate JSON schemas for python functions."
 readme = "README.md"

test/test_guess_type.py

@@ -8,7 +8,7 @@
 
 def test_primitive():
     """Test primitive types"""
-    assert guess_type(int) == "integer"
+    assert guess_type(int) == "number"
     assert guess_type(str) == "string"
     assert guess_type(float) == "number"
     assert guess_type(bool) == "boolean"
@@ -32,39 +32,39 @@ def test_typings():
 
 def test_optional():
     """Test optional types"""
-    assert guess_type(typing.Optional[int]) == "integer"
+    assert guess_type(typing.Optional[int]) == "number"
     assert guess_type(typing.Optional[str]) == "string"
     assert guess_type(typing.Optional[float]) == "number"
     assert guess_type(typing.Optional[bool]) == "boolean"
 
 
 def test_union_null():
     """Test union types with null"""
-    assert guess_type(typing.Union[int, None]) == "integer"
+    assert guess_type(typing.Union[int, None]) == "number"
     assert guess_type(typing.Union[str, None]) == "string"
     assert guess_type(typing.Union[float, None]) == "number"
     assert guess_type(typing.Union[bool, None]) == "boolean"
 
 
 def test_union():
     """Test union types"""
-    assert guess_type(typing.Union[int, str]) == ["integer", "string"]
+    assert set(guess_type(typing.Union[int, str])) == {"number", "string"}
     assert guess_type(typing.Union[int, float]) == "number"
-    assert guess_type(typing.Union[int, bool]) == ["integer", "boolean"]
-    assert guess_type(typing.Union[bool, int]) == ["boolean", "integer"]
-    assert guess_type(typing.Union[str, float]) == ["string", "number"]
-    assert guess_type(typing.Union[str, bool]) == ["string", "boolean"]
-    assert guess_type(typing.Union[float, bool]) == ["number", "boolean"]
-    assert guess_type(typing.Union[str, float, bool]) == [
+    assert set(guess_type(typing.Union[int, bool])) == {"number", "boolean"}
+    assert set(guess_type(typing.Union[bool, int])) == {"boolean", "number"}
+    assert set(guess_type(typing.Union[str, float])) == {"string", "number"}
+    assert set(guess_type(typing.Union[str, bool])) == {"string", "boolean"}
+    assert set(guess_type(typing.Union[float, bool])) == {"number", "boolean"}
+    assert set(guess_type(typing.Union[str, float, bool])) == {
         "string",
         "number",
         "boolean",
-    ]
-    assert guess_type(typing.Union[str, float, bool, None]) == [
+    }
+    assert set(guess_type(typing.Union[str, float, bool, None])) == {
         "string",
         "number",
         "boolean",
-    ]
+    }
 
 
 current_version = packaging.version.parse(platform.python_version())
@@ -77,37 +77,36 @@ def test_union():
 def test_union_type():
     """Test union types in Python 3.10+"""
 
-    assert guess_type(int | str) == ["integer", "string"]
+    assert set(guess_type(int | str)) == {"number", "string"}
     assert guess_type(int | float) == "number"
-    assert guess_type(int | bool) == ["integer", "boolean"]
-    assert guess_type(bool | int) == ["boolean", "integer"]
-    assert guess_type(str | float) == ["string", "number"]
-    assert guess_type(str | bool) == ["string", "boolean"]
-    assert guess_type(float | bool) == ["number", "boolean"]
-    assert guess_type(str | float | bool) == [
+    assert set(guess_type(int | bool)) == {"number", "boolean"}
+    assert set(guess_type(str | float)) == {"string", "number"}
+    assert set(guess_type(str | bool)) == {"string", "boolean"}
+    assert set(guess_type(float | bool)) == {"number", "boolean"}
+    assert set(guess_type(str | float | bool)) == {
         "string",
         "number",
         "boolean",
-    ]
-    assert guess_type(str | float | bool | None) == [
+    }
+    assert set(guess_type(str | float | bool | None)) == {
         "string",
         "number",
         "boolean",
-    ]
+    }
 
 
 def test_literal_type():
     """Test literal type"""
     assert guess_type(typing.Literal["a"]) == "string", "should be string"
-    assert guess_type(typing.Literal[1]) == "integer", "should be integer"
+    assert guess_type(typing.Literal[1]) == "number", "should be number"
     assert guess_type(typing.Literal[1.0]) == "number", "should be number"
 
     assert set(guess_type(typing.Literal["a", 1, None])) == {
         "string",
-        "integer",
+        "number",
     }, "should be string or integer, omit None"
 
-    assert set(guess_type(typing.Literal["a", 1])) == {"string", "integer"}
+    assert set(guess_type(typing.Literal["a", 1])) == {"string", "number"}
     assert set(guess_type(typing.Literal["a", 1.0])) == {"string", "number"}
     assert set(guess_type(typing.Literal["a", 1.1])) == {"string", "number"}
     assert set(guess_type(typing.Literal["a", 1, 1.0])) == {

test/test_schema.py

@@ -36,7 +36,7 @@ def func1(a: int, b: str, c: float = 1.0):
         schema["description"] == "My function"
     ), "Function description should be there"
     assert (
-        schema["parameters"]["properties"]["a"]["type"] == "integer"
+        schema["parameters"]["properties"]["a"]["type"] == "number"
     ), "parameter a should be an integer"
     assert (
         schema["parameters"]["properties"]["b"]["type"] == "string"
@@ -66,7 +66,7 @@ def func1(
     schema = get_function_schema(func1)
 
     assert (
-        schema["parameters"]["properties"]["a"]["type"] == "integer"
+        schema["parameters"]["properties"]["a"]["type"] == "number"
     ), "parameter a should be an integer"
     assert (
         schema["parameters"]["properties"]["a"]["description"] == "An integer parameter"
@@ -145,21 +145,21 @@ def func3(animal: Literal["Cat", "Dog", 1]):
         ...
 
     schema = get_function_schema(func3)
-    assert schema["parameters"]["properties"]["animal"]["type"] == [
+    assert set(schema["parameters"]["properties"]["animal"]["type"]) == {
         "string",
-        "integer",
-    ], "parameter animal should be a string"
+        "number",
+    }, "parameter animal should be a string"
 
     def func4(animal: Literal["Cat", "Dog", 1, None]):
         """My function"""
         ...
 
     schema = get_function_schema(func4)
 
-    assert schema["parameters"]["properties"]["animal"]["type"] == [
+    assert set(schema["parameters"]["properties"]["animal"]["type"]) == {
         "string",
-        "integer",
-    ], "parameter animal should be a string"
+        "number",
+    }, "parameter animal should be a string"
 
     assert schema["parameters"]["properties"]["animal"]["enum"] == [
         "Cat",