scwidgets 0.1.0.dev0__tar.gz

scwidgets-0.1.0.dev0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, scicode-widgets developer team
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

scwidgets-0.1.0.dev0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.1
+Name: scwidgets
+Version: 0.1.0.dev0
+Summary: A collection of widgets to prepare interactive scientific visualisations, including user code input and validation
+License: BSD-3-Clause
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: ipywidgets>=8.0.0
+Requires-Dist: numpy<2.0.0
+Requires-Dist: widget_code_input>=4.0.13
+Requires-Dist: matplotlib
+Requires-Dist: termcolor
+
+Important
+=========
+
+So far scicode-widget has been created by prototyping without much concern about the code quality. This resulted in faster development time but in cost of readability and maintanability of the code. Since we finished now the prototype phase and have converged on a set of functionalities we are satisfied with, we are in the process of refactoring the resulting code in this branch. While we are refactoring we recommend the usage of the `vertical-slice branch <https://github.com/osscar-org/scicode-widgets/tree/vertical-slice>`_ till all features have been implemented in the refactor.
+
+
+scicode-widgets
+===============
+
+.. marker-package-description
+
+A collection of ipywidgets for the creation of interactive code demos and educational notebooks with exercises that can be checked and exported.
+
+Installation
+------------
+
+.. code-block:: bash
+
+  pip install .

scwidgets-0.1.0.dev0/README.rst

@@ -0,0 +1,19 @@
+Important
+=========
+
+So far scicode-widget has been created by prototyping without much concern about the code quality. This resulted in faster development time but in cost of readability and maintanability of the code. Since we finished now the prototype phase and have converged on a set of functionalities we are satisfied with, we are in the process of refactoring the resulting code in this branch. While we are refactoring we recommend the usage of the `vertical-slice branch <https://github.com/osscar-org/scicode-widgets/tree/vertical-slice>`_ till all features have been implemented in the refactor.
+
+
+scicode-widgets
+===============
+
+.. marker-package-description
+
+A collection of ipywidgets for the creation of interactive code demos and educational notebooks with exercises that can be checked and exported.
+
+Installation
+------------
+
+.. code-block:: bash
+
+  pip install .

scwidgets-0.1.0.dev0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+# setuptools requirement due to specifiying the version the in pyproject.toml
+# https://packaging.python.org/en/latest/guides/single-sourcing-package-version/
+requires = [
+    "setuptools>=61.0.0",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scwidgets"
+description = "A collection of widgets to prepare interactive scientific visualisations, including user code input and validation"
+readme = "README.rst"
+requires-python = ">=3.9"
+license = {text = "BSD-3-Clause"}
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Operating System :: POSIX",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Chemistry",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+  "ipywidgets>=8.0.0",
+  "numpy<2.0.0",
+  "widget_code_input>=4.0.13",
+  "matplotlib",
+  "termcolor"
+]
+dynamic = ["version"]
+
+[tool.setuptools.dynamic]
+version = {attr = "scwidgets.__version__"}
+readme = {file = ["README.rst"]}
+
+[tool.setuptools.package-data]
+scwidgets = ["css/widgets.css"]
+
+[tool.isort]
+profile = "black"

scwidgets-0.1.0.dev0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scwidgets-0.1.0.dev0/src/scwidgets/__init__.py

@@ -0,0 +1,47 @@
+__version__ = "0.1.0-dev0"
+__authors__ = "the scicode-widgets developer team"
+
+from ._css_style import CssStyle, get_css_style
+from .check import *  # noqa: F403
+from .code import *  # noqa: F403
+from .cue import *  # noqa: F403
+from .exercise import *  # noqa: F403
+
+__all__ = [  # noqa: F405
+    # css_style
+    "CssStyle",
+    "get_css_style",
+    # cue
+    "CueWidget",
+    "CheckCueBox",
+    "CueBox",
+    "SaveCueBox",
+    "UpdateCueBox",
+    "ResetCueButton",
+    "SaveResetCueButton",
+    "CheckResetCueButton",
+    "UpdateResetCueButton",
+    "CueOutput",
+    "CueObject",
+    "CueFigure",
+    # code
+    "CodeInput",
+    "ParameterPanel",
+    # check
+    "Check",
+    "CheckResult",
+    "AssertResult",
+    "CheckRegistry",
+    "CheckableWidget",
+    "assert_equal",
+    "assert_shape",
+    "assert_numpy_allclose",
+    "assert_type",
+    "assert_numpy_floating_sub_dtype",
+    "assert_numpy_sub_dtype",
+    # exercise
+    "CodeExercise",
+    "TextExercise",
+    "ExerciseWidget",
+    "ExerciseRegistry",
+]

