Speed up Pane.clone with 50%

panel/pane/base.py

@@ -31,6 +31,7 @@
 from ..reactive import Reactive
 from ..util import param_reprs, param_watchers
 from ..util.checks import is_dataframe, is_series
+from ..util.parameters import get_params_to_inherit
 from ..viewable import (
     Layoutable, ServableMixin, Viewable, Viewer,
 )
@@ -40,7 +41,6 @@
     from bokeh.model import Model
     from pyviz_comms import Comm
 
-
 def panel(obj: Any, **kwargs) -> Viewable:
     """
     Creates a displayable Panel object given any valid Python object.
@@ -382,11 +382,7 @@ def clone(self: T, object: Optional[Any] = None, **params) -> T:
         -------
         Cloned Pane object
         """
-        inherited = {
-            p: v for p, v in self.param.values().items()
-            if not self.param[p].readonly and v is not self.param[p].default
-            and not (v is None and not self.param[p].allow_None)
-        }
+        inherited = get_params_to_inherit(self)
         params = dict(inherited, **params)
         old_object = params.pop('object', None)
         if object is None:

panel/tests/pane/test_base.py

@@ -103,6 +103,13 @@ def test_pane_clone(pane):
     assert ([(k, v) for k, v in sorted(p.param.values().items()) if k not in ('name', '_pane')] ==
             [(k, v) for k, v in sorted(clone.param.values().items()) if k not in ('name', '_pane')])
 
+def test_pane_with_non_defaults_clone():
+    p = Markdown("Hello World", sizing_mode="stretch_width")
+    clone = p.clone()
+
+    assert ([(k, v) for k, v in sorted(p.param.values().items()) if k not in ('name', '_pane')] ==
+            [(k, v) for k, v in sorted(clone.param.values().items()) if k not in ('name', '_pane')])
+
 
 @pytest.mark.parametrize('pane', all_panes)
 def test_pane_signature(pane):

panel/tests/test_viewable.py

@@ -100,3 +100,18 @@ def __panel__(self):
             return 42
 
     panel(Example())
+
+@pytest.mark.parametrize('viewable', all_viewables)
+def test_clone(viewable):
+    v = Viewable()
+    clone = v.clone()
+
+    assert ([(k, v) for k, v in sorted(v.param.values().items()) if k not in ('name')] ==
+            [(k, v) for k, v in sorted(clone.param.values().items()) if k not in ('name')])
+
+def test_clone_with_non_defaults():
+    v= Viewable(loading=True)
+    clone = v.clone()
+
+    assert ([(k, v) for k, v in sorted(v.param.values().items()) if k not in ('name')] ==
+            [(k, v) for k, v in sorted(clone.param.values().items()) if k not in ('name')])

panel/util/__init__.py

@@ -6,7 +6,6 @@
 import ast
 import base64
 import datetime as dt
-import inspect
 import json
 import logging
 import numbers
@@ -18,12 +17,11 @@
 
 from collections import OrderedDict, defaultdict
 from collections.abc import MutableMapping, MutableSequence
-from contextlib import contextmanager
 from datetime import datetime
 from functools import partial
 from html import escape  # noqa
 from importlib import import_module
-from typing import Any, AnyStr, Iterator
+from typing import Any, AnyStr
 
 import bleach
 import bokeh
@@ -38,6 +36,10 @@
     datetime_types, is_dataframe, is_holoviews, is_number, is_parameterized,
     is_series, isdatetime, isfile, isIn, isurl,
 )
+from .parameters import (  # noqa
+    edit_readonly, extract_dependencies, get_method_owner, param_watchers,
+    recursive_parameterized,
+)
 
 log = logging.getLogger('panel.util')
 
@@ -85,17 +87,6 @@ def param_name(name: str) -> str:
     return name[:name.index(match[0])] if match else name
 
 
-def recursive_parameterized(parameterized: param.Parameterized, objects=None) -> list[param.Parameterized]:
-    """
-    Recursively searches a Parameterized object for other Parmeterized
-    objects.
-    """
-    objects = [] if objects is None else objects
-    objects.append(parameterized)
-    for p in parameterized.param.values().values():
-        if isinstance(p, param.Parameterized) and not any(p is o for o in objects):
-            recursive_parameterized(p, objects)
-    return objects
 
 
 def abbreviated_repr(value, max_length=25, natural_breaks=(',', ' ')):
@@ -174,42 +165,6 @@ def full_groupby(l, key=lambda x: x):
     return d.items()
 
 
