add to_viewer back

panel/ipywidget.py

@@ -8,7 +8,8 @@
 from param import Parameterized
 from param.reactive import bind
 
-from .viewable import Viewer
+from .pane import IPyWidget
+from .viewable import Layoutable, Viewer
 
 if TYPE_CHECKING:
     try:
@@ -23,16 +24,19 @@ class HasTraits:  # type: ignore
     class HasTraits:  # type: ignore
         """Mock class"""
 
+
 def _is_custom_trait(name):
     if name.startswith("_"):
         return False
-    if name in {'comm', 'tabbable', 'keys', 'log', 'layout'}:
+    if name in {"comm", "tabbable", "keys", "log", "layout"}:
         return False
     return True
 
+
 def _get_parameter_names(widget):
     return [name for name in widget.traits() if _is_custom_trait(name)]
 
+
 class IpyWidgetParameterized(Parameterized):
     _widget = param.Parameter(allow_None=False)
     _parameters = param.List(allow_None=False)
@@ -52,22 +56,27 @@ def __init__(self, **params):
                 setattr(self, parameter, getattr(widget, parameter))
 
                 # Observe widget parameters
-                def _handle_widget_change(change, widget=widget, parameter=parameter):
+                def _handle_widget_change(_, widget=widget, parameter=parameter):
                     setattr(self, parameter, getattr(widget, parameter))
 
                 widget.observe(_handle_widget_change, names=parameter)
 
                 # Bind to self parameters
-                def _handle_observer_change(value, widget=widget, parameter=parameter):
+                def _handle_observer_change(_, widget=widget, parameter=parameter):
                     setattr(widget, parameter, getattr(self, parameter))
 
-                bind(_handle_observer_change, value=self.param[parameter], watch=True)
+                bind(_handle_observer_change, self.param[parameter], watch=True)
+
 
 _ipywidget_classes = {}
 
+
 def to_parameterized(
-    widget: HasTraits, parameters: Iterable | None = None, bases: Parameterized|None=None
-) -> Viewer:
+    widget: HasTraits,
+    parameters: Iterable | None = None,
+    bases: Parameterized | None = None,
+    **kwargs
+) -> Parameterized:
     """Returns a Parameterized object with parameters synced to the ipywidget widget parameters
 
     Args:
@@ -79,19 +88,57 @@ def to_parameterized(
     if not parameters:
         parameters = _get_parameter_names(widget)
     if bases:
-        bases = (bases, IpyWidgetParameterized,)
+        bases = (
+            bases,
+            IpyWidgetParameterized,
+        )
     else:
         bases = (IpyWidgetParameterized,)
     name = type(widget).__name__
     key = (name, tuple(parameters), bases)
     if name in _ipywidget_classes:
-        viewer = _ipywidget_classes[key]
+        parameterized = _ipywidget_classes[key]
     else:
         existing_params = set(IpyWidgetParameterized.param)
-        params = {name: param.Parameterized() for name in parameters if name not in existing_params}
-        viewer = param.parameterized_class(name, params=params, bases=bases)
-    _ipywidget_classes[key] = viewer
-    return viewer(_widget=widget, _parameters=parameters)
+        params = {
+            name: param.Parameterized()
+            for name in parameters
+            if name not in existing_params
+        }
+        parameterized = param.parameterized_class(name, params=params, bases=bases)
+    _ipywidget_classes[key] = parameterized
+    return parameterized(_widget=widget, _parameters=parameters, **kwargs)
+
+
+class IpyWidgetViewer(Layoutable, Viewer):
+
+    def __init__(self, **params):
+        super().__init__(**params)
+
+        widget = self._widget
+        layout_params = {name: self.param[name] for name in Layoutable.param}
+
+        self._layout = IPyWidget(widget, **layout_params)
+
+    def __panel__(self):
+        return self._layout
+
+
+def to_viewer(
+    widget: HasTraits,
+    parameters: Iterable | None = None,
+    bases: Parameterized | None = None,
+    **kwargs,
+) -> Viewer:
+    """Returns a Parameterized object with parameters synced to the ipywidget widget parameters
+
+    Args:
+        widget (HasTraits): The ipywidget to create the Viewer from.
+        parameters (Iterable | None): The parameters to add to the Parameterized and to sync.
+            If no parameters are specified all public parameters on the widget will be added
+            and synced.
+    """
+    return to_parameterized(widget, parameters=parameters, bases=IpyWidgetViewer, **kwargs)
 
 
 def sync_rx(element: HasTraits, name: str, target: param.rx):

panel/tests/test_ipywidget.py

@@ -10,14 +10,16 @@
 from ipywidgets import DOMWidget, register
 from traitlets import Float, Int, Unicode
 
-from panel.ipywidget import to_parameterized, to_rx
+from panel.ipywidget import to_parameterized, to_rx, to_viewer
+from panel.pane import IPyWidget
+from panel.viewable import Layoutable, Viewer
 
 
 @register
 class ExampleIpyWidget(DOMWidget):
-    _view_name = Unicode('ExampleIpyWidgetView').tag(sync=True)
-    _view_module = Unicode('example_ipywidget').tag(sync=True)
-    _view_module_version = Unicode('0.1.0').tag(sync=True)
+    _view_name = Unicode("ExampleIpyWidgetView").tag(sync=True)
+    _view_module = Unicode("example_ipywidget").tag(sync=True)
+    _view_module_version = Unicode("0.1.0").tag(sync=True)
 
     name = Unicode("Default Name").tag(description="A string trait")
     age = Int(0).tag(description="An integer trait")
@@ -58,6 +60,7 @@ def test_to_parameterized_is_synced(widget):
     assert viewer.age == widget.age
     assert viewer.weight == widget.weight
 
+
 def test_to_parameterized_parameter_list(widget):
     viewer = to_parameterized(widget, parameters=["name", "age"])
 
@@ -79,6 +82,7 @@ def test_to_parameterized_parameter_list(widget):
     assert viewer.name == widget.name
     assert viewer.age == widget.age
 
+
 def test_to_parameterized_bases(widget):
 
     class ExampleParameterized(param.Parameterized):
@@ -95,6 +99,24 @@ class ExampleParameterized(param.Parameterized):
     assert viewer.weight == widget.weight
 
 
+def test_to_viewer(widget):
+    viewer = to_viewer(widget)
+
+    assert isinstance(viewer, Layoutable)
+    assert isinstance(viewer, Viewer)
+
+    component = viewer.__panel__()
+    assert isinstance(component, IPyWidget)
+
+    viewer.sizing_mode = "stretch_width"
+    assert viewer.sizing_mode == component.sizing_mode
+
+
+def test_to_viewer_kwargs(widget):
+    viewer = to_viewer(widget, parameters=["name", "age"], sizing_mode="stretch_width")
+    assert viewer.__panel__().sizing_mode == "stretch_width"
+
+
 def test_to_rx(widget):
     age, weight, name = to_rx(widget, parameters=["age", "weight", "name"])
     assert isinstance(name, param.reactive.rx)