param 2.4.0a0__tar.gz → 2.4.0rc0__tar.gz

{param-2.4.0a0 → param-2.4.0rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: param
-Version: 2.4.0a0
+Version: 2.4.0rc0
 Summary: Declarative parameters for robust Python classes and a rich API for reactive programming
 Project-URL: Homepage, https://param.holoviz.org/
 Project-URL: Tracker, https://github.com/holoviz/param/issues

{param-2.4.0a0 → param-2.4.0rc0}/param/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.4.0a0'
-__version_tuple__ = version_tuple = (2, 4, 0, 'a0')
+__version__ = version = '2.4.0rc0'
+__version_tuple__ = version_tuple = (2, 4, 0, 'rc0')
 
 __commit_id__ = commit_id = None

{param-2.4.0a0 → param-2.4.0rc0}/param/depends.py

@@ -15,11 +15,12 @@ if t.TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Callable, Generator
 
     _Y = t.TypeVar("_Y")
-    _S = t.TypeVar("_S")
     _T = t.TypeVar("_T")
 
 _P = t.ParamSpec("_P")
+_FullP = t.ParamSpec("_FullP")
 _R = t.TypeVar("_R", covariant=True)
+_S = t.TypeVar("_S")
 Dependency = Parameter | str
 
 class DependencyInfo(t.TypedDict):
@@ -28,6 +29,10 @@ class DependencyInfo(t.TypedDict):
     watch: bool
     on_init: bool
 
+class _DepsFn(t.Protocol[_FullP, _R]):
+    _dinfo: DependencyInfo
+    def __call__(self, *args: _FullP.args, **kwargs: _FullP.kwargs) -> _R: ...
+
 class DependsFunc(t.Protocol[_P, _R]):
     _dinfo: DependencyInfo
     def __call__(self, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
@@ -35,25 +40,25 @@ class DependsFunc(t.Protocol[_P, _R]):
 
 @t.overload
 def depends(
-    func: Callable[_P, _R], /, *dependencies: Dependency, watch: bool = False, on_init: bool = False, **kw: Dependency
+    func: Callable[t.Concatenate[_S, _P], _R], /, *dependencies: Dependency, watch: bool = False, on_init: bool = False, **kw: Dependency
 ) -> DependsFunc[_P, _R]:
     ...
 
 @t.overload
 def depends(
     *dependencies: str, watch: bool = False, on_init: bool = False
-) -> Callable[[Callable[_P, _R]], DependsFunc[_P, _R]]:
+) -> Callable[[Callable[t.Concatenate[_S, _P], _R]], DependsFunc[_P, _R]]:
     ...
 
 @t.overload
 def depends(
     *dependencies: Parameter, watch: bool = False, on_init: bool = False, **kw: Parameter
-) -> Callable[[Callable[_P, _R]], DependsFunc[_P, _R]]:
+) -> Callable[[Callable[t.Concatenate[_S, _P], _R]], DependsFunc[_P, _R]]:
     ...
 
 def depends(
-    *dependencies: Dependency | Callable[_P, _R], watch: bool = False, on_init: bool = False, **kw: Dependency
-) -> DependsFunc[_P, _R] | Callable[[Callable[_P, _R]], DependsFunc[_P, _R]]:
+    *dependencies: Dependency | Callable[t.Concatenate[_S, _P], _R], watch: bool = False, on_init: bool = False, **kw: Dependency
+) -> DependsFunc[_P, _R] | Callable[[Callable[t.Concatenate[_S, _P], _R]], DependsFunc[_P, _R]]:
     """
     Annotates a function or :class:`Parameterized` method to express its dependencies.
 
@@ -74,51 +79,51 @@ def depends(
 
     """
     if dependencies and callable(dependencies[0]) and not isinstance(dependencies[0], (str, Parameter)):
-        func = t.cast("Callable[_P, _R]", dependencies[0])
+        func = t.cast("Callable[t.Concatenate[_S, _P], _R]", dependencies[0])
         deps = t.cast("tuple[Dependency, ...]", dependencies[1:])
-        return _depends_impl(func, *deps, watch=watch, on_init=on_init, **kw)
+        return t.cast("DependsFunc[_P, _R]", _depends_impl(func, *deps, watch=watch, on_init=on_init, **kw))
 
     deps = t.cast("tuple[Dependency, ...]", dependencies)
 
