Fixed a bug deriving JSON schema

Author: forman

chartlets.py/CHANGES.md

@@ -1,3 +1,9 @@
+## Version 0.0.x (in development)
+
+* Fixed a bug that prevent using annotations of type `dict` or `dict[str, T]`.
+  in callback functions.
+
+
 ## Version 0.0.28 (from 2024/11/26)
 
 * Updated docs.

chartlets.py/chartlets/callback.py

@@ -158,23 +158,45 @@ def _parameter_to_dict(parameter: inspect.Parameter) -> dict[str, Any]:
     return d
 
 
-_scalar_types = {
-    "None": "null",
-    "NoneType": "null",
-    "bool": "boolean",
-    "int": "integer",
-    "float": "number",
-    "str": "string",
-    "object": "object",
+_basic_types = {
+    None: "null",
+    type(None): "null",
+    bool: "boolean",
+    int: "integer",
+    float: "number",
+    str: "string",
+    list: "array",
+    tuple: "array",
+    dict: "object",
 }
 
 _object_types = {"Component": "Component", "Chart": "Chart"}
 
 
 def _annotation_to_json_schema(annotation: Any) -> dict:
+    if annotation is Any:
+        return {}
+
+    if annotation in _basic_types:
+        return {"type": _basic_types[annotation]}
+
     if isinstance(annotation, types.UnionType):
-        return {"type": list(map(_annotation_to_json_schema, annotation.__args__))}
-    elif isinstance(annotation, types.GenericAlias):
+        type_list = list(map(_annotation_to_json_schema, annotation.__args__))
+        type_name_list = [
+            t["type"] for t in type_list if isinstance(t.get("type"), str)
+        ]
+        if len(type_name_list) == 1:
+            return {"type": type_name_list[0]}
+        elif len(type_name_list) > 1:
+            return {"type": type_name_list}
+        elif len(type_list) == 1:
+            return type_list[0]
+        elif len(type_list) > 1:
+            return {"oneOf": type_list}
+        else:
+            return {}
+
+    if isinstance(annotation, types.GenericAlias):
         if annotation.__origin__ is tuple:
             return {
                 "type": "array",
@@ -190,21 +212,26 @@ def _annotation_to_json_schema(annotation: Any) -> dict:
                 return {
                     "type": "array",
                 }
-    elif issubclass(annotation, list):
-        try:
-            return {"type": "array"}
-        except KeyError:
-            pass
+        elif annotation.__origin__ is dict:
+            if annotation.__args__:
+                if len(annotation.__args__) == 2 and annotation.__args__[0] is str:
+                    return {
+                        "type": "object",
+                        "additionalProperties": _annotation_to_json_schema(
+                            annotation.__args__[1]
+                        ),
+                    }
+            else:
+                return {
+                    "type": "object",
+                }
     else:
         type_name = (
             annotation.__name__ if hasattr(annotation, "__name__") else str(annotation)
         )
-        try:
-            return {"type": _scalar_types[type_name]}
-        except KeyError:
-            pass
         try:
             return {"type": "object", "class": _object_types[type_name]}
         except KeyError:
             pass
+
     raise TypeError(f"unsupported type annotation: {annotation}")

chartlets.py/chartlets/components/button.py

@@ -28,6 +28,7 @@ class Button(Component):
     One "contained" | "outlined" | "text". Defaults to "text".
     """
 
+
 @dataclass(frozen=True)
 class IconButton(Component):
     """Icon buttons are commonly found in app bars and toolbars.
@@ -49,5 +50,3 @@ class IconButton(Component):
     """The button variant. 
     One "contained" | "outlined" | "text". Defaults to "text".
     """
-
-

chartlets.py/chartlets/contribution.py

@@ -123,9 +123,7 @@ def callback(self, *args: Input | State | Output) -> Callable[[Callable], Callab
 
         def decorator(function: Callable) -> Callable:
             self.callbacks.append(
-                Callback.from_decorator(
-                    "callback", args, function, states_only=False
-                )
+                Callback.from_decorator("callback", args, function, states_only=False)
             )
             return function
 

chartlets.py/tests/callback_test.py

@@ -1,8 +1,10 @@
 import unittest
+from typing import Any
 
 import pytest
 
-from chartlets.callback import Input, Callback, Output
+from chartlets.channel import Input, State, Output
+from chartlets.callback import Callback
 
 
 # noinspection PyUnusedLocal
@@ -13,6 +15,7 @@ def my_callback(
     b: str | int = "",
     c: bool | None = False,
     d: list[str] = (),
+    e: dict[str, Any] = (),
 ) -> str:
     return f"{a}-{b}-{c}-{d}"
 
@@ -31,7 +34,9 @@ def test_make_function_args(self):
 
     def test_to_dict_with_no_outputs(self):
         callback = Callback(
-            my_callback, [Input("a"), Input("b"), Input("c"), Input("d")], []
+            my_callback,
+            [Input("a"), Input("b"), Input("c"), Input("d"), State("e")],
+            [],
         )
         d = callback.to_dict()
         # print(json.dumps(d, indent=2))
@@ -44,38 +49,32 @@ def test_to_dict_with_no_outputs(self):
                         {
                             "default": "",
                             "name": "b",
-                            "type": {"type": [{"type": "string"}, {"type": "integer"}]},
+                            "type": {"type": ["string", "integer"]},
                         },
                         {
                             "default": False,
                             "name": "c",
-                            "type": {"type": [{"type": "boolean"}, {"type": "null"}]},
+                            "type": {"type": ["boolean", "null"]},
                         },
                         {
                             "default": (),
                             "name": "d",
                             "type": {"items": {"type": "string"}, "type": "array"},
                         },
+                        {
+                            "default": (),
+                            "name": "e",
+                            "type": {"additionalProperties": {}, "type": "object"},
+                        },
                     ],
                     "returnType": {"type": "string"},
                 },
                 "inputs": [
-                    {
-                        "id": "a",
-                        "property": "value",
-                    },
-                    {
-                        "id": "b",
-                        "property": "value",
-                    },
-                    {
-                        "id": "c",
-                        "property": "value",
-                    },
-                    {
-                        "id": "d",
-                        "property": "value",
-                    },
+                    {"id": "a", "property": "value"},
+                    {"id": "b", "property": "value"},
+                    {"id": "c", "property": "value"},
+                    {"id": "d", "property": "value"},
+                    {"id": "e", "noTrigger": True, "property": "value"},
                 ],
             },
             d,