scwidgets-0.1.0.dev0/src/scwidgets/_css_style.py

@@ -0,0 +1,24 @@
+import os
+
+from ipywidgets import HTML
+
+
+class CssStyle(HTML):
+    """
+    This HTML widget has to be displayed so the css style is loaded in the notebook.
+
+    :param preamble: Text to appear before the style sheet
+    """
+
+    def __init__(self, preamble: str = ""):
+        with open(os.path.join(os.path.dirname(__file__), "css/widgets.css")) as file:
+            style_txt = file.read()
+
+        HTML.__init__(self, preamble + "<style>" + style_txt + "</style>")
+
+
+def get_css_style() -> HTML:
+    return CssStyle(
+        preamble="HTML with scicode-widget css style sheet. "
+        "Please keep this cell output alive."
+    )

scwidgets-0.1.0.dev0/src/scwidgets/_utils.py

@@ -0,0 +1,46 @@
+import re
+
+from termcolor import colored
+
+
+class Formatter:
+    LINE_LENGTH = 120
+    INFO_COLOR = "blue"
+    ERROR_COLOR = "red"
+    SUCCESS_COLOR = "green"
+
+    @staticmethod
+    def format_title_message(message: str) -> str:
+        return message.center(Formatter.LINE_LENGTH - len(message) // 2, "-")
+
+    @staticmethod
+    def break_lines(message: str) -> str:
+        return "\n ".join(
+            re.findall(r".{1," + str(Formatter.LINE_LENGTH) + "}", message)
+        )
+
+    @staticmethod
+    def color_error_message(message: str) -> str:
+        return colored(message, Formatter.ERROR_COLOR, attrs=["bold"])
+
+    @staticmethod
+    def color_success_message(message: str) -> str:
+        return colored(message, Formatter.SUCCESS_COLOR, attrs=["bold"])
+        print(Formatter.color_success_message(message))
+
+    @staticmethod
+    def color_info_message(message: str):
+        return colored(message, Formatter.INFO_COLOR, attrs=["bold"])
+        print(Formatter.color_info_message(message))
+
+    @staticmethod
+    def color_assert_failed(message: str) -> str:
+        return colored(message, "light_" + Formatter.ERROR_COLOR)
+
+    @staticmethod
+    def color_assert_info(message: str) -> str:
+        return colored(message, "light_" + Formatter.INFO_COLOR)
+
+    @staticmethod
+    def color_assert_success(message: str) -> str:
+        return colored(message, "light_" + Formatter.SUCCESS_COLOR)

scwidgets-0.1.0.dev0/src/scwidgets/check/__init__.py

@@ -0,0 +1,24 @@
+from ._asserts import (
+    assert_equal,
+    assert_numpy_allclose,
+    assert_numpy_floating_sub_dtype,
+    assert_numpy_sub_dtype,
+    assert_shape,
+    assert_type,
+)
+from ._check import AssertResult, Check, CheckResult
+from ._widget_check_registry import CheckableWidget, CheckRegistry
+
+__all__ = [
+    "Check",
+    "CheckResult",
+    "AssertResult",
+    "CheckRegistry",
+    "CheckableWidget",
+    "assert_equal",
+    "assert_shape",
+    "assert_numpy_allclose",
+    "assert_type",
+    "assert_numpy_floating_sub_dtype",
+    "assert_numpy_sub_dtype",
+]

scwidgets-0.1.0.dev0/src/scwidgets/check/_asserts.py

@@ -0,0 +1,294 @@
+import functools
+from collections import abc
+from typing import Iterable, Union
+
+import numpy as np
+
+from ._check import AssertResult, Check
+
+AssertFunctionOutputT = Union[str, AssertResult]
+
+
+def assert_equal(
+    output_parameters: Check.FunOutParamsT,
+    output_references: Check.FunOutParamsT,
+    parameters_to_check: Union[Iterable[int], str] = "all",
+) -> AssertResult:
+    assert len(output_parameters) == len(
+        output_references
+    ), "output_parameters and output_references have to have the same length"
+
+    parameter_indices: Iterable[int]
+    if isinstance(parameters_to_check, str):
+        if parameters_to_check == "all":
+            parameter_indices = range(len(output_parameters))
+        else:
+            raise ValueError(
+                f'Got parameters_to_check="{parameters_to_check}" but only "all" '
+                "is accepted as string"
+            )
+    elif isinstance(parameters_to_check, abc.Iterable):
+        parameter_indices = parameters_to_check  # type: ignore[assignment]
+    else:
+        raise TypeError(
+            "Only str and Iterable are accepted for parameters_to_check, "
+            f"but got type {type(parameters_to_check)}."
+        )
+
+    failed_parameter_indices = []
+    failed_parameter_values = []
+    messages = []
+    for i in parameter_indices:
+        if not output_parameters[i] == output_references[i]:
+            message = (
+                f"Expected {output_references[i]} " f"but got {output_parameters[i]}."
+            )
+            failed_parameter_indices.append(i)
+            failed_parameter_values.append(output_parameters[i])
+            messages.append(message)
+    return AssertResult(
+        assert_name="assert_equal",
+        parameter_indices=failed_parameter_indices,
+        parameter_values=failed_parameter_values,
+        messages=messages,
+    )
+
+
+def assert_shape(
+    output_parameters: Check.FunOutParamsT,
+    output_references: Check.FunOutParamsT,
+    parameters_to_check: Union[Iterable[int], str] = "auto",
+) -> AssertResult:
+    assert len(output_parameters) == len(
+        output_references
+    ), "output_parameters and output_references have to have the same length"
+
+    parameter_indices: Iterable[int]
+    if isinstance(parameters_to_check, str):
+        if parameters_to_check == "auto":
+            parameter_indices = []
+            for i in range(len(output_references)):
+                if hasattr(output_references[i], "shape"):
+                    parameter_indices.append(i)
+        elif parameters_to_check == "all":
+            parameter_indices = range(len(output_parameters))
+        else:
+            raise ValueError(
+                f'Got parameters_to_check="{parameters_to_check}" but only "all" '
+                ' and "auto" are accepted as string'
+            )
+    elif isinstance(parameters_to_check, abc.Iterable):
+        parameter_indices = parameters_to_check  # type: ignore[assignment]
+    else:
+        raise TypeError(
+            "Only str and Iterable are accepted for parameters_to_check, "
+            f"but got type {type(parameters_to_check)}."
+        )
+
+    failed_parameter_indices = []
+    failed_parameter_values = []
+    messages = []
+    for i in parameter_indices:
+        if output_parameters[i].shape != output_references[i].shape:
+            message = (
+                f"Expected shape {output_references[i].shape} "
+                f"but got {output_parameters[i].shape}."
+            )
+            failed_parameter_indices.append(i)
+            failed_parameter_values.append(output_parameters[i])
+            messages.append(message)
+
+    return AssertResult(
+        assert_name="assert_shape",
+        parameter_indices=failed_parameter_indices,
+        parameter_values=failed_parameter_values,
+        messages=messages,
+    )
+
+
+def assert_numpy_allclose(
+    output_parameters: Check.FunOutParamsT,
+    output_references: Check.FunOutParamsT,
+    parameters_to_check: Union[Iterable[int], str] = "auto",
+    rtol=1e-05,
+    atol=1e-08,
+    equal_nan=False,
+) -> AssertResult:
+    assert len(output_parameters) == len(
+        output_references
+    ), "output_parameters and output_references have to have the same length"
+
+    parameter_indices: Iterable[int]
+    if isinstance(parameters_to_check, str):
+        if parameters_to_check == "auto":
+            parameter_indices = []
+            for i in range(len(output_references)):
+                try:
+                    np.allclose(output_references[i], output_references[i])
+                    parameter_indices.append(i)
+                except Exception:
+                    pass
+        elif parameters_to_check == "all":
+            parameter_indices = range(len(output_parameters))
+        else:
+            raise ValueError(
+                f'Got parameters_to_check="{parameters_to_check}" but only "all" '
+                ' and "auto" are accepted as string'
+            )
+    elif isinstance(parameters_to_check, abc.Iterable):
+        parameter_indices = parameters_to_check  # type: ignore[assignment]
+    else:
+        raise TypeError(
+            "Only str and Iterable are accepted for parameters_to_check, "
+            f"but got type {type(parameters_to_check)}."
+        )
+
+    failed_parameter_indices = []
+    failed_parameter_values = []
+    messages = []
+    for i in parameter_indices:
+        is_allclose = np.allclose(
+            output_parameters[i],
+            output_references[i],
+            atol=atol,
+            rtol=rtol,
+            equal_nan=equal_nan,
+        )
+
+        if not (is_allclose):
+            output_parameters_i_arr = np.asarray(output_parameters[i])
+            output_references_i_arr = np.asarray(output_references[i])
+
+            diff = np.abs(output_parameters_i_arr - output_references_i_arr)
+            abs_diff = np.sum(diff)
+            rel_diff_dividend = np.max(
+                np.vstack(
+                    (
+                        np.abs(output_parameters_i_arr),
+                        np.abs(output_references_i_arr),
+                    )
+                ),
+                axis=0,
+            )
+            # when both are zero the diff is also zero, so we set it to 1
+            # so no division by zero error is raised
+            rel_diff_dividend[rel_diff_dividend == 0.0] = 1.0
+            rel_diff = np.sum(diff / rel_diff_dividend)
+
+            message = (
+                f"Output is not close to reference absolute difference "
+                f"is {abs_diff}, relative difference is {rel_diff}."
+            )
+            failed_parameter_indices.append(i)
+            failed_parameter_values.append(output_parameters[i])
+            messages.append(message)
+
+    return AssertResult(
+        assert_name="assert_numpy_allclose",
+        parameter_indices=failed_parameter_indices,
+        parameter_values=failed_parameter_values,
+        messages=messages,
+    )
+
+
+def assert_type(
+    output_parameters: Check.FunOutParamsT,
+    output_references: Check.FunOutParamsT,
+    parameters_to_check: Union[Iterable[int], str] = "all",
+) -> AssertResult:
+    assert len(output_parameters) == len(
+        output_references
+    ), "output_parameters and output_references have to have the same length"
+
+    parameter_indices: Iterable[int]
+    if isinstance(parameters_to_check, str):
+        if parameters_to_check == "all":
+            parameter_indices = range(len(output_parameters))
+        else:
+            raise ValueError(
+                f'Got parameters_to_check="{parameters_to_check}" but only "all" '
+                "is accepted as string"
+            )
+    elif isinstance(parameters_to_check, abc.Iterable):
+        parameter_indices = parameters_to_check  # type: ignore[assignment]
+    else:
+        raise TypeError(
+            "Only str and Iterable are accepted for parameters_to_check, "
+            f"but got type {type(parameters_to_check)}."
+        )
+
+    failed_parameter_indices = []
+    failed_parameter_values = []
+    messages = []
+    for i in parameter_indices:
+        if not (isinstance(output_parameters[i], type(output_references[i]))):
+            message = (
+                f"Expected type {type(output_references[i])} "
+                f"but got {type(output_parameters[i])}."
+            )
+            failed_parameter_indices.append(i)
+            failed_parameter_values.append(output_parameters[i])
+            messages.append(message)
+    return AssertResult(
+        assert_name="assert_type",
+        parameter_indices=failed_parameter_indices,
+        parameter_values=failed_parameter_values,
+        messages=messages,
+    )
+
+
+def assert_numpy_sub_dtype(
+    output_parameters: Union[Check.FunOutParamsT, tuple[Check.FingerprintT]],
+    numpy_type: Union[np.dtype, type],
+    parameters_to_check: Union[Iterable[int], str] = "all",
+) -> AssertResult:
+    if parameters_to_check == "all":
+        parameter_indices = range(len(output_parameters))
+    elif isinstance(parameters_to_check, abc.Iterable):
+        parameter_indices = parameters_to_check  # type: ignore[assignment]
+    else:
+        raise TypeError(
+            "Only str and Iterable are accepted for parameters_to_check, "
+            f"but got type {type(parameters_to_check)}."
+        )
+
+    failed_parameter_indices = []
+    failed_parameter_values = []
+    messages = []
+    for i in parameter_indices:
+        if not (isinstance(output_parameters[i], np.ndarray)):
+            failed_parameter_indices.append(i)
+            failed_parameter_values.append(output_parameters[i])
+            message = (
+                f"Output expected to be numpy array "
+                f"but got {type(output_parameters[i])}."
+            )
+            messages.append(message)
+        if not (np.issubdtype(output_parameters[i].dtype, numpy_type)):
+            if isinstance(numpy_type, np.dtype):
+                type_name = numpy_type.type.__name__
+            else:
+                type_name = numpy_type.__name__
+            failed_parameter_indices.append(i)
+            failed_parameter_values.append(output_parameters[i])
+            message = (
+                f"Output expected to be sub dtype "
+                f"numpy.{type_name} but got "
+                f"numpy.{output_parameters[i].dtype.type.__name__}."
+            )
+            messages.append(message)
+    if isinstance(numpy_type, np.dtype):
+        type_name = numpy_type.type.__name__
+    else:
+        type_name = numpy_type.__name__
+    return AssertResult(
+        assert_name=f"assert_numpy_{type_name}_sub_dtype",
+        parameter_indices=failed_parameter_indices,
+        parameter_values=failed_parameter_values,
+        messages=messages,
+    )
+
+
+assert_numpy_floating_sub_dtype = functools.partial(
+    assert_numpy_sub_dtype, numpy_type=np.floating
+)