-    def _decorator(func: Callable[_P, _R]) -> DependsFunc[_P, _R]:
-        return _depends_impl(func, *deps, watch=watch, on_init=on_init, **kw)
+    def _decorator(func: Callable[t.Concatenate[_S, _P], _R]) -> DependsFunc[_P, _R]:
+        return t.cast("DependsFunc[_P, _R]", _depends_impl(func, *deps, watch=watch, on_init=on_init, **kw))
 
     return _decorator
 
 
 def _depends_impl(
-    func: Callable[_P, _R], /, *dependencies: Dependency, watch: bool = False, on_init: bool = False, **kw: Dependency
-) -> DependsFunc[_P, _R]:
+    func: Callable[_FullP, _R], /, *dependencies: Dependency, watch: bool = False, on_init: bool = False, **kw: Dependency
+) -> _DepsFn[_FullP, _R]:
     dependencies, kw = (
         tuple(transform_reference(arg) for arg in dependencies),
         {key: transform_reference(arg) for key, arg in kw.items()}
     )
 
     if inspect.isgeneratorfunction(func):
-        func_gen = t.cast("Callable[_P, Generator[t.Any, t.Any, t.Any]]", func)
+        func_gen = t.cast("Callable[_FullP, Generator[t.Any, t.Any, t.Any]]", func)
         @wraps(func)
         def _depends_gen(*args, **kw):
             for val in func_gen(*args, **kw):
                 yield val
-        _depends = t.cast("Callable[_P, _R]", _depends_gen)
+        _depends = t.cast("Callable[_FullP, _R]", _depends_gen)
     elif inspect.isasyncgenfunction(func):
-        func_agen = t.cast("Callable[_P, AsyncGenerator[t.Any, t.Any]]", func)
+        func_agen = t.cast("Callable[_FullP, AsyncGenerator[t.Any, t.Any]]", func)
         @wraps(func)
         async def _depends_async_gen(*args, **kw):
             async for val in func_agen(*args, **kw):
                 yield val
-        _depends = t.cast("Callable[_P, _R]", _depends_async_gen)
+        _depends = t.cast("Callable[_FullP, _R]", _depends_async_gen)
     elif iscoroutinefunction(func):
-        F = t.cast("Callable[_P, t.Awaitable[_R]]", func)
+        F = t.cast("Callable[_FullP, t.Awaitable[_R]]", func)
         @wraps(func)
         async def _depends_coro(*args, **kw):
             return await F(*args, **kw)
-        _depends = t.cast("Callable[_P, _R]", _depends_coro)
+        _depends = t.cast("Callable[_FullP, _R]", _depends_coro)
     else:
         @wraps(func)
         def _depends_sync(*args, **kw):
             return func(*args, **kw)
-        _depends = t.cast("Callable[_P, _R]", _depends_sync)
+        _depends = t.cast("Callable[_FullP, _R]", _depends_sync)
 
     deps = list(dependencies)+list(kw.values())
     string_specs = False
