Python test coverage almost at 100%

Author: forman

.gitignore

@@ -12,6 +12,8 @@ node_modules
 __pycache__
 # mkdocs
 site
+# pytest --cov
+.coverage
 
 # Editor directories and files
 .vscode/*

chartlets.js/CHANGES.md

@@ -29,6 +29,9 @@
   dark, light, and system mode.
 
 * Changed the yet unused descriptor type `CbFunction` for callback functions.
+  - using `schema` instead of `type` property for callback arguments
+  - using `return` object with `schema` property for callback return values
+
 
 ## Version 0.0.29 (from 2024/11/26)
 

chartlets.py/CHANGES.md

@@ -1,6 +1,5 @@
 ## Version 0.1.0 (in development)
 
-
 * Reorganised Chartlets project to better separate demo from library code.
   Created separate folder `demo` in `chartlets.py` that contains 
   a demo `server` package and example configuration.
@@ -14,6 +13,9 @@
 * Renamed `Plot` into `VegaChart`, which now also respects a `theme` property. 
 
 * Changed schema of the yet unused descriptor for callback functions.
+  - using `schema` instead of `type` property for callback arguments
+  - using `return` object with `schema` property for callback return values
+
 
 ## Version 0.0.29 (from 2024/11/26)
 

chartlets.py/chartlets/callback.py

@@ -2,11 +2,12 @@
 import types
 from typing import Any, Callable
 
-from chartlets.channel import (
+from .channel import (
     Input,
     Output,
     State,
 )
+from .util.logger import LOGGER
 
 
 class Callback:
@@ -20,7 +21,7 @@ class Callback:
     def from_decorator(
         cls,
         decorator_name: str,
-        decorator_args: tuple[Any, ...],
+        decorator_args: tuple | list,
         function: Any,
         states_only: bool = False,
     ) -> "Callback":
@@ -126,11 +127,10 @@ def make_function_args(
                 f" expected {num_inputs},"
                 f" but got {num_values}"
             )
-            if delta > 0:
-                values = (*values, *(delta * (None,)))
-                print(f"WARNING: {message}")  # TODO use logging
-            else:
+            if delta < 0:
                 raise TypeError(message)
+            LOGGER.warning(message)
+            values = (*values, *(delta * (None,)))
 
         param_names = self.param_names[1:]
         args = [context]
@@ -150,15 +150,14 @@ def _parameter_to_dict(parameter: inspect.Parameter) -> dict[str, Any]:
     empty = inspect.Parameter.empty
     d = {"name": parameter.name}
     if parameter.annotation is not empty:
-        d |= {"schema": _annotation_to_json_schema(parameter.annotation)}
+        d |= {"schema": annotation_to_json_schema(parameter.annotation)}
     if parameter.default is not empty:
         d |= {"default": parameter.default}
     return d
 
+
 def _return_to_dict(return_annotation: Any) -> dict[str, Any]:
-    return {
-        "schema": _annotation_to_json_schema(return_annotation)
-    }
+    return {"schema": annotation_to_json_schema(return_annotation)}
 
 
 _basic_types = {
@@ -173,68 +172,55 @@ def _return_to_dict(return_annotation: Any) -> dict[str, Any]:
     dict: "object",
 }
 
-_object_types = {"Component": "Component", "Chart": "Chart"}
 
+def annotation_to_json_schema(annotation: Any) -> dict:
+    from chartlets import Component
 
-def _annotation_to_json_schema(annotation: Any) -> dict:
     if annotation is Any:
         return {}
-
-    if annotation in _basic_types:
+    elif annotation in _basic_types:
         return {"type": _basic_types[annotation]}
-
-    if isinstance(annotation, types.UnionType):
-        type_list = list(map(_annotation_to_json_schema, annotation.__args__))
+    elif isinstance(annotation, types.UnionType):
+        assert annotation.__args__ and len(annotation.__args__) > 1
+        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)
+            t["type"]
+            for t in type_list
+            if isinstance(t.get("type"), str) and len(t) == 1
         ]
-        if len(type_name_list) == 1:
-            return {"type": type_name_list[0]}
-        elif len(type_name_list) > 1:
+        if len(type_list) == len(type_name_list):
             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):
+            return {"oneOf": type_list}
+    elif isinstance(annotation, types.GenericAlias):
+        assert annotation.__args__
         if annotation.__origin__ is tuple:
             return {
                 "type": "array",
-                "items": list(map(_annotation_to_json_schema, annotation.__args__)),
+                "items": list(map(annotation_to_json_schema, annotation.__args__)),
             }
         elif annotation.__origin__ is list:
-            if annotation.__args__:
-                return {
-                    "type": "array",
-                    "items": _annotation_to_json_schema(annotation.__args__[0]),
-                }
+            assert annotation.__args__ and len(annotation.__args__) == 1
+            items_schema = annotation_to_json_schema(annotation.__args__[0])
+            if items_schema == {}:
+                return {"type": "array"}
             else:
-                return {
-                    "type": "array",
-                }
+                return {"type": "array", "items": items_schema}
         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": "object", "class": _object_types[type_name]}
-        except KeyError:
-            pass
+            assert annotation.__args__
+            assert len(annotation.__args__) == 2
+            if annotation.__args__[0] is str:
+                value_schema = annotation_to_json_schema(annotation.__args__[1])
+                if value_schema == {}:
+                    return {"type": "object"}
+                else:
+                    return {"type": "object", "additionalProperties": value_schema}
+    elif (
+        inspect.isclass(annotation)
+        and "." not in annotation.__qualname__
+        and callable(getattr(annotation, "to_dict", None))
+    ):
+        # Note, for Component classes it is actually possible to generate the object schema
+        return {"type": "object", "class": annotation.__qualname__}
 
     raise TypeError(f"unsupported type annotation: {annotation}")

chartlets.py/chartlets/channel.py

@@ -2,7 +2,7 @@
 from typing import Any
 
 from .util.assertions import (
-    assert_is_given,
+    assert_is_not_empty,
     assert_is_instance_of,
     assert_is_one_of,
 )
@@ -26,13 +26,13 @@ def to_dict(self) -> dict[str, Any]:
             return dict(id=self.id, property=self.property)
 
     def _validate_params(self, id_: Any, property: Any) -> tuple[str, str | None]:
-        assert_is_given("id", id_)
+        assert_is_not_empty("id", id_)
         assert_is_instance_of("id", id_, str)
         id: str = id_
         if id.startswith("@"):
             # Other states than component states
             assert_is_one_of("id", id, ("@app", "@container"))
-            assert_is_given("property", property)
+            assert_is_not_empty("property", property)
             assert_is_instance_of("property", property, str)
         else:
             # Component state
@@ -44,7 +44,7 @@ def _validate_params(self, id_: Any, property: Any) -> tuple[str, str | None]:
                 pass
             else:
                 # Components must have valid properties
-                assert_is_given("property", property)
+                assert_is_not_empty("property", property)
                 assert_is_instance_of("property", property, str)
         return id, property
 

chartlets.py/chartlets/components/charts/vega.py

@@ -2,17 +2,23 @@
 from typing import Any
 import warnings
 
+from chartlets import Component
+
+
 # Respect that "altair" is an optional dependency.
+class AltairDummy:
+    # noinspection PyPep8Naming
+    @property
+    def Chart(self):
+        warnings.warn("you must install 'altair' to use the VegaChart component")
+        return int
+
+
 try:
     # noinspection PyUnresolvedReferences
     import altair
-
-    AltairChart = altair.Chart
 except ImportError:
-    warnings.warn("you must install 'altair' to use the VegaChart component")
-    AltairChart = type(None)
-
-from chartlets import Component
+    altair = AltairDummy()
 
 
 @dataclass(frozen=True)
@@ -27,7 +33,7 @@ class VegaChart(Component):
     theme: str | None = None
     """The name of a [Vega theme](https://vega.github.io/vega-themes/)."""
 
-    chart: AltairChart | None = None
+    chart: altair.Chart | None = None
     """The [Vega Altair chart](https://altair-viz.github.io/gallery/index.html)."""
 
     def to_dict(self) -> dict[str, Any]:

chartlets.py/chartlets/contribution.py

@@ -19,7 +19,6 @@ class Contribution(ABC):
         initial_state: contribution specific attribute values.
     """
 
-    # noinspection PyShadowingBuiltins
     def __init__(self, name: str, **initial_state: Any):
         self.name = name
         self.initial_state = initial_state

chartlets.py/chartlets/controllers/callback.py

@@ -2,6 +2,8 @@
 
 from chartlets.extensioncontext import ExtensionContext
 from chartlets.response import Response
+from chartlets.util.assertions import assert_is_instance_of
+from chartlets.util.assertions import assert_is_not_none
 
 
 # POST /chartlets/callback
@@ -20,8 +22,8 @@ def get_callback_results(
         On success, the response is a list of state-change requests
         grouped by contributions.
     """
-    if ext_ctx is None:
-        return Response.failed(404, f"no contributions configured")
+    assert_is_not_none("ext_ctx", ext_ctx)
+    assert_is_instance_of("data", data, dict)
 
     # TODO: validate data
     callback_requests: list[dict] = data.get("callbackRequests") or []

chartlets.py/chartlets/controllers/contributions.py

@@ -1,5 +1,6 @@
 from chartlets.extensioncontext import ExtensionContext
 from chartlets.response import Response
+from chartlets.util.assertions import assert_is_not_none
 
 
 def get_contributions(ext_ctx: ExtensionContext | None) -> Response:
@@ -13,9 +14,7 @@ def get_contributions(ext_ctx: ExtensionContext | None) -> Response:
         On success, the response is a dictionary that represents
         a JSON-serialized component tree.
     """
-    if ext_ctx is None:
-        return Response.failed(404, f"no contributions configured")
-
+    assert_is_not_none("ext_ctx", ext_ctx)
     extensions = ext_ctx.extensions
     contributions = ext_ctx.contributions
     return Response.success(

chartlets.py/chartlets/controllers/layout.py

@@ -2,6 +2,9 @@
 
 from chartlets.extensioncontext import ExtensionContext
 from chartlets.response import Response
+from chartlets.util.assertions import assert_is_not_none
+from chartlets.util.assertions import assert_is_not_empty
+from chartlets.util.assertions import assert_is_instance_of
 
 
 def get_layout(
@@ -25,8 +28,10 @@ def get_layout(
         On success, the response is a dictionary that represents
         a JSON-serialized component tree.
     """
-    if ext_ctx is None:
-        return Response.failed(404, f"no contributions configured")
+    assert_is_not_none("ext_ctx", ext_ctx)
+    assert_is_not_empty("contrib_point_name", contrib_point_name)
+    assert_is_instance_of("contrib_index", contrib_index, int)
+    assert_is_instance_of("data", data, dict)
 
     # TODO: validate data
     input_values = data.get("inputValues") or []
@@ -38,16 +43,20 @@ def get_layout(
             404, f"contribution point {contrib_point_name!r} not found"
         )
 
-    contrib_ref = f"{contrib_point_name}[{contrib_index}]"
-
     try:
         contribution = contributions[contrib_index]
     except IndexError:
-        return Response.failed(404, f"contribution {contrib_ref!r} not found")
+        return Response.failed(
+            404,
+            (
+                f"index range of contribution point {contrib_point_name!r} is"
+                f" 0 to {len(contributions) - 1}, got {contrib_index}"
+            ),
+        )
 
     callback = contribution.layout_callback
     if callback is None:
-        return Response.failed(400, f"contribution {contrib_ref!r} has no layout")
+        return Response.failed(400, f"contribution {contribution.name!r} has no layout")
 
     component = callback.invoke(ext_ctx.app_ctx, input_values)