@@ -100,26 +99,15 @@ def test_to_dict_with_two_outputs(self):
                     "returnType": {
                         "items": [
                             {"items": {"type": "string"}, "type": "array"},
-                            {"type": [{"type": "string"}, {"type": "null"}]},
+                            {"type": ["string", "null"]},
                         ],
                         "type": "array",
                     },
                 },
-                "inputs": [
-                    {
-                        "id": "n",
-                        "property": "value",
-                    }
-                ],
+                "inputs": [{"id": "n", "property": "value"}],
                 "outputs": [
-                    {
-                        "id": "select",
-                        "property": "options",
-                    },
-                    {
-                        "id": "select",
-                        "property": "value",
-                    },
+                    {"id": "select", "property": "options"},
+                    {"id": "select", "property": "value"},
                 ],
             },
             d,
@@ -133,18 +121,18 @@ def test_too_few_inputs(self):
         with pytest.raises(
             TypeError,
             match="too few inputs in decorator 'test' for function"
-            " 'my_callback': expected 4, but got 0",
+            " 'my_callback': expected 5, but got 0",
         ):
             Callback.from_decorator("test", (), my_callback)
 
     def test_too_many_inputs(self):
         with pytest.raises(
             TypeError,
             match="too many inputs in decorator 'test' for function"
-            " 'my_callback': expected 4, but got 5",
+            " 'my_callback': expected 5, but got 7",
         ):
             Callback.from_decorator(
-                "test", tuple(Input(c) for c in "abcde"), my_callback
+                "test", tuple(Input(c) for c in "abcdefg"), my_callback
             )
 
     def test_decorator_target(self):

chartlets.py/tests/channel_test.py

@@ -80,7 +80,7 @@ def test_to_dict(self):
 
         def test_no_arguments(self):
             with pytest.raises(
-                    TypeError, match="missing 1 required positional argument: 'id'"
+                TypeError, match="missing 1 required positional argument: 'id'"
             ):
                 # noinspection PyArgumentList
                 obj = self.channel_cls()
@@ -108,6 +108,7 @@ def test_component_empty_property(self):
         with pytest.raises(ValueError, match="value for 'property' must be given"):
             self.channel_cls("dataset_select", "")
 
+
 class OutputTest(make_base(), unittest.TestCase):
     channel_cls = Output