-def get_method_owner(meth):
-    """
-    Returns the instance owning the supplied instancemethod or
-    the class owning the supplied classmethod.
-    """
-    if inspect.ismethod(meth):
-        return meth.__self__
-
-
-def extract_dependencies(function):
-    """
-    Extract references from a method or function that declares the references.
-    """
-    subparameters = list(function._dinfo['dependencies'])+list(function._dinfo['kw'].values())
-    params = []
-    for p in subparameters:
-        if isinstance(p, str):
-            owner = get_method_owner(function)
-            *subps, p = p.split('.')
-            for subp in subps:
-                owner = getattr(owner, subp, None)
-                if owner is None:
-                    raise ValueError('Cannot depend on undefined sub-parameter {p!r}.')
-            if p in owner.param:
-                pobj = owner.param[p]
-                if pobj not in params:
-                    params.append(pobj)
-            else:
-                for sp in extract_dependencies(getattr(owner, p)):
-                    if sp not in params:
-                        params.append(sp)
-        elif p not in params:
-            params.append(p)
-    return params
-
-
 def value_as_datetime(value):
     """
     Retrieve the value tuple as a tuple of datetime objects.
@@ -313,31 +268,6 @@ def url_path(url: str) -> str:
     return '/'.join('/'.join(subpaths).split('/')[1:])
 
 
-# This functionality should be contributed to param
-# See https://github.com/holoviz/param/issues/379
-@contextmanager
-def edit_readonly(parameterized: param.Parameterized) -> Iterator:
-    """
-    Temporarily set parameters on Parameterized object to readonly=False
-    to allow editing them.
-    """
-    params = parameterized.param.objects("existing").values()
-    readonlys = [p.readonly for p in params]
-    constants = [p.constant for p in params]
-    for p in params:
-        p.readonly = False
-        p.constant = False
-    try:
-        yield
-    except Exception:
-        raise
-    finally:
-        for (p, readonly) in zip(params, readonlys):
-            p.readonly = readonly
-        for (p, constant) in zip(params, constants):
-            p.constant = constant
-
-
 def lazy_load(module, model, notebook=False, root=None, ext=None):
     from ..config import panel_extension as extension
     from ..io.state import state
@@ -471,20 +401,6 @@ def relative_to(path, other_path):
     except Exception:
         return False
 
-_unset = object()
-
-def param_watchers(parameterized, value=_unset):
-    if Version(param.__version__) <= Version('2.0.0a2'):
-        if value is not _unset:
-            parameterized._param_watchers = value
-        else:
-            return parameterized._param_watchers
-    else:
-        if value is not _unset:
-            parameterized.param.watchers = value
-        else:
-            return parameterized.param.watchers
-
 
 def flatten(line):
     """

panel/util/parameters.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import inspect
+
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator
+
+import param
+
+from packaging.version import Version
+
+_unset = object()
+
+
+def should_inherit(parameterized: param.Parameterized, p: str, v: Any) -> Any:
+    pobj = parameterized.param[p]
+    return v is not pobj.default and not pobj.readonly and (v is not None or pobj.allow_None)
+
+
+def get_params_to_inherit(parameterized: param.Parameterized) -> Dict:
+    return {
+        p: v for p, v in parameterized.param.values().items()
+        if should_inherit(parameterized, p, v)
+    }
+
+
+def get_method_owner(meth):
+    """
+    Returns the instance owning the supplied instancemethod or
+    the class owning the supplied classmethod.
+    """
+    if inspect.ismethod(meth):
+        return meth.__self__
+
+
+# This functionality should be contributed to param
+# See https://github.com/holoviz/param/issues/379
+@contextmanager
+def edit_readonly(parameterized: param.Parameterized) -> Iterator:
+    """
+    Temporarily set parameters on Parameterized object to readonly=False
+    to allow editing them.
+    """
+    params = parameterized.param.objects("existing").values()
+    readonlys = [p.readonly for p in params]
+    constants = [p.constant for p in params]
+    for p in params:
+        p.readonly = False
+        p.constant = False
+    try:
+        yield
+    except Exception:
+        raise
+    finally:
+        for (p, readonly) in zip(params, readonlys):
+            p.readonly = readonly
+        for (p, constant) in zip(params, constants):
+            p.constant = constant
+
+
+def extract_dependencies(function):
+    """
+    Extract references from a method or function that declares the references.
+    """
+    subparameters = list(function._dinfo['dependencies'])+list(function._dinfo['kw'].values())
+    params = []
+    for p in subparameters:
+        if isinstance(p, str):
+            owner = get_method_owner(function)
+            *subps, p = p.split('.')
+            for subp in subps:
+                owner = getattr(owner, subp, None)
+                if owner is None:
+                    raise ValueError('Cannot depend on undefined sub-parameter {p!r}.')
+            if p in owner.param:
+                pobj = owner.param[p]
+                if pobj not in params:
+                    params.append(pobj)
+            else:
+                for sp in extract_dependencies(getattr(owner, p)):
+                    if sp not in params:
+                        params.append(sp)
+        elif p not in params:
+            params.append(p)
+    return params
+
+
+def param_watchers(parameterized: param.Parameterized, value=_unset):
+    if Version(param.__version__) <= Version('2.0.0a2'):
+        if value is not _unset:
+            parameterized._param_watchers = value
+        else:
+            return parameterized._param_watchers
+    else:
+        if value is not _unset:
+            parameterized.param.watchers = value
+        else:
+            return parameterized.param.watchers
+
+
+def recursive_parameterized(parameterized: param.Parameterized, objects=None) -> list[param.Parameterized]:
+    """
+    Recursively searches a Parameterized object for other Parmeterized
+    objects.
+    """
+    objects = [] if objects is None else objects
+    objects.append(parameterized)
+    for p in parameterized.param.values().values():
+        if isinstance(p, param.Parameterized) and not any(p is o for o in objects):
+            recursive_parameterized(p, objects)
+    return objects

panel/viewable.py

@@ -45,6 +45,7 @@
 from .io.save import save
 from .io.state import curdoc_locked, set_curdoc, state
 from .util import escape, param_reprs
+from .util.parameters import get_params_to_inherit
 from .util.warnings import deprecated
 
 if TYPE_CHECKING:
@@ -672,7 +673,6 @@ def get_root(
         state._views[ref] = (root_view, root, doc, comm)
         return root
 
-
 class Viewable(Renderable, Layoutable, ServableMixin):
     """
     Viewable is the baseclass all visual components in the panel
@@ -851,11 +851,7 @@ def clone(self, **params) -> 'Viewable':
         -------
         Cloned Viewable object
         """
-        inherited = {
-            p: v for p, v in self.param.values().items()
-            if not self.param[p].readonly and v is not self.param[p].default
-            and not (v is None and not self.param[p].allow_None)
-        }
+        inherited = get_params_to_inherit(self)
         return type(self)(**dict(inherited, **params))
 
     def pprint(self) -> None: