scwidgets 0.1.0.dev0__tar.gz → 0.1.0.dev1__tar.gz

{scwidgets-0.1.0.dev0 → scwidgets-0.1.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scwidgets
-Version: 0.1.0.dev0
+Version: 0.1.0.dev1
 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
@@ -24,22 +24,38 @@ 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.
+*scicode-widgets* is a widget library for the purpose of creating computational
+experiments for educational content. It is targeted to teach students how to
+code and interpret computational experiments while hiding technical details and
+boiler plate code that are not essential for the learning experience. The logic
+is purely written in Python to simplify the development process for scientific
+researchers as they usually are more capable in writing Python code than
+JavaScript. It therefore builds on top of widgets provided by ipywidgets to
+creating a framework out of it.
+
+Features
+--------
+
+The core features of scicode-widgets are:
+
+**Customizable coding exercises and demos**
+
+**Checks for students to verify their solution**
+
+**Automatic grading using nbgrader**
+
+Please continue with our `getting started page <https://scicode-widgets.readthedocs.io/en/latest/getting_started.html>`_  
+for a more detailed overview of our features.
 
-Installation
-------------
+Supportde jupyter environments
+------------------------------
 
-.. code-block:: bash
+We support the following widget environments
 
-  pip install .
+* jupyterlab
+* notebook < 7

scwidgets-0.1.0.dev1/README.rst

@@ -0,0 +1,35 @@
+scicode-widgets
+===============
+
+.. marker-package-description
+
+*scicode-widgets* is a widget library for the purpose of creating computational
+experiments for educational content. It is targeted to teach students how to
+code and interpret computational experiments while hiding technical details and
+boiler plate code that are not essential for the learning experience. The logic
+is purely written in Python to simplify the development process for scientific
+researchers as they usually are more capable in writing Python code than
+JavaScript. It therefore builds on top of widgets provided by ipywidgets to
+creating a framework out of it.
+
+Features
+--------
+
+The core features of scicode-widgets are:
+
+**Customizable coding exercises and demos**
+
+**Checks for students to verify their solution**
+
+**Automatic grading using nbgrader**
+
+Please continue with our `getting started page <https://scicode-widgets.readthedocs.io/en/latest/getting_started.html>`_  
+for a more detailed overview of our features.
+
+Supportde jupyter environments
+------------------------------
+
+We support the following widget environments
+
+* jupyterlab
+* notebook < 7

{scwidgets-0.1.0.dev0 → scwidgets-0.1.0.dev1}/src/scwidgets/__init__.py

@@ -1,38 +1,21 @@
-__version__ = "0.1.0-dev0"
+__version__ = "0.1.0-dev1"
 __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",
+    "ParametersPanel",
     # check
-    "Check",
-    "CheckResult",
-    "AssertResult",
     "CheckRegistry",
-    "CheckableWidget",
     "assert_equal",
     "assert_shape",
     "assert_numpy_allclose",
@@ -42,6 +25,5 @@ __all__ = [  # noqa: F405
     # exercise
     "CodeExercise",
     "TextExercise",
-    "ExerciseWidget",
     "ExerciseRegistry",
 ]

{scwidgets-0.1.0.dev0 → scwidgets-0.1.0.dev1}/src/scwidgets/check/_widget_check_registry.py

@@ -7,8 +7,8 @@ from typing import Callable, List, Optional, Union
 
 from ipywidgets import Button, HBox, Layout, Output, VBox, Widget
 
-from .._css_style import CssStyle
 from .._utils import Formatter
+from ..css_style import CssStyle
 from ._check import Check, CheckResult
 
 
@@ -147,11 +147,19 @@ class CheckRegistry(VBox):
         self._check_all_widgets_button = Button(description="Check all widgets")
         self._output = Output()
         kwargs["layout"] = kwargs.pop("layout", Layout(width="100%"))
+
+        self._buttons_hbox = HBox()
+
+        # needs to be after the _buttons_hbox already was created
+        self.display_set_all_references_button = kwargs.pop(
+            "display_set_all_references_button", False
+        )
+
         VBox.__init__(
             self,
             [
                 CssStyle(),
-                HBox([self._set_all_references_button, self._check_all_widgets_button]),
+                self._buttons_hbox,
                 self._output,
             ],
             *args,
@@ -170,6 +178,22 @@ class CheckRegistry(VBox):
         """
         return self._checks
 
+    @property
+    def display_set_all_references_button(self) -> bool:
+        return self._display_set_all_references_button
+
+    @display_set_all_references_button.setter
+    def display_set_all_references_button(self, value: bool):
+        if value:
+            self._display_set_all_references_button = True
+            self._buttons_hbox.children = (
+                self._check_all_widgets_button,
+                self._set_all_references_button,
+            )
+        else:
+            self._display_set_all_references_button = False
+            self._buttons_hbox.children = (self._check_all_widgets_button,)
+
     @property
     def registered_widgets(self):
         return self._widgets.copy()

scwidgets-0.1.0.dev1/src/scwidgets/code/__init__.py

@@ -0,0 +1,7 @@
+from ._widget_code_input import CodeInput
+from ._widget_parameters_panel import ParametersPanel
+
+__all__ = [
+    "CodeInput",
+    "ParametersPanel",
+]

{scwidgets-0.1.0.dev0 → scwidgets-0.1.0.dev1}/src/scwidgets/code/_widget_code_input.py

@@ -1,11 +1,14 @@
+import ast
+import copy
 import inspect
 import re
 import sys
+import textwrap
 import traceback
 import types
 import warnings
 from functools import wraps
-from typing import List, Optional
+from typing import Any, List, Optional, Tuple
 
 from widget_code_input import WidgetCodeInput
 from widget_code_input.utils import (
@@ -20,6 +23,20 @@ from ..check import Check
 class CodeInput(WidgetCodeInput):
     """
     Small wrapper around WidgetCodeInput that controls the output
+
+    :param function: We can automatically parse the function. Note that during
+        parsing the source code might be differently formatted and certain
+        python functionalities are not formatted. If you notice undesired
+        changes by the parsing, please directly specify the function as string
+        using the other parameters.
+    :param function_name: The name of the function
+    :param function_paramaters: The parameters as continuous string as specified in
+        the signature of the function. e.g  for `foo(x, y = 5)` it should be
+        `"x, y = 5"`
+    :param docstring: The docstring of the function
+    :param function_body: The function definition without indentation
+    :param builtins: A dict of variable name and value that is added to the
+      globals __builtins__ and thus available on initialization
     """
 
     valid_code_themes = ["nord", "solarizedLight", "basicLight"]
@@ -31,6 +48,7 @@ class CodeInput(WidgetCodeInput):
         function_parameters: Optional[str] = None,
         docstring: Optional[str] = None,
         function_body: Optional[str] = None,
+        builtins: Optional[dict[str, Any]] = None,
         code_theme: str = "basicLight",
     ):
         if function is not None:
@@ -38,13 +56,15 @@ class CodeInput(WidgetCodeInput):
                 function.__name__ if function_name is None else function_name
             )
             function_parameters = (
-                ", ".join(inspect.getfullargspec(function).args)
+                self.get_function_parameters(function)
                 if function_parameters is None
                 else function_parameters
             )
-            docstring = inspect.getdoc(function) if docstring is None else docstring
+            docstring = self.get_docstring(function) if docstring is None else docstring
             function_body = (
-                self.get_code(function) if function_body is None else function_body
+                self.get_function_body(function)
+                if function_body is None
+                else function_body
             )
 
         # default parameters from WidgetCodeInput
@@ -53,6 +73,7 @@ class CodeInput(WidgetCodeInput):
         function_parameters = "" if function_parameters is None else function_parameters
         docstring = "\n" if docstring is None else docstring
         function_body = "" if function_body is None else function_body
+        self._builtins = {} if builtins is None else builtins
         super().__init__(
             function_name, function_parameters, docstring, function_body, code_theme
         )
@@ -66,7 +87,7 @@ class CodeInput(WidgetCodeInput):
             )
 
     @property
-    def function(self) -> types.FunctionType:
+    def unwrapped_function(self) -> types.FunctionType:
         """
         Return the compiled function object.
 
@@ -78,11 +99,37 @@ class CodeInput(WidgetCodeInput):
         :raise SyntaxError: if the function code has syntax errors (or if
           the function name is not a valid identifier)
         """
-        return inspect.unwrap(self.wrapped_function)
+        # we shallow copy the builtins to be able to overwrite it
+        # if self.builtins changes
+        globals_dict = {
+            "__builtins__": copy.copy(globals()["__builtins__"]),
+            "__name__": "__main__",
+            "__doc__": None,
+            "__package__": None,
+        }
+
+        globals_dict["__builtins__"].update(self._builtins)
+
+        if not is_valid_variable_name(self.function_name):
+            raise SyntaxError("Invalid function name '{}'".format(self.function_name))
+
+        # Optionally one could do a ast.parse here already, to check syntax
+        # before execution
+        try:
+            exec(
+                compile(self.full_function_code, __name__, "exec", dont_inherit=True),
+                globals_dict,
+            )
+        except SyntaxError as exc:
+            raise CodeValidationError(
+                format_syntax_error_msg(exc), orig_exc=exc
+            ) from exc
+
+        return globals_dict[self.function_name]
 
     def __call__(self, *args, **kwargs) -> Check.FunOutParamsT:
         """Calls the wrapped function"""
-        return self.wrapped_function(*args, **kwargs)
+        return self.function(*args, **kwargs)
 
     def compatible_with_signature(self, parameters: List[str]) -> str:
         """
@@ -105,8 +152,68 @@ class CodeInput(WidgetCodeInput):
         return self.function_parameters.replace(",", "").split(" ")
 
     @staticmethod
-    def get_code(func: types.FunctionType) -> str:
-        source_lines, _ = inspect.getsourcelines(func)
+    def get_docstring(function: types.FunctionType) -> str:
+        docstring = function.__doc__
+        return "" if docstring is None else textwrap.dedent(docstring)
+
+    @staticmethod
+    def _get_function_source_and_def(
+        function: types.FunctionType,
+    ) -> Tuple[str, ast.FunctionDef]:
+        function_source = inspect.getsource(function)
+        function_source = textwrap.dedent(function_source)
+        module = ast.parse(function_source)
+        if len(module.body) != 1:
+            raise ValueError(
+                f"Expected code with one function definition but found {module.body}"
+            )
+        function_definition = module.body[0]
+        if not isinstance(function_definition, ast.FunctionDef):
+            raise ValueError(
+                f"While parsing code found {module.body[0]}"
+                " but only ast.FunctionDef is supported."
+            )
+        return function_source, function_definition
+
+    @staticmethod
+    def get_function_parameters(function: types.FunctionType) -> str:
+        function_parameters = []
+        function_source, function_definition = CodeInput._get_function_source_and_def(
+            function
+        )
+        idx_start_defaults = len(function_definition.args.args) - len(
+            function_definition.args.defaults
+        )
+        for i, arg in enumerate(function_definition.args.args):
+            function_parameter = ast.get_source_segment(function_source, arg)
+            # Following PEP 8 in formatting
+            if arg.annotation:
+                annotation = function_parameter = ast.get_source_segment(
+                    function_source, arg.annotation
+                )
+                function_parameter = f"{arg.arg}: {annotation}"
+            else:
+                function_parameter = f"{arg.arg}"
+            if i >= idx_start_defaults:
+                default_val = ast.get_source_segment(
+                    function_source,
+                    function_definition.args.defaults[i - idx_start_defaults],
+                )
+                # Following PEP 8 in formatting
+                if arg.annotation:
+                    function_parameter = f"{function_parameter} = {default_val}"
+                else:
+                    function_parameter = f"{function_parameter}={default_val}"
+            function_parameters.append(function_parameter)
+
+        if function_definition.args.kwarg is not None:
+            function_parameters.append(f"**{function_definition.args.kwarg.arg}")
+
+        return ", ".join(function_parameters)
+
+    @staticmethod
+    def get_function_body(function: types.FunctionType) -> str:
+        source_lines, _ = inspect.getsourcelines(function)
 
         found_def = False
         def_index = 0
@@ -144,10 +251,10 @@ class CodeInput(WidgetCodeInput):
                 line[leading_indent:] if line.strip() else "" for line in lines
             )
 
-        return source
+        return source.strip()
 
     @property
-    def wrapped_function(self) -> types.FunctionType:
+    def function(self) -> types.FunctionType:
         """
         Return the compiled function object wrapped by an try-catch block
         raising a `CodeValidationError`.
@@ -160,29 +267,6 @@ class CodeInput(WidgetCodeInput):
         :raise SyntaxError: if the function code has syntax errors (or if
           the function name is not a valid identifier)
         """
-        globals_dict = {
-            "__builtins__": globals()["__builtins__"],
-            "__name__": "__main__",
-            "__doc__": None,
-            "__package__": None,
-        }
-
-        if not is_valid_variable_name(self.function_name):
-            raise SyntaxError("Invalid function name '{}'".format(self.function_name))
-
-        # Optionally one could do a ast.parse here already, to check syntax
-        # before execution
-        try:
-            exec(
-                compile(self.full_function_code, __name__, "exec", dont_inherit=True),
-                globals_dict,
-            )
-        except SyntaxError as exc:
-            raise CodeValidationError(
-                format_syntax_error_msg(exc), orig_exc=exc
-            ) from exc
-
-        function_object = globals_dict[self.function_name]
 
         def catch_exceptions(func):
             @wraps(func)
@@ -198,7 +282,15 @@ class CodeInput(WidgetCodeInput):
 
             return wrapper
 
-        return catch_exceptions(function_object)
+        return catch_exceptions(self.unwrapped_function)
+
+    @property
+    def builtins(self) -> dict[str, Any]:
+        return self._builtins
+
+    @builtins.setter
+    def builtins(self, value: dict[str, Any]):
+        self._builtins = value
 
 
 # Temporary fix until https://github.com/osscar-org/widget-code-input/pull/26

scwidgets-0.1.0.dev0/src/scwidgets/code/_widget_parameter_panel.py → scwidgets-0.1.0.dev1/src/scwidgets/code/_widget_parameters_panel.py

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, List, Union
+from typing import Any, Callable, Dict, List, Union
 
 from ipywidgets import Output, VBox, Widget, fixed, interactive
 from traitlets.utils.sentinel import Sentinel
@@ -6,7 +6,7 @@ from traitlets.utils.sentinel import Sentinel
 from ..check import Check
 
 
-class ParameterPanel(VBox):
+class ParametersPanel(VBox):
     """
     A wrapper around ipywidgets.interactive to have more control how to connect the
     parameters and the observation of parameters by buttons and the panels
@@ -25,7 +25,7 @@ class ParameterPanel(VBox):
         if "_option" in parameters.keys():
             raise ValueError(
                 "Found interactive argument `_option` in paramaters, but "
-                "ParameterPanels should be controled by an exercise widget "
+                "ParametersPanels should be controled by an exercise widget "
                 "to ensure correct initialization."
             )
 
@@ -39,42 +39,61 @@ class ParameterPanel(VBox):
             "Assumed that interactive returns an output as last child. "
             "Parameter will be wrongly initialized if this is not True."
         )
-        self._parameters_widget = list(self._interactive_widget.children[:-1])
-        super().__init__(self._parameters_widget)
+        # Because interact only keeps a list of the widgets we build a map
+        # so the params can be changed in arbitrary order.
+        # Last widget is an output that interact adds to the widgets.
+        self._param_to_widget_map = {
+            key: widget
+            for key, widget in zip(
+                parameters.keys(), self._interactive_widget.kwargs_widgets
+            )
+        }
+        super().__init__(self.panel_parameters_widget)
 
     @property
-    def parameters_widget(self) -> List[Widget]:
-        return self._parameters_widget
+    def param_to_widget_map(self) -> dict[str, Widget]:
+        return self._param_to_widget_map
 
     @property
-    def parameters_trait(self) -> List[str]:
-        return ["value"] * len(self._parameters_widget)
+    def panel_parameters_trait(self) -> List[str]:
+        return ["value"] * len(self.panel_parameters)
+
+    @property
+    def panel_parameters_widget(self) -> List[Widget]:
+        """
+        :return: Only parameters that are tunable in the parameter panel are returned.
+            Fixed parameters are ignored.
+        """
+        return [
+            widget
+            for widget in self._param_to_widget_map.values()
+            if not (isinstance(widget, fixed))
+        ]
 
     @property
-    def params(self) -> dict:
+    def parameters(self) -> Dict[str, Any]:
         """
         :return: All parameters that were given on initialization are returned,
             also including also fixed parameters.
         """
-        return self._interactive_widget.kwargs.copy()
-
-    @params.setter
-    def params(self, parameters: dict):
-        for i, key in enumerate(self._interactive_widget.kwargs.keys()):
-            self._interactive_widget.kwargs_widgets[i].value = parameters[key]
+        return {key: widget.value for key, widget in self._param_to_widget_map.items()}
 
     @property
-    def panel_parameters(self) -> dict:
+    def panel_parameters(self) -> Dict[str, Any]:
         """
         :return: Only parameters that are tunable in the parameter panel are returned.
             Fixed parameters are ignored.
         """
         return {
-            key: self._interactive_widget.kwargs_widgets[i].value
-            for i, key in enumerate(self._interactive_widget.kwargs.keys())
-            if not (isinstance(self._interactive_widget.kwargs_widgets[i], fixed))
+            key: widget.value
+            for key, widget in self._param_to_widget_map.items()
+            if not (isinstance(widget, fixed))
         }
 
+    def update_parameters(self, new_parameters: Dict[str, Any]):
+        for key, value in new_parameters.items():
+            self.param_to_widget_map[key].value = value
+
     def observe_parameters(
         self,
         handler: Callable[[dict], None],
@@ -82,7 +101,7 @@ class ParameterPanel(VBox):
         notification_type: Union[None, str, Sentinel] = "change",
     ):
         """ """
-        for widget in self._parameters_widget:
+        for widget in self.panel_parameters_widget:
             widget.observe(handler, trait_name, notification_type)
 
     def unobserve_parameters(
@@ -91,10 +110,10 @@ class ParameterPanel(VBox):
         trait_name: Union[str, Sentinel, List[str]],
         notification_type: Union[None, str, Sentinel] = "change",
     ):
-        for widget in self._parameters_widget:
+        for widget in self.panel_parameters_widget:
             widget.unobserve(handler, trait_name, notification_type)
 
     def set_parameters_widget_attr(self, name: str, value):
-        for widget in self._parameters_widget:
+        for widget in self.panel_parameters_widget:
             if hasattr(widget, name):
                 setattr(widget, name, value)

{scwidgets-0.1.0.dev0 → scwidgets-0.1.0.dev1}/src/scwidgets/cue/_widget_cue.py

@@ -56,7 +56,7 @@ class CueWidget:
                             "traits_to_observe cannot contain lists when "
                             "widgets_to_observe is not a list."
                         )
-            traits_to_observe = [traits_to_observe]
+            traits_to_observe = [traits_to_observe]  # type: ignore[list-item]
         else:
             if not (isinstance(traits_to_observe, list)):
                 raise ValueError(

{scwidgets-0.1.0.dev0 → scwidgets-0.1.0.dev1}/src/scwidgets/cue/_widget_cue_box.py

@@ -37,7 +37,9 @@ class CueBox(VBox, CueWidget):
     def __init__(
         self,
         widgets_to_observe: Union[List[Widget], Widget],
-        traits_to_observe: Union[str, List[str], List[List[str]], Sentinel] = "value",
+        traits_to_observe: Union[
+            str, Sentinel, List[Union[str, Sentinel, List[str]]]
+        ] = "value",
         widget_to_cue: Optional[Widget] = None,
         cued: bool = True,
         css_style: Optional[dict] = None,
@@ -112,7 +114,9 @@ class SaveCueBox(CueBox):
     def __init__(
         self,
         widgets_to_observe: Widget,
-        traits_to_observe: Union[str, List[str], Sentinel] = "value",
+        traits_to_observe: Union[
+            str, Sentinel, List[Union[str, Sentinel, List[str]]]
+        ] = "value",
         widget_to_cue: Optional[Widget] = None,
         cued: bool = True,
         *args,
@@ -151,7 +155,9 @@ class CheckCueBox(CueBox):
     def __init__(
         self,
         widgets_to_observe: Widget,
-        traits_to_observe: Union[str, List[str], Sentinel] = "value",
+        traits_to_observe: Union[
+            str, Sentinel, List[Union[str, Sentinel, List[str]]]
+        ] = "value",
         widget_to_cue: Optional[Widget] = None,
         cued: bool = True,
         *args,
@@ -190,7 +196,9 @@ class UpdateCueBox(CueBox):
     def __init__(
         self,
         widgets_to_observe: Widget,
-        traits_to_observe: Union[str, List[str], Sentinel] = "value",
+        traits_to_observe: Union[
+            str, Sentinel, List[Union[str, Sentinel, List[str]]]
+        ] = "value",
         widget_to_cue: Optional[Widget] = None,
         cued: bool = True,
         *args,

{scwidgets-0.1.0.dev0 → scwidgets-0.1.0.dev1}/src/scwidgets/cue/_widget_cue_figure.py

@@ -32,8 +32,8 @@ class CueFigure(CueOutput):
         Specify `traitlets.All` to observe all traits.
     :param cued:
         Specifies if it is cued on initialization
-    :param no_toolbars:
-        Hide toolbars and headers when using widget mode
+    :param show_toolbars:
+        Hide toolbars and headers when using in widget mode.
     :param css_syle:
         - **base**: the css style of the box during initialization
         - **cue**: the css style that is added when :param
@@ -47,10 +47,10 @@ class CueFigure(CueOutput):
         figure: Figure,
         widgets_to_observe: Union[None, List[Widget], Widget] = None,
         traits_to_observe: Union[
-            None, str, List[str], List[List[str]], Sentinel
+            None, str, Sentinel, List[Union[str, Sentinel, List[str]]]
         ] = None,
         cued: bool = True,
-        no_toolbars: bool = True,
+        show_toolbars: bool = False,
         css_style: Optional[dict] = None,
         **kwargs,
     ):
@@ -87,7 +87,7 @@ class CueFigure(CueOutput):
                 "that should be supported on all systems."
             )
 
-        if no_toolbars:
+        if show_toolbars:
             # hides unnecessary elements shown with %matplotlib widget
             self.figure.canvas.header_visible = False
             self.figure.canvas.footer_visible = False