@@ -155,7 +160,7 @@ def _depends_impl(
     _dinfo.update({'dependencies': dependencies,
                    'kw': kw, 'watch': watch, 'on_init': on_init})
 
-    typed_depends = t.cast("DependsFunc[_P, _R]", _depends)
+    typed_depends = t.cast("_DepsFn[_FullP, _R]", _depends)
     typed_depends._dinfo = _dinfo
 
     if string_specs or not watch:
@@ -196,7 +201,7 @@ def _depends_impl(
         def cb_gen(*events: Event):
             args = _resolve_args()
             dep_kwargs = _resolve_kwargs()
-            func_gen = t.cast("Callable[_P, Generator[t.Any, t.Any, t.Any]]", func)
+            func_gen = t.cast("Callable[_FullP, Generator[t.Any, t.Any, t.Any]]", func)
             for val in func_gen(*args, **dep_kwargs):
                 yield val
         cb = cb_gen
@@ -204,7 +209,7 @@ def _depends_impl(
         async def cb_async_gen(*events: Event):
             args = _resolve_args()
             dep_kwargs = _resolve_kwargs()
-            func_agen = t.cast("Callable[_P, AsyncGenerator[t.Any, t.Any]]", func)
+            func_agen = t.cast("Callable[_FullP, AsyncGenerator[t.Any, t.Any]]", func)
             async for val in func_agen(*args, **dep_kwargs):
                 yield val
         cb = cb_async_gen
@@ -212,7 +217,7 @@ def _depends_impl(
         async def cb_coro(*events: Event):
             args = _resolve_args()
             dep_kwargs = _resolve_kwargs()
-            func_coro = t.cast("Callable[_P, t.Awaitable[t.Any]]", func)
+            func_coro = t.cast("Callable[_FullP, t.Awaitable[t.Any]]", func)
             await func_coro(*args, **dep_kwargs)
         cb = cb_coro
     else:

{param-2.4.0a0 → param-2.4.0rc0}/param/parameterized.py

@@ -59,7 +59,6 @@ if t.TYPE_CHECKING:
     class _StringInitKwargs(_ParameterKwargs, total=False):
         regex: str | re.Pattern[str] | None
 
-
 _T = t.TypeVar("_T")
 _P = t.ParamSpec("_P")
 _R = t.TypeVar("_R", covariant=True)
@@ -84,6 +83,8 @@ from ._utils import (
     gen_types,
 )
 
+_IS_PYPY = sys.implementation.name == "pypy"
+
 CRITICAL = 50
 ERROR = 40
 WARNING = 30
@@ -1189,6 +1190,7 @@ class ParameterMetaclass(type):
 
 
 _UDPATE_PARAMETER_SIGNATURE = _in_ipython() or (os.getenv("PARAM_PARAMETER_SIGNATURE", "false").lower() in ("1" , "true"))
+_PARAMETER_CACHE_ATTRS = ('instantiate', 'constant', 'default_factory')
 
 
 class _ParameterBase(metaclass=ParameterMetaclass):
@@ -1853,6 +1855,8 @@ class Parameter(_ParameterBase, t.Generic[_T]):
                 pass
 
         super().__setattr__(attribute, value)
+        if is_slot and attribute in _PARAMETER_CACHE_ATTRS:
+            self._invalidate_init_cache()
         if has_watcher and old is not NotImplemented:
             self._trigger_event(attribute, old, value)
 
@@ -1867,6 +1871,20 @@ class Parameter(_ParameterBase, t.Generic[_T]):
         if not self.owner.param._BATCH_WATCH:
             self.owner.param._batch_call_watchers()
 
+    def _invalidate_init_cache(self):
+        try:
+            owner = object.__getattribute__(self, 'owner')
+        except AttributeError:
+            return
+        if owner is None:
+            return
+        private = owner._param__private
+        if not hasattr(private, 'params_to_deepcopy'):
+            return
+        private.params_to_deepcopy = None
+        private.params_to_ref = None
+        private.params_with_default_factory = None
+
     def __getattribute__(self, key: str) -> t.Any:
         """
         Allow slot values to be Undefined in an "unbound" parameter, i.e. one
@@ -2011,6 +2029,9 @@ class Parameter(_ParameterBase, t.Generic[_T]):
                 obj._param__private.values[name] = val
         self._post_setter(obj, val)
 
+        if obj is None:
+            self._invalidate_init_cache()
+
         if obj is not None:
             if not hasattr(obj, '_param__private') or not getattr(obj._param__private, 'initialized', False):
                 return
@@ -2105,6 +2126,17 @@ class Parameter(_ParameterBase, t.Generic[_T]):
         """
         return {slot: getattr(self, slot) for slot in getattr(self.__class__, "_all_slots_", ())}
 
+    def __copy__(self) -> Parameter:
+        cls = self.__class__
+        duplicate = cls.__new__(cls)
+        if _IS_PYPY:
+            # Workaround for PyPy segfaults (https://github.com/pypy/pypy/issues/5400)
+            duplicate.__setstate__(self.__getstate__())
+        else:
+            for slot in cls._all_slots_:
+                object.__setattr__(duplicate, slot, getattr(self, slot))
+        return duplicate
+
     def __setstate__(self, state: dict[str, t.Any]):
         # set values of __slots__ (instead of in non-existent __dict__)
         for k, v in state.items():
@@ -2561,21 +2593,17 @@ class Parameters:
         defined as parameters.
         """
         self = self_.self
-        ## Deepcopy all 'instantiate=True' parameters
-        params_to_deepcopy = {}
-        params_to_ref = {}
         objects = self_._cls_parameters
-        for pname, p in objects.items():
-            if pname == 'name' or p.default_factory:
-                continue
-            if p.instantiate:
-                params_to_deepcopy[pname] = p
-            elif p.constant:
-                params_to_ref[pname] = p
+        private = self_.cls._param__private
+        params_to_deepcopy = private.params_to_deepcopy or []
+        params_to_ref = private.params_to_ref or []
+
+        if not params and not params_to_deepcopy and not params_to_ref:
+            return {}, {}
 
-        for p in params_to_deepcopy.values():
+        for p in params_to_deepcopy:
             self_._instantiate_param(p)
-        for p in params_to_ref.values():
+        for p in params_to_ref:
             self_._instantiate_param(p, deepcopy=False)
 
         ## keyword arg setting
@@ -3108,8 +3136,22 @@ class Parameters:
         and parameters are rarely added (and cannot be deleted).
         """
         cls = self_.cls
-        pdict = cls._param__private.params
+        private = cls._param__private
+        pdict = private.params
         if pdict:
+            if private.params_to_deepcopy is None or private.params_to_ref is None or private.params_with_default_factory is None:
+                private.params_to_deepcopy = []
+                private.params_to_ref = []
+                private.params_with_default_factory = []
+                for pname, pobj in pdict.items():
+                    if pname == 'name':
+                        continue
+                    if pobj.default_factory is not None:
+                        private.params_with_default_factory.append((pname, pobj))
+                    elif pobj.instantiate:
+                        private.params_to_deepcopy.append(pobj)
+                    elif pobj.constant:
+                        private.params_to_ref.append(pobj)
             return pdict
 
         paramdict = {}
@@ -3118,12 +3160,28 @@ class Parameters:
                 if isinstance(val, Parameter):
                     paramdict[name] = val
 
+        params_to_deepcopy: list[Parameter] = []
+        params_to_ref: list[Parameter] = []
+        params_with_default_factory: list[tuple[str, Parameter]] = []
+        for pname, pobj in paramdict.items():
+            if pname == 'name':
+                continue
+            if pobj.default_factory is not None:
+                params_with_default_factory.append((pname, pobj))
+            elif pobj.instantiate:
+                params_to_deepcopy.append(pobj)
+            elif pobj.constant:
+                params_to_ref.append(pobj)
+
         # We only want the cache to be visible to the cls on which
         # params() is called, so we mangle the name ourselves at
         # runtime (if we were to mangle it now, it would be
         # _Parameterized.__params for all classes).
         # cls._param__private.params[f'_{cls.__name__}__params'] = paramdict
-        cls._param__private.params = paramdict
+        private.params = paramdict
+        private.params_to_deepcopy = params_to_deepcopy
+        private.params_to_ref = params_to_ref
+        private.params_with_default_factory = params_with_default_factory
         return paramdict
 
     def objects(self_, instance: t.Literal[True, False, 'existing'] = True) -> dict[str, Parameter]:
@@ -3331,14 +3389,14 @@ class Parameters:
         """
         self_or_cls = self_.self_or_cls
         self_or_cls._Dynamic_time_fn = time_fn  # type: ignore[union-attr, ty:invalid-assignment]  # pyright: ignore[reportAttributeAccessIssue]
-        param_ns: Parameters = self_or_cls.param
+        param_objs = self_.objects('existing')
 
-        for n, p in param_ns.objects('existing').items():
+        for n, p in param_objs.items():
             if not hasattr(p, '_value_is_dynamic'):
                 continue
             is_dynamic = p._value_is_dynamic(None, self_._cls) if self_.self is None else p._value_is_dynamic(self_.self)
             if is_dynamic:
-                g = param_ns.get_value_generator(n)
+                g = self_.get_value_generator(n, param_objs)
                 g._Dynamic_time_fn = time_fn
 
         if sublistattr:
@@ -3647,12 +3705,12 @@ class Parameters:
         >>> p.param.values(onlychanged=True)
         {'a': 10}
         """
-        self_or_cls = self_.self_or_cls
-        param_ns = self_or_cls.param
+        param_objs = self_.objects('existing')  # type: ignore[union-attr, ty:unresolved-attribute]
+
         vals = []
-        for name, val in param_ns.objects('existing').items():  # type: ignore[union-attr, ty:unresolved-attribute,]
-            value = param_ns.get_value_generator(name)  # type: ignore[union-attr, ty:unresolved-attribute]
-            if name == 'name' and onlychanged and _is_auto_name(self_.cls.__name__, value):
+        for name, val in param_objs.items():
+            value = self_.get_value_generator(name, param_objs)
+            if name == 'name' and onlychanged and isinstance(value, str) and _is_auto_name(self_.cls.__name__, value):
                 continue
             if not onlychanged or not Comparator.is_equal(value, val.default):
                 vals.append((name, value))
@@ -3671,25 +3729,15 @@ class Parameters:
         If name is not dynamic, its current value is returned
         (i.e. equivalent to ``getattr(name)``).
         """
-        cls_or_slf = self_.self_or_cls
-        param_ns = cls_or_slf.param
-        param_obj = param_ns.objects('existing').get(name)  # type: ignore[union-attr, ty:unresolved-attribute]
-
+        param_obj = self_.objects('existing').get(name)  # type: ignore[union-attr, ty:unresolved-attribute]
         if not param_obj:
-            return getattr(cls_or_slf, name)
-
-        cls, slf = None, None
-        if isinstance(cls_or_slf,type):
-            cls = cls_or_slf
-        else:
-            slf = cls_or_slf
-
-        if not hasattr(param_obj,'_force'):
-            return param_obj.__get__(slf, cls)
+            return getattr(self_.self_or_cls, name)
+        elif not hasattr(param_obj, '_force'):
+            return param_obj.__get__(self_.self, self_.cls)
         else:
-            return param_obj._force(slf, cls)
+            return param_obj._force(self_.self, self_.cls)
 
-    def get_value_generator(self_, name: str) -> t.Any:
+    def get_value_generator(self_, name: str, parameters: dict[str, Parameter] | None = None) -> t.Any:
         """
         Retrieve the value or value-generating object of a named parameter.
 
@@ -3732,15 +3780,17 @@ class Parameters:
         <UniformRandom UniformRandom ...>
         """
         cls_or_slf = self_.self_or_cls
-        param_ns = cls_or_slf.param
-        param_obj = param_ns.objects('existing').get(name)  # type: ignore[union-attr, ty:unresolved-attribute]
+        if parameters and name in parameters:
+            param_obj: Parameter | None = parameters[name]
+        else:
+            param_obj = self_.objects('existing').get(name)  # type: ignore[union-attr, ty:unresolved-attribute]
 
         if not param_obj:
-            value = getattr(cls_or_slf,name)
+            value = getattr(cls_or_slf, name)
 
         # CompositeParameter detected by being a Parameter and having 'attribs'
         elif hasattr(param_obj, 'attribs'):
-            value = [param_ns.get_value_generator(a) for a in param_obj.attribs]  # type: ignore[union-attr, ty:unresolved-attribute]
+            value = [self_.get_value_generator(a) for a in param_obj.attribs]  # type: ignore[union-attr, ty:unresolved-attribute]
 
         # not a Dynamic Parameter
         elif not hasattr(param_obj, '_value_is_dynamic'):
@@ -3748,10 +3798,9 @@ class Parameters:
 
         # Dynamic Parameter...
         else:
-            # TODO: is this always an instance?
-            if isinstance(cls_or_slf, Parameterized) and name in cls_or_slf._param__private.values:
+            if self_.self is not None and name in self_.self._param__private.values:
                 # dealing with object and it's been set on this object
-                value = cls_or_slf._param__private.values[name]
+                value = self_.self._param__private.values[name]
             elif not callable(param_obj.default):
                 value = getattr(cls_or_slf, name)
             else:
@@ -3796,17 +3845,16 @@ class Parameters:
         -0.7312715117751976
         """
         cls_or_slf = self_.self_or_cls
-        param_ns = cls_or_slf.param
-        param_obj = param_ns.objects('existing').get(name)  # type: ignore[union-attr, ty:unresolved-attribute]
+        param_obj = self_.objects('existing').get(name)  # type: ignore[union-attr, ty:unresolved-attribute]
 
         if not param_obj:
             value = getattr(cls_or_slf,name)
         elif hasattr(param_obj,'attribs'):
-            value = [param_ns.inspect_value(a) for a in param_obj.attribs]  # type: ignore[union-attr, ty:unresolved-attribute]
+            value = [self_.inspect_value(a) for a in param_obj.attribs]  # type: ignore[union-attr, ty:unresolved-attribute]
         elif not hasattr(param_obj,'_inspect'):
-            value = getattr(cls_or_slf,name)
+            value = getattr(cls_or_slf, name)
         else:
-            if isinstance(cls_or_slf,type):
+            if isinstance(cls_or_slf, type):
                 value = param_obj._inspect(None, cls_or_slf)
             else:
                 value = param_obj._inspect(cls_or_slf, None)
@@ -5474,6 +5522,9 @@ class _ClassPrivate:
         'disable_instance_params',
         'renamed',
         'params',
+        'params_to_deepcopy',
+        'params_to_ref',
+        'params_with_default_factory',
         'initialized',
         'signature',
         'explicit_no_refs',
@@ -5483,6 +5534,9 @@ class _ClassPrivate:
     disable_instance_params: bool
     renamed: bool
     params: dict[str, Parameter]
+    params_to_deepcopy: list[Parameter] | None
+    params_to_ref: list[Parameter] | None
+    params_with_default_factory: list[tuple[str, Parameter]] | None
     initialized: bool
     signature: inspect.Signature | None
     explicit_no_refs: list[str]
@@ -5506,6 +5560,9 @@ class _ClassPrivate:
         self.disable_instance_params = disable_instance_params
         self.renamed = renamed
         self.params = {} if params is None else params
+        self.params_to_deepcopy = None
+        self.params_to_ref = None
+        self.params_with_default_factory = None
         self.initialized = False
         self.signature = None
         self.explicit_no_refs = [] if explicit_no_refs is None else explicit_no_refs
@@ -5617,15 +5674,7 @@ class _NS:
     def __get__(self, obj: C | None, objtype: type[C]) -> Parameters:
         if obj is None:
             return objtype._param__parameters
-        objdict = getattr(obj, "__dict__", None)
-        ns = objdict.get("_param__parameters") if objdict is not None else None
-        if ns is None:
-            ns = Parameters(objtype, self=obj)
-            if objdict is not None:
-                objdict["_param__parameters"] = ns
-            else:
-                setattr(obj, "_param__parameters", ns)
-        return ns
+        return Parameters(objtype, self=obj)
 
 
 class _PrivateNS:
@@ -5834,21 +5883,19 @@ class Parameterized(metaclass=ParameterizedMetaclass):
 
         # Find parameters with default_factory through the class
         # parameters to avoid making a copy.
-        params_with_default_factory = [
-            pname
-            for pname, pobj in self.param._cls_parameters.items()
-            if pname not in params
-            and pobj.default_factory is not None
-        ]
+        params_with_default_factory = type(self)._param__private.params_with_default_factory or []
         # Set from default_factory once initialized so instance parameters
         # are copied.
         if params_with_default_factory:
-            for pname in params_with_default_factory:
-                pobj = self.param[pname]
+            for pname, pobj in params_with_default_factory:
+                if pname in params:
+                    continue
                 dfactory = pobj.default_factory
                 if dfactory is None:
                     continue
                 elif isinstance(dfactory, DefaultFactory):
+                    # DefaultFactory receives instance-level Parameter context.
+                    pobj = self.param[pname]
                     default_val = dfactory(cls=type(self), self=self, parameter=pobj)
                 else:
                     default_val = dfactory()

{param-2.4.0a0 → param-2.4.0rc0}/param/parameters.py

@@ -67,6 +67,7 @@ if t.TYPE_CHECKING:
     from .parameterized import _ParameterKwargs
 
     LT = t.TypeVar("LT")
+    CT = t.TypeVar("CT")
 
     AT = t.TypeVar("AT", np.ndarray, np.ndarray | None)
     DF = t.TypeVar("DF", pd.DataFrame, pd.DataFrame | None)
@@ -1638,11 +1639,11 @@ class NumericTuple(Tuple[_T]):
 
         @t.overload
         def __init__(
-            self: NumericTuple[tuple[float, ...] | None],
+            self: NumericTuple[tuple[float, ...]],
             default: tuple[float, ...] = (0.0, 0.0),
             *,
             length: int | None = None,
-            allow_None: t.Literal[True] = True,
+            allow_None: t.Literal[False] = False,
             doc: str | None = None,
             label: str | None = None,
             precedence: float | None = None,
@@ -1661,10 +1662,21 @@ class NumericTuple(Tuple[_T]):
         @t.overload
         def __init__(
             self: NumericTuple[tuple[float, ...] | None],
-            default: None = None,
+            default: tuple[float, ...] | None = (0.0, 0.0),
             *,
             length: int | None = None,
-            allow_None: t.Literal[False] = False,
+            allow_None: t.Literal[True] = True,
+            **kwargs: Unpack[_ParameterKwargs]
+        ) -> None:
+            ...
+
+        @t.overload
+        def __init__(
+            self: NumericTuple[tuple[float, ...] | None],
+            default: None,
+            *,
+            length: int | None = None,
+            allow_None: bool = False,
             **kwargs: Unpack[_ParameterKwargs]
         ) -> None:
             ...
@@ -2586,7 +2598,7 @@ class Selector(SelectorBase, _SignatureSelector[_T]):
         object.__setattr__(self, 'check_on_set', check_on_set)
 
         instantiate = params.pop("instantiate", Undefined)
-        params["instantiate"] = False if instantiate is Undefined else instantiate
+        params["instantiate"] = False if instantiate is Undefined else instantiate  # pyrefly: ignore[bad-typed-dict-key]
         super().__init__(default=default, **params)
         # Required as Parameter sets allow_None=True if default is None
         if allow_None is Undefined:
@@ -2915,10 +2927,10 @@ class ClassSelector(SelectorBase[_T]):
 
         @t.overload
         def __init__(
-            self,
+            self: ClassSelector[CT],
             *,
-            default: _T,
-            class_: type[_T] | tuple[type[_T], ...],
+            default: CT,
+            class_: type[CT],
             is_instance: t.Literal[True] = True,
             allow_None: t.Literal[False] = False,
             doc: str | None = None,
@@ -2938,10 +2950,10 @@ class ClassSelector(SelectorBase[_T]):
 
         @t.overload
         def __init__(
-            self,
+            self: ClassSelector[CT | None],
             *,
             default: None = None,
-            class_: type[_T] | tuple[type[_T], ...],
+            class_: type[CT],
             is_instance: t.Literal[True] = True,
             allow_None: t.Literal[False] = False,
             **kwargs: Unpack[_ParameterKwargs]
@@ -2950,10 +2962,10 @@ class ClassSelector(SelectorBase[_T]):
 
         @t.overload
         def __init__(
-            self,
+            self: ClassSelector[CT | None],
             *,
-            default: _T | None = None,
-            class_: type[_T] | tuple[type[_T], ...],
+            default: CT | None = None,
+            class_: type[CT],
             is_instance: t.Literal[True] = True,
             allow_None: t.Literal[True] = True,
             **kwargs: Unpack[_ParameterKwargs]
@@ -2962,10 +2974,32 @@ class ClassSelector(SelectorBase[_T]):
 
         @t.overload
         def __init__(
-            self,
+            self: ClassSelector[t.Any],
             *,
-            default: type[_T],
-            class_: type[_T] | tuple[type[_T], ...],
+            default: t.Any = None,
+            class_: tuple[type, ...],
+            is_instance: t.Literal[True] = True,
+            allow_None: t.Literal[False] = False,
+            **kwargs: Unpack[_ParameterKwargs]
+        ) -> None: ...
+
+        @t.overload
+        def __init__(
+            self: ClassSelector[t.Any],
+            *,
+            default: t.Any = None,
+            class_: tuple[type, ...],
+            is_instance: t.Literal[True] = True,
+            allow_None: t.Literal[True] = True,
+            **kwargs: Unpack[_ParameterKwargs]
+        ) -> None: ...
+
+        @t.overload
+        def __init__(
+            self: ClassSelector[type[CT]],
+            *,
+            default: type[CT],
+            class_: type[CT],
             is_instance: t.Literal[False],
             allow_None: t.Literal[False] = False,
             **kwargs: Unpack[_ParameterKwargs]
@@ -2974,10 +3008,10 @@ class ClassSelector(SelectorBase[_T]):
 
         @t.overload
         def __init__(
-            self,
+            self: ClassSelector[type[CT] | None],
             *,
             default: None = None,
-            class_: type[_T] | tuple[type[_T], ...],
+            class_: type[CT] | tuple[type[CT], ...],
             is_instance: t.Literal[False],
             allow_None: t.Literal[False] = False,
             **kwargs: Unpack[_ParameterKwargs]
@@ -2986,16 +3020,27 @@ class ClassSelector(SelectorBase[_T]):
 
         @t.overload
         def __init__(
-            self,
+            self: ClassSelector[type[CT] | None],
             *,
-            default: type[_T] | None = None,
-            class_: type[_T] | tuple[type[_T], ...],
+            default: type[CT] | None = None,
+            class_: type[CT] | tuple[type[CT], ...],
             is_instance: t.Literal[False],
             allow_None: t.Literal[True] = True,
             **kwargs: Unpack[_ParameterKwargs]
         ) -> None:
             ...
 
+        @t.overload
+        def __init__(
+            self: ClassSelector[t.Any],
+            *,
+            default: t.Any = None,
+            class_: tuple[type, ...],
+            is_instance: t.Literal[False] = False,
+            allow_None: t.Literal[False] = False,
+            **kwargs: Unpack[_ParameterKwargs]
+        ) -> None: ...
+
     def __init__(
         self, *,
         class_: type | tuple[type, ...] = t.cast("type | tuple[type, ...]", Undefined),  # pyrefly: ignore[bad-argument-type]
@@ -3158,7 +3203,7 @@ class Array(ClassSelector["AT"]):
         import numpy
         super().__init__(  # type: ignore[misc, call-overload]
             default=default,  # type: ignore[arg-type]
-            class_=numpy.ndarray,
+            class_=numpy.ndarray,  # type: ignore[arg-type]
             is_instance=True,
             allow_None=allow_None,  # type: ignore[arg-type]
             **params,  # type: ignore[arg-type]
@@ -3471,7 +3516,7 @@ class List(Parameter[_T]):
             self: List[list[LT]],
             default: list[LT] = [],
             *,
-            item_type: type[LT] | tuple[type[LT], ...] | None = None,
+            item_type: type[LT] | tuple[type[LT], ...] = (),
             bounds: tuple[int, int | None] | None = (0, None),
             is_instance: bool = True,
             allow_None: t.Literal[False] = False,
@@ -3495,7 +3540,7 @@ class List(Parameter[_T]):
             self: List[list[LT] | None],
             default: list[LT] | None = None,
             *,
-            item_type: type[LT] | tuple[type[LT], ...] | None = None,
+            item_type: type[LT] | tuple[type[LT], ...] = (),
             allow_None: t.Literal[True] = True,
             **kwargs: Unpack[_ParameterKwargs]
         ) -> None:

{param-2.4.0a0 → param-2.4.0rc0}/tests/testparameterizedobject.py

@@ -2,8 +2,10 @@
 import abc
 import inspect
 import re
+import sys
 import unittest
 import warnings
+import weakref
 
 import param
 import numbergen
@@ -1981,3 +1983,22 @@ def test_abc_basic_checks():
     assert gc.l == [10]
     gc.x += 1
     assert gc.l == [10, 11]
+
+
+@pytest.mark.skipif(sys.implementation.name == "pypy", reason='Works differently on PyPy')
+def test_no_param_namespace_cycle():
+    # Accessing .param on an instance must not create a reference cycle.
+    # A cycle (obj -> obj.__dict__['_param__parameters'] -> Parameters.self -> obj)
+    # would prevent CPython's reference-counting from immediately freeing the
+    # object, breaking weakref-based cleanup used by libraries like HoloViews.
+    class P(param.Parameterized):
+        x = param.Number(1)
+
+    freed = []
+    obj = P()
+    ref = weakref.ref(obj, lambda _: freed.append(True))  # noqa: F841
+
+    _ = obj.param.values()  # access .param to trigger any caching
+
+    del obj
+    assert freed, "Parameterized instance not freed immediately — likely a reference cycle via .param"