Added progress components CircularProgress, CircularProgressWithLabel,

  `LinearProgress`, `LinearProgressWithLabel`: added more tests.

Author: forman

chartlets.py/CHANGES.md

@@ -1,5 +1,8 @@
 ## Version 0.0.22 (in development)
 
+* Added progress components `CircularProgress`, `CircularProgressWithLabel`, 
+  `LinearProgress`, `LinearProgressWithLabel`.
+
 * Replacing components is now possible by using an 
   `Output` with `property` set to an empty string. (#38)
 

chartlets.py/chartlets/component.py

@@ -31,6 +31,9 @@ class Component(ABC):
     label: str | None = None
     """HTML `label` attribute. Optional."""
 
+    color: str | None = None
+    """HTML `color` attribute. Optional."""
+
     children: list[Union["Component", str]] | None = None
     """Children used by many specific components. Optional."""
 

chartlets.py/chartlets/components/__init__.py

@@ -1,6 +1,10 @@
 from .box import Box
 from .button import Button
 from .checkbox import Checkbox
+from .progress import CircularProgress
+from .progress import CircularProgressWithLabel
+from .progress import LinearProgress
+from .progress import LinearProgressWithLabel
 from .plot import Plot
 from .select import Select
 from .typography import Typography

chartlets.py/chartlets/components/progress.py

@@ -0,0 +1,49 @@
+from abc import ABC
+from dataclasses import dataclass, field
+from typing import Literal
+
+from chartlets import Component
+
+
+@dataclass(frozen=True)
+class Progress(Component, ABC):
+    """Progress indicators commonly known as spinners,
+    express an unspecified wait time or display the length of a process.
+    """
+
+    value: int | None = None
+    """Progress value in percent. Optional."""
+
+    variant: str | None = None
+    """Progress size. Example values: `"determinate"` or the default `"indeterminate"`."""
+
+
+@dataclass(frozen=True)
+class CircularProgress(Progress):
+    """Progress indicators commonly known as spinners,
+    express an unspecified wait time or display the length of a process.
+    """
+
+    size: str | int | None = None
+    """Progress size. Example values: `"30px"`, `40`, `"3rem"`."""
+
+
+@dataclass(frozen=True)
+class CircularProgressWithLabel(CircularProgress):
+    """Progress indicators commonly known as spinners,
+    express an unspecified wait time or display the length of a process.
+    """
+
+
+@dataclass(frozen=True)
+class LinearProgress(Progress):
+    """Progress indicators commonly known as spinners,
+    express an unspecified wait time or display the length of a process.
+    """
+
+
+@dataclass(frozen=True)
+class LinearProgressWithLabel(LinearProgress):
+    """Progress indicators commonly known as spinners,
+    express an unspecified wait time or display the length of a process.
+    """

chartlets.py/chartlets/components/typography.py

@@ -9,10 +9,23 @@ class Typography(Component):
     and efficiently as possible."""
 
     text: str | None = None
-    """Text to be displayed. Optional"""
+    """Text to be displayed."""
+
+    align: str | None = None
+    """Set the text-align on the component."""
 
     color: str | None = None
     """The color of the component."""
 
     variant: str | None = None
     """Applies the theme typography styles."""
+
+    gutterBottom: bool | None = None
+    """If True, the text will have a bottom margin."""
+
+    noWrap: bool | None = None
+    """If true, the text will not wrap, but instead will 
+    truncate with a text overflow ellipsis."""
+
+    component: str | None = None
+    """The HTML element used for the root node."""

chartlets.py/tests/component_test.py

@@ -1,28 +1,47 @@
-import unittest
 from dataclasses import dataclass
+import json
+import unittest
+from typing import Any
+
 
 from chartlets import Component
 
 
+def make_base(component_cls: type):
+    class ComponentTestBase(unittest.TestCase):
+
+        cls = component_cls
+
+        def assert_is_json_serializable(
+            self, component: Component, expected_dict: dict[str, Any]
+        ):
+            self.assertIsInstance(component, Component)
+
+            actual_dict = component.to_dict()
+            self.assertIsInstance(actual_dict, dict)
+
+            serialized = json.dumps(actual_dict)
+            deserialized = json.loads(serialized)
+            self.assertEqual(expected_dict, deserialized)
+
+        def test_type_is_class_name(self):
+            component = self.cls()
+            self.assertIsInstance(component, Component)
+            self.assertEqual(self.cls.__name__, component.type)
+
+    return ComponentTestBase
+
+
 @dataclass(frozen=True)
 class Pin(Component):
     text: str = ""
 
 
 # noinspection PyMethodMayBeStatic
-class ComponentTest(unittest.TestCase):
-    pin = Pin(id="p12", text="hello!", style={"color": "red"})
-
-    def test_attributes(self):
-        pin = self.pin
-        self.assertEqual("Pin", pin.type)
-        self.assertEqual("p12", pin.id)
-        self.assertEqual("hello!", pin.text)
-        self.assertEqual({"color": "red"}, pin.style)
-
-    def test_to_dict(self):
-        pin = self.pin
-        self.assertEqual(
+class ComponentTest(make_base(Pin)):
+
+    def test_is_json_serializable(self):
+        self.assert_is_json_serializable(
+            self.cls(id="p12", text="hello!", style={"color": "red"}),
             {"type": "Pin", "id": "p12", "text": "hello!", "style": {"color": "red"}},
-            pin.to_dict(),
         )

chartlets.py/tests/components/box_test.py

@@ -1,22 +1,24 @@
-import json
-import unittest
-
 from chartlets.components import Box
+from tests.component_test import make_base
 
 
-class BoxTest(unittest.TestCase):
+class BoxTest(make_base(Box)):
 
     def test_is_json_serializable(self):
-        box = Box(
-            children=[
-                Box(id="b1"),
-                Box(id="b2"),
-            ]
+        self.assert_is_json_serializable(
+            self.cls(
+                children=[
+                    Box(id="b1"),
+                    Box(id="b2"),
+                ],
+                style={"color": "grey", "display": "flex"},
+            ),
+            {
+                "type": "Box",
+                "children": [
+                    {"children": [], "id": "b1", "type": "Box"},
+                    {"children": [], "id": "b2", "type": "Box"},
+                ],
+                "style": {"color": "grey", "display": "flex"},
+            },
         )
-
-        d = box.to_dict()
-        self.assertIsInstance(d, dict)
-        self.assertIsInstance(d.get("children"), list)
-        json_text = json.dumps(d)
-        self.assertEqual("{", json_text[0])
-        self.assertEqual("}", json_text[-1])

chartlets.py/tests/components/button_test.py

@@ -0,0 +1,11 @@
+from chartlets.components import Button
+from tests.component_test import make_base
+
+
+class ButtonTest(make_base(Button)):
+
+    def test_is_json_serializable(self):
+        self.assert_is_json_serializable(
+            self.cls(text="Update"),
+            {"type": "Button", "text": "Update"},
+        )

chartlets.py/tests/components/checkbox_test.py

@@ -0,0 +1,11 @@
+from chartlets.components import Checkbox
+from tests.component_test import make_base
+
+
+class CheckboxTest(make_base(Checkbox)):
+
+    def test_is_json_serializable(self):
+        self.assert_is_json_serializable(
+            self.cls(value=True, label="Auto-safe"),
+            {"type": "Checkbox", "value": True, "label": "Auto-safe"},
+        )

chartlets.py/tests/components/plot_test.py

@@ -7,30 +7,49 @@
 from chartlets.components import Plot
 
 
-class PlotTest(unittest.TestCase):
-    def setUp(self):
-        dataset = pd.DataFrame(
+from tests.component_test import make_base
+
+
+class PlotTest(make_base(Plot)):
+
+    def test_is_json_serializable(self):
+        source = pd.DataFrame(
             {"x": ["A", "B", "C", "D", "E"], "a": [28, 55, 43, 91, 81]}
         )
         self.chart = (
-            alt.Chart(dataset)
+            alt.Chart(source)
             .mark_bar()
             .encode(
                 x=alt.X("x:N", title="x"),
                 y=alt.Y("a:Q", title="a"),
             )
         )
 
-    def test_is_json_serializable(self):
-
-        plot = Plot(id="plot", chart=self.chart)
-        p = plot.to_dict()
-
-        print(p)
-        self.assertIsInstance(p, dict)
-        self.assertEqual(p["type"], "Plot")
-        self.assertIsInstance(p["chart"], dict)
-        self.assertEqual(p["chart"]["mark"], {"type": "bar"})
-        json_text = json.dumps(p)
-        self.assertEqual("{", json_text[0])
-        self.assertEqual("}", json_text[-1])
+        self.assert_is_json_serializable(
+            self.cls(id="plot", chart=self.chart),
+            {
+                "chart": {
+                    "$schema": "https://vega.github.io/schema/vega-lite/v5.20.1.json",
+                    "config": {
+                        "view": {"continuousHeight": 300, "continuousWidth": 300}
+                    },
+                    "data": {"name": "data-2780b27b376c14369bf3f449cf25f092"},
+                    "datasets": {
+                        "data-2780b27b376c14369bf3f449cf25f092": [
+                            {"a": 28, "x": "A"},
+                            {"a": 55, "x": "B"},
+                            {"a": 43, "x": "C"},
+                            {"a": 91, "x": "D"},
+                            {"a": 81, "x": "E"},
+                        ]
+                    },
+                    "encoding": {
+                        "x": {"field": "x", "title": "x", "type": "nominal"},
+                        "y": {"field": "a", "title": "a", "type": "quantitative"},
+                    },
+                    "mark": {"type": "bar"},
+                },
+                "id": "plot",
+                "type": "Plot",
+            },
+        )