param 2.4.0rc0__tar.gz → 2.4.0rc2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: param
-Version: 2.4.0rc0
+Version: 2.4.0rc2
 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.0rc0 → param-2.4.0rc2}/param/_utils.py

@@ -19,6 +19,7 @@ if t.TYPE_CHECKING:
 
     _P = t.ParamSpec("_P")
     _R = t.TypeVar("_R")
+    _T = t.TypeVar("_T")
     _CallableT = t.TypeVar("_CallableT", bound=abc.Callable)
 
 DEFAULT_SIGNATURE = inspect.Signature([
@@ -443,7 +444,7 @@ def _is_abstract(class_: type) -> bool:
     return bool(getattr(class_, "abstract", False))
 
 
-def descendents(class_: type, concrete: bool = False) -> list[type]:
+def descendents(class_: type[_T], concrete: bool = False) -> list[type[_T]]:
     """
     Return a list of all descendent classes of a given class.
 
@@ -482,7 +483,7 @@ def descendents(class_: type, concrete: bool = False) -> list[type]:
     if not isinstance(class_, type):
         raise TypeError(f"descendents expected a class object, not {type(class_).__name__}")
     q = [class_]
-    out: list[type] = []
+    out: list[type[_T]] = []
     while len(q):
         x = q.pop(0)
         out.insert(0, x)
@@ -499,7 +500,7 @@ def descendents(class_: type, concrete: bool = False) -> list[type]:
 
 
 # Could be a method of ClassSelector.
-def concrete_descendents(parentclass: type) -> dict[str, type]:
+def concrete_descendents(parentclass: type[_T]) -> dict[str, type[_T]]:
     """
     Return a dictionary containing all subclasses of the specified
     parentclass, including the parentclass (prefer :func:`descendents`).

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

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

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

@@ -1944,7 +1944,7 @@ class Parameter(_ParameterBase, t.Generic[_T]):
         return result
 
     @instance_descriptor
-    def __set__(self, obj: Parameterized, val: _T):
+    def __set__(self, obj: Parameterized | None, val: _T):
         """
         Set the value for this Parameter.
 
@@ -2253,9 +2253,9 @@ class String(Parameter[_T]):
         self._validate(self.default)
 
     def _validate_regex(self, val: t.Any, regex: str | re.Pattern[str] | None):
-        if (val is None and self.allow_None):
+        if val is None or regex is None:
             return
-        if regex is not None and re.match(regex, val) is None:
+        if re.fullmatch(regex, val) is None:
             raise ValueError(
                 f'{_validate_error_prefix(self)} value {val!r} does not '
                 f'match regex {regex!r}.'
@@ -2731,7 +2731,7 @@ class Parameters:
         except Skip:
             value = Undefined
         if is_async and pobj.name:
-            async_executor(partial(self_._async_ref, pobj.name, value))
+            async_executor(partial(self_._async_ref, pobj.name, t.cast("t.Awaitable[t.Any]", value)))
             value = None
         return ref, deps, value, is_async
 

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

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import copy
 import datetime as dt
+import enum
 import glob
 import inspect
 import numbers
@@ -605,17 +606,17 @@ class Dynamic(Parameter[_T]):
         Call the superclass's __init__ and set instantiate=True if the
         default is dynamic.
         """
-        super().__init__(default=default, allow_None=allow_None, **params)
+        super().__init__(default=default, allow_None=allow_None, **params)  # ty: ignore[no-matching-overload]
 
         if callable(self.default):
             self._set_instantiate(True)
             self._initialize_generator(self.default)
 
-    def _initialize_generator(self, gen, obj=None):
+    def _initialize_generator(self, gen, obj: Parameterized | None = None):
         """Add 'last time' and 'last value' attributes to the generator."""
         # Could use a dictionary to hold these things.
         if obj is not None and hasattr(obj, "_Dynamic_time_fn"):
-            gen._Dynamic_time_fn = obj._Dynamic_time_fn
+            gen._Dynamic_time_fn = obj._Dynamic_time_fn  # type: ignore[attribute-access]
 
         gen._Dynamic_last = None
         # Would have usede None for this, but can't compare a fixedpoint
@@ -641,7 +642,7 @@ class Dynamic(Parameter[_T]):
             return t.cast("_T", self._produce_value(gen))
 
     @instance_descriptor
-    def __set__(self, obj: Parameterized, val: _T):
+    def __set__(self, obj: Parameterized | None, val: _T):
         """
         Call the superclass's set and keep this parameter's
         instantiate value up to date (dynamic parameters
@@ -652,8 +653,10 @@ class Dynamic(Parameter[_T]):
         super().__set__(obj, val)
 
         dynamic = callable(val)
-        if dynamic: self._initialize_generator(val,obj)
-        if obj is None: self._set_instantiate(dynamic)
+        if dynamic:
+            self._initialize_generator(val, obj)
+        if obj is None:
+            self._set_instantiate(dynamic)
 
     def _produce_value(self, gen, force: bool = False):
         """
@@ -1154,7 +1157,7 @@ class Magnitude(Number[_T]):
         allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
         **kwargs: Unpack[_NumberInitKwargs]
     ) -> None:
-        super().__init__( # type: ignore[misc, call-overload]
+        super().__init__(  # type: ignore[misc, call-overload]
             default=default, allow_None=allow_None, **kwargs  # type: ignore[arg-type]
         )
 
@@ -1307,7 +1310,7 @@ class CalendarDate(Number[_T]):
         allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
         **kwargs: Unpack[_CalendarDateInitKwargs]
     ) -> None:
-        super().__init__( # type: ignore[misc, call-overload]
+        super().__init__(  # type: ignore[misc, call-overload]  # ty: ignore[no-matching-overload]
             default=default, allow_None=allow_None, **kwargs  # type: ignore[arg-type]
         )
 
@@ -1606,7 +1609,7 @@ class Tuple(Parameter[_T]):
             )
 
     def _validate_length(self, val, length):
-        if val is None and self.allow_None:
+        if val is None:
             return
 
         if not len(val) == length:
@@ -1898,16 +1901,17 @@ class Range(NumericTuple[_T]):
             )
 
     def _validate_bounds(self, val, bounds, inclusive_bounds, kind):
-        if bounds is not None:
-            for pos, v in zip(['lower', 'upper'], bounds):
-                if v is None:
-                    continue
-                self._validate_bound_type(v, pos, kind)
-        if kind == 'softbound':
+        if bounds is None:
             return
 
-        if bounds is None or (val is None and self.allow_None):
+        for pos, v in zip(['lower', 'upper'], bounds):
+            if v is None:
+                continue
+            self._validate_bound_type(v, pos, kind)
+
+        if val is None or kind == 'softbound':
             return
+
         vmin, vmax = bounds
         incmin, incmax = inclusive_bounds
         for bound, v in zip(['lower', 'upper'], val):
@@ -1984,7 +1988,7 @@ class DateRange(Range[_T]):
         allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
         **kwargs: Unpack[_DateInitKwargs]
     ) -> None:
-        super().__init__(default=default, allow_None=allow_None, **kwargs)  # type: ignore[misc, call-overload]
+        super().__init__(default=default, allow_None=allow_None, **kwargs)  # type: ignore[misc, call-overload, ty:invalid-argument-type]
 
     def _validate_bound_type(self, value, position, kind):
         if not isinstance(value, _dt_types):
@@ -2107,7 +2111,7 @@ class CalendarDateRange(Range[_T]):
         allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
         **kwargs: Unpack[_CalendarDateInitKwargs]
     ) -> None:
-        super().__init__(default=default, allow_None=allow_None, **kwargs)  # type: ignore[misc, call-overload]
+        super().__init__(default=default, allow_None=allow_None, **kwargs)  # type: ignore[misc, call-overload]  # ty: ignore[invalid-argument-type]
 
     def _validate_value(self, value, allow_None):
         if allow_None and value is None:
@@ -2216,11 +2220,54 @@ class Callable(Parameter[_T]):
         self._validate_value(val, self.allow_None)
 
 
-class Action(Callable):
+class Action(Callable[_T]):
     """
     A user-provided function that can be invoked like a class or object method using ().
     In a GUI, this might be mapped to a button, but it can be invoked directly as well.
     """
+
+    if t.TYPE_CHECKING:
+
+        @t.overload
+        def __init__(
+            self: Action[t.Callable[[], t.Any]],
+            default: t.Callable[[], t.Any] = lambda: None,
+            *,
+            allow_None: t.Literal[False] = False,
+            doc: str | None = None,
+            label: str | None = None,
+            precedence: float | None = None,
+            instantiate: bool = False,
+            constant: bool = False,
+            readonly: bool = False,
+            pickle_default_value: bool = True,
+            per_instance: bool = True,
+            allow_refs: bool = False,
+            nested_refs: bool = False,
+            default_factory: t.Callable[[], t.Any] | None = None,
+            metadata: dict[str, t.Any] | None = None,
+        ) -> None:
+            ...
+
+        @t.overload
+        def __init__(
+            self: Action[t.Callable[[], t.Any] | None],
+            default: None = None,
+            *,
+            allow_None: t.Literal[True] = True,
+            **params: Unpack[_ParameterKwargs]
+        ) -> None:
+            ...
+
+    def __init__(self,
+        default: t.Callable[[], t.Any] | None = t.cast("t.Callable[[], t.Any] | None", Undefined),  # pyrefly: ignore[bad-argument-type]
+        *,
+        allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
+        **params: Unpack[_ParameterKwargs]
+    ) -> None:
+        super().__init__(default=default, **params)  # type: ignore[misc]  # pyrefly: ignore[bad-argument-type]
+        self._validate(self.default)
+
 # Currently same implementation as Callable, but kept separate to allow different handling in GUIs
 
 #-----------------------------------------------------------------------------
@@ -2829,14 +2876,14 @@ class ListSelector(Selector):
                     self.objects.append(o)
 
     def _validate(self, val):
-        if (val is None and self.allow_None):
+        if val is None and self.allow_None:
             return
         self._validate_type(val)
 
         if self.check_on_set:
             self._validate_value(val)
         else:
-            for v in val:
+            for v in val:  # pyright: ignore[reportOptionalIterable]
                 self._ensure_value_is_in_objects(v)
 
     def _validate_type(self, val):
@@ -2901,6 +2948,14 @@ class MultiFileSelector(ListSelector):
         return _abbreviate_paths(self.path, super().get_range())
 
 
+class NoNoneType(enum.Enum):
+    NO_NONE = enum.auto()
+
+
+NoNone = NoNoneType.NO_NONE
+
+
+
 class ClassSelector(SelectorBase[_T]):
     """
     Parameter allowing selection of either a subclass or an instance of a class
@@ -2960,6 +3015,18 @@ class ClassSelector(SelectorBase[_T]):
         ) -> None:
             ...
 
+        @t.overload
+        def __init__(
+            self: ClassSelector[CT],
+            *,
+            default: CT | None = None,
+            class_: type[CT],
+            is_instance: t.Literal[True] = True,
+            allow_None: NoNoneType,
+            **kwargs: Unpack[_ParameterKwargs]
+        ) -> None:
+            ...
+
         @t.overload
         def __init__(
             self: ClassSelector[CT | None],
@@ -3006,6 +3073,18 @@ class ClassSelector(SelectorBase[_T]):
         ) -> None:
             ...
 
+        @t.overload
+        def __init__(
+            self: ClassSelector[type[CT]],
+            *,
+            default: type[CT] | None = None,
+            class_: type[CT],
+            is_instance: t.Literal[False],
+            allow_None: NoNoneType,
+            **kwargs: Unpack[_ParameterKwargs]
+        ) -> None:
+            ...
+
         @t.overload
         def __init__(
             self: ClassSelector[type[CT] | None],
@@ -3046,9 +3125,10 @@ class ClassSelector(SelectorBase[_T]):
         class_: type | tuple[type, ...] = t.cast("type | tuple[type, ...]", Undefined),  # pyrefly: ignore[bad-argument-type]
         default: t.Any | None = Undefined,
         is_instance: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
-        allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
+        allow_None: bool | NoNoneType = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
         **params: Unpack[_ParameterKwargs]
     ) -> None:
+        allow_None = t.cast("bool", Undefined if allow_None is NoNone else allow_None)
         object.__setattr__(self, 'class_', class_)
         object.__setattr__(self, 'is_instance', is_instance)  # type: ignore
         super().__init__(  # type: ignore[misc, call-overload]
@@ -3063,7 +3143,9 @@ class ClassSelector(SelectorBase[_T]):
     def _validate_class_(self, val: t.Any, class_: type | tuple[type, ...], is_instance: bool):
         if (val is None and self.allow_None):
             return
-        if (is_instance and isinstance(val, class_)) or (not is_instance and issubclass(val, class_)):
+        if (is_instance and isinstance(val, class_)) or (
+            not is_instance and isinstance(val, type) and issubclass(val, class_)
+        ):
             return
 
         if isinstance(class_, tuple):
@@ -3152,7 +3234,7 @@ class Dict(ClassSelector[_T]):
         allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
         **params: Unpack[_ClassSelectorKwargs]
     ) -> None:
-        super().__init__(  # type: ignore[misc, call-overload]
+        super().__init__(  # type: ignore[misc, call-overload]  # ty: ignore[no-matching-overload]
             default=default, class_=dict, allow_None=allow_None, **params  # type: ignore[arg-type]
         )
 
@@ -3201,7 +3283,7 @@ class Array(ClassSelector["AT"]):
         **params: Unpack[_ClassSelectorKwargs]
     ) -> None:
         import numpy
-        super().__init__(  # type: ignore[misc, call-overload]
+        super().__init__(  # type: ignore[misc, call-overload]  # ty: ignore[no-matching-overload]
             default=default,  # type: ignore[arg-type]
             class_=numpy.ndarray,  # type: ignore[arg-type]
             is_instance=True,
@@ -3290,6 +3372,16 @@ class DataFrame(ClassSelector["DF"]):
         ) -> None:
             ...
 
+        @t.overload
+        def __init__(
+            self: DataFrame[pd.DataFrame | None],
+            default: None = None,
+            *,
+            allow_None: t.Literal[False] = False,
+            **kwargs: Unpack[_DataFrameInitKwargs]
+        ) -> None:
+            ...
+
     def __init__(
         self,
         default: pd.DataFrame | None = t.cast("pd.DataFrame | None", Undefined),  # pyrefly: ignore[bad-argument-type]
@@ -3596,7 +3688,7 @@ class List(Parameter[_T]):
 
     def _validate_bounds(self, val, bounds):
         """Check that the list is of the right length and has the right contents."""
-        if bounds is None or (val is None and self.allow_None):
+        if bounds is None or val is None:
             return
         min_length, max_length = bounds
         l = len(val)
@@ -3761,7 +3853,7 @@ class Path(Parameter[_T]):
     __slots__ = ['search_paths', 'check_exists']
 
     _slot_defaults = dict(
-        Parameter._slot_defaults, check_exists=True,
+        Parameter._slot_defaults, check_exists=True, search_paths=None
     )
 
     search_paths: list[str | PathLike] | None
@@ -3774,9 +3866,9 @@ class Path(Parameter[_T]):
             self: Path[PathLike | str],
             default: PathLike | str = pathlib.Path(""),
             *,
-            allow_None: t.Literal[False] = False,
             search_paths: list[str | PathLike] | None = None,
             check_exists: bool = True,
+            allow_None: t.Literal[False] = False,
             doc: str | None = None,
             label: str | None = None,
             precedence: float | None = None,
@@ -3795,7 +3887,7 @@ class Path(Parameter[_T]):
         @t.overload
         def __init__(
             self: Path[PathLike | str | None],
-            default: None = None,
+            default: PathLike | str = pathlib.Path(""),
             *,
             allow_None: t.Literal[True] = True,
             **kwargs: Unpack[_PathInitKwargs]
@@ -3805,7 +3897,7 @@ class Path(Parameter[_T]):
         @t.overload
         def __init__(
             self: Path[PathLike | str | None],
-            default: PathLike | str = pathlib.Path(""),
+            default: PathLike | str | None = None,
             *,
             allow_None: t.Literal[True] = True,
             **kwargs: Unpack[_PathInitKwargs]
@@ -3873,8 +3965,7 @@ class Path(Parameter[_T]):
         return state
 
 
-
-class Filename(Path):
+class Filename(Path[_T]):
     """
     Parameter that can be set to a string specifying the path of a file.
 
@@ -3889,11 +3980,67 @@ class Filename(Path):
       is ``None``).
     """
 
+    if t.TYPE_CHECKING:
+
+        @t.overload
+        def __init__(
+            self: Filename[PathLike | str],
+            default: PathLike | str = pathlib.Path(""),
+            *,
+            allow_None: t.Literal[False] = False,
+            search_paths: list[str | PathLike] | None = None,
+            check_exists: bool = True,
+            doc: str | None = None,
+            label: str | None = None,
+            precedence: float | None = None,
+            instantiate: bool = False,
+            constant: bool = False,
+            readonly: bool = False,
+            pickle_default_value: bool = True,
+            per_instance: bool = True,
+            allow_refs: bool = False,
+            nested_refs: bool = False,
+            default_factory: t.Callable[[], t.Any] | None = None,
+            metadata: dict[str, t.Any] | None = None,
+        ) -> None:
+            ...
+
+        @t.overload
+        def __init__(
+            self: Filename[PathLike | str | None],
+            default: PathLike | str = pathlib.Path(""),
+            *,
+            allow_None: t.Literal[True] = True,
+            **kwargs: Unpack[_PathInitKwargs]
+        ) -> None:
+            ...
+
+        @t.overload
+        def __init__(
+            self: Filename[PathLike | str | None],
+            default: PathLike | str | None = None,
+            *,
+            allow_None: t.Literal[True] = True,
+            **kwargs: Unpack[_PathInitKwargs]
+        ) -> None:
+            ...
+
+    def __init__(
+        self,
+        default: str | PathLike | None = t.cast("str | PathLike | None", Undefined),  # pyrefly: ignore[bad-argument-type]
+        *,
+        allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
+        **kwargs: Unpack[_PathInitKwargs]
+    ) -> None:
+        super().__init__(  # type: ignore[misc, call-overload]  # ty: ignore[no-matching-overload]
+            default=default, allow_None=allow_None, **kwargs  # type: ignore[arg-type]
+        )
+
     def _resolve(self, path):
         return resolve_path(path=path, path_to_file=True, search_paths=self.search_paths)
 
 
-class Foldername(Path):
+class Foldername(Path[_T]):
     """
     Parameter that can be set to a string specifying the path of a folder.
 
@@ -3908,6 +4055,62 @@ class Foldername(Path):
       is ``None``).
     """
 
+    if t.TYPE_CHECKING:
+
+        @t.overload
+        def __init__(
+            self: Foldername[PathLike | str],
+            default: PathLike | str = pathlib.Path(""),
+            *,
+            allow_None: t.Literal[False] = False,
+            search_paths: list[str | PathLike] | None = None,
+            check_exists: bool = True,
+            doc: str | None = None,
+            label: str | None = None,
+            precedence: float | None = None,
+            instantiate: bool = False,
+            constant: bool = False,
+            readonly: bool = False,
+            pickle_default_value: bool = True,
+            per_instance: bool = True,
+            allow_refs: bool = False,
+            nested_refs: bool = False,
+            default_factory: t.Callable[[], t.Any] | None = None,
+            metadata: dict[str, t.Any] | None = None,
+        ) -> None:
+            ...
+
+        @t.overload
+        def __init__(
+            self: Foldername[PathLike | str | None],
+            default: PathLike | str = pathlib.Path(""),
+            *,
+            allow_None: t.Literal[True] = True,
+            **kwargs: Unpack[_PathInitKwargs]
+        ) -> None:
+            ...
+
+        @t.overload
+        def __init__(
+            self: Foldername[PathLike | str | None],
+            default: PathLike | str | None = None,
+            *,
+            allow_None: t.Literal[True] = True,
+            **kwargs: Unpack[_PathInitKwargs]
+        ) -> None:
+            ...
+
+    def __init__(
+        self,
+        default: str | PathLike | None = t.cast("str | PathLike | None", Undefined),  # pyrefly: ignore[bad-argument-type]
+        *,
+        allow_None: bool = t.cast("bool", Undefined),  # pyrefly: ignore[bad-argument-type]
+        **kwargs: Unpack[_PathInitKwargs]
+    ) -> None:
+        super().__init__(  # type: ignore[misc, call-overload]  # ty: ignore[no-matching-overload]
+            default=default, allow_None=allow_None, **kwargs  # type: ignore[arg-type]
+        )
+
     def _resolve(self, path):
         return resolve_path(path=path, path_to_file=False, search_paths=self.search_paths)
 
@@ -4031,9 +4234,9 @@ class Color(Parameter[_T]):
             )
 
     def _validate_allow_named(self, val, allow_named):
-        if (val is None and self.allow_None):
+        if val is None:
             return
-        is_hex = re.match('^#?(([0-9a-fA-F]{2}){3}|([0-9a-fA-F]){3})$', val)
+        is_hex = re.fullmatch('^#?(([0-9a-fA-F]{2}){3}|([0-9a-fA-F]){3})$', val)
         if self.allow_named:
             if not is_hex and val.lower() not in self._named_colors:
                 raise ValueError(
@@ -4114,9 +4317,9 @@ class Bytes(Parameter[_T]):
         self._validate(self.default)
 
     def _validate_regex(self, val, regex):
-        if (val is None and self.allow_None):
+        if val is None or regex is None:
             return
-        if regex is not None and re.match(regex, val) is None:
+        if re.fullmatch(regex, val) is None:
             raise ValueError(
                 f"{_validate_error_prefix(self)} value {val!r} "
                 f"does not match regex {regex!r}."

param-2.4.0rc2/tests/assert_types.py

@@ -0,0 +1,426 @@
+from __future__ import annotations
+
+import os
+import typing as t
+import pathlib
+from datetime import date, datetime
+from typing_extensions import assert_type
+
+import numpy as np
+import param
+import pandas
+
+
+class ParameterType(param.Parameterized):
+    parameter = param.Parameter()
+    optional_parameter = param.Parameter(default=None, allow_None=True)
+
+ptypes = ParameterType()
+assert_type(ptypes.parameter, t.Any)
+assert_type(ptypes.optional_parameter, t.Any)
+
+ParameterType.parameter = "Foo"
+ptypes.parameter = 42
+
+################
+# String Types #
+################
+
+class StringTypes(param.Parameterized):
+    string = param.String()
+    optional_string = param.String(allow_None=True)
+    implicit_optional_string = param.String(default=None)
+    empty_string = param.String()
+
+    nt = param.NumericTuple()
+
+stypes = StringTypes()
+
+assert_type(stypes.string, str)
+assert_type(stypes.empty_string, str)
+assert_type(stypes.optional_string, str | None)
+assert_type(stypes.implicit_optional_string, str | None)
+
+stypes.string = "test"
+stypes.optional_string = None
+
+################
+# Number Types #
+################
+
+class NumberTypes(param.Parameterized):
+    number = param.Number(allow_None=False)
+    optional_number = param.Number(allow_None=True)
+    implicit_optional_number = param.Number(default=None)
+    empty_number = param.Number()
+ntypes = NumberTypes()
+
+assert_type(ntypes.number, float | int)
+assert_type(ntypes.empty_number, float | int)
+assert_type(ntypes.optional_number, float | int | None)
+assert_type(ntypes.implicit_optional_number, float | int | None)
+
+class MagnitudeTypes(param.Parameterized):
+    magnitude = param.Magnitude(allow_None=False)
+    optional_magnitude = param.Magnitude(allow_None=True)
+
+mtypes = MagnitudeTypes()
+assert_type(mtypes.magnitude, float)
+assert_type(mtypes.optional_magnitude, float | None)
+
+#################
+# Integer Types #
+#################
+
+class IntegerTypes(param.Parameterized):
+    integer = param.Integer(allow_None=False)
+    optional_integer = param.Integer(allow_None=True)
+    implicit_optional_integer = param.Integer(default=None)
+    empty_integer = param.Integer()
+
+itypes = IntegerTypes()
+
+assert_type(itypes.integer, int)
+assert_type(itypes.empty_integer, int)
+assert_type(itypes.optional_integer, int | None)
+assert_type(itypes.implicit_optional_integer, int | None)
+
+#################
+# Boolean Types #
+#################
+
+class BooleanTypes(param.Parameterized):
+    boolean = param.Boolean(allow_None=False)
+    optional_boolean = param.Boolean(allow_None=True)
+    implicit_optional_boolean = param.Boolean(default=None)
+
+btypes = BooleanTypes()
+
+assert_type(btypes.boolean, bool)
+assert_type(btypes.optional_boolean, bool | None)
+assert_type(btypes.implicit_optional_boolean, bool | None)
+
+class EventTypes(param.Parameterized):
+    event = param.Event()
+
+etypes = EventTypes()
+assert_type(etypes.event, t.Any)
+
+##############
+# List Types #
+##############
+
+class ListTypes(param.Parameterized):
+    list_param = param.List(allow_None=False)
+    optional_list_param = param.List(allow_None=True)
+    list_int_param = param.List(item_type=int, allow_None=False)
+    optional_list_int_param = param.List(item_type=int, allow_None=True)
+    empty_list = param.List()
+
+ListTypes.list_param = []
+
+ltypes = ListTypes()
+
+assert_type(ltypes.empty_list, list[t.Any])
+assert_type(ltypes.list_param, list[t.Any])
+assert_type(ltypes.optional_list_param, list[t.Any] | None)
+assert_type(ltypes.list_int_param, list[int])
+assert_type(ltypes.optional_list_int_param, list[int] | None)
+
+class Test(param.Parameterized):
+    a = param.Integer()
+    b = param.List(item_type=int)
+
+tst = Test()
+assert_type(Test.a, int)
+assert_type(Test.b, list[int])
+assert_type(tst.a, int)
+assert_type(tst.b, list[int])
+
+##############
+# Dict Types #
+##############
+
+class DictTypes(param.Parameterized):
+    dict_param = param.Dict(allow_None=False)
+    optional_dict_param = param.Dict(allow_None=True)
+
+dtypes = DictTypes()
+
+assert_type(dtypes.dict_param, dict)
+assert_type(dtypes.optional_dict_param, dict | None)
+
+###############
+# Dynamic Type #
+###############
+
+class DynamicTypes(param.Parameterized):
+    dynamic = param.Dynamic(default=1)
+    optional_dynamic = param.Dynamic(default=None, allow_None=True)
+
+dytypes = DynamicTypes()
+assert_type(dytypes.dynamic, t.Any)
+assert_type(dytypes.optional_dynamic, t.Any | None)
+
+###############
+# Tuple Types #
+###############
+
+class TupleTypes(param.Parameterized):
+    tuple_param = param.Tuple(length=2, allow_None=False)
+    optional_tuple_param = param.Tuple(length=2, allow_None=True)
+
+ttypes = TupleTypes()
+
+assert_type(ttypes.tuple_param, tuple[t.Any, ...])
+assert_type(ttypes.optional_tuple_param, tuple[t.Any, ...] | None)
+
+class NumericTupleTypes(param.Parameterized):
+    numeric_tuple = param.NumericTuple(allow_None=False)
+    optional_numeric_tuple = param.NumericTuple(allow_None=True)
+    empty_numeric_tuple = param.NumericTuple()
+
+nttypes = NumericTupleTypes()
+assert_type(nttypes.numeric_tuple, tuple[float, ...])
+assert_type(nttypes.optional_numeric_tuple, tuple[float, ...] | None)
+assert_type(nttypes.empty_numeric_tuple, tuple[float, ...])
+
+class XYCoordinatesTypes(param.Parameterized):
+    xy = param.XYCoordinates(allow_None=False)
+    optional_xy = param.XYCoordinates(allow_None=True)
+
+xytypes = XYCoordinatesTypes()
+assert_type(xytypes.xy, tuple[float, float])
+assert_type(xytypes.optional_xy, tuple[float, float] | None)
+
+class RangeTypes(param.Parameterized):
+    range_param = param.Range(allow_None=False)
+    optional_range_param = param.Range(allow_None=True)
+
+rtypes = RangeTypes()
+assert_type(rtypes.range_param, tuple[float, float])
+assert_type(rtypes.optional_range_param, tuple[float, float] | None)
+
+##############
+# Date Types #
+##############
+
+class DateTypes(param.Parameterized):
+    date_param = param.Date(default=datetime(2024, 1, 1), allow_None=False)
+    optional_date_param = param.Date(default=None, allow_None=True)
+    calendar_date_param = param.CalendarDate(default=date(2024, 1, 1), allow_None=False)
+    optional_calendar_date_param = param.CalendarDate(default=None, allow_None=True)
+
+dtypes = DateTypes()
+assert_type(dtypes.date_param, datetime | date)
+assert_type(dtypes.optional_date_param, datetime | date | None)
+assert_type(dtypes.calendar_date_param, date)
+assert_type(dtypes.optional_calendar_date_param, date | None)
+
+class DateRangeTypes(param.Parameterized):
+    date_range = param.DateRange(
+        default=(datetime(2024, 1, 1), datetime(2024, 1, 2)),
+        allow_None=False,
+    )
+    optional_date_range = param.DateRange(default=None, allow_None=True)
+    calendar_date_range = param.CalendarDateRange(
+        default=(date(2024, 1, 1), date(2024, 1, 2)),
+        allow_None=False,
+    )
+    optional_calendar_date_range = param.CalendarDateRange(default=None, allow_None=True)
+
+drtypes = DateRangeTypes()
+assert_type(drtypes.date_range, tuple[datetime | date, datetime | date])
+assert_type(drtypes.optional_date_range, tuple[datetime | date, datetime | date] | None)
+assert_type(drtypes.calendar_date_range, tuple[date, date])
+assert_type(drtypes.optional_calendar_date_range, tuple[date, date] | None)
+
+###############
+# Class Types #
+###############
+
+class Foo: pass
+
+class ClassTypes(param.Parameterized):
+    foo = param.ClassSelector(class_=Foo, allow_None=False, default=Foo())
+    optional_foo = param.ClassSelector(class_=Foo, allow_None=True)
+    no_none_foo = param.ClassSelector(class_=Foo, allow_None=param.parameters.NoNone)
+
+ctypes = ClassTypes()
+
+assert_type(ctypes.foo, Foo)
+assert_type(ctypes.optional_foo, Foo | None)
+assert_type(ctypes.no_none_foo, Foo)
+
+class SelectorBaseTypes(param.Parameterized):
+    selector_base = param.SelectorBase(default=1, allow_None=False)
+    optional_selector_base = param.SelectorBase(default=None, allow_None=True)
+
+sbtypes = SelectorBaseTypes()
+assert_type(sbtypes.selector_base, t.Any)
+assert_type(sbtypes.optional_selector_base, t.Any)
+
+##############
+# Type
+##############
+
+class TypeTypes(param.Parameterized):
+    type_param = param.ClassSelector(
+        allow_None=False, is_instance=False, class_=Foo, default=Foo
+    )
+    optional_type_param = param.ClassSelector(
+        allow_None=True, is_instance=False, class_=Foo
+    )
+
+ttypes = TypeTypes()
+assert_type(ttypes.type_param, type[Foo])
+assert_type(ttypes.optional_type_param, type[Foo] | None)
+
+
+##############
+# DataFrame  #
+##############
+
+class DataFrameTypes(param.Parameterized):
+    df = param.DataFrame(default=pandas.DataFrame(), allow_None=False)
+    optional_df = param.DataFrame(allow_None=True, rows=3)
+    optional_df_by_default = param.DataFrame()
+
+dftypes = DataFrameTypes()
+assert_type(dftypes.df, pandas.DataFrame)
+assert_type(dftypes.optional_df, pandas.DataFrame | None)
+assert_type(dftypes.optional_df_by_default, pandas.DataFrame | None)  # type: ignore
+
+###########
+# Series  #
+###########
+
+class SeriesTypes(param.Parameterized):
+    series = param.Series(allow_None=False)
+    optional_series = param.Series(allow_None=True)
+
+stypes = SeriesTypes()
+assert_type(stypes.series, pandas.Series)
+assert_type(stypes.optional_series, pandas.Series | None)
+
+###########
+# Array   #
+###########
+
+class ArrayTypes(param.Parameterized):
+    array = param.Array(allow_None=False)
+    optional_array = param.Array(default=None)
+
+atypes = ArrayTypes()
+assert_type(atypes.array, np.ndarray)
+assert_type(atypes.optional_array, np.ndarray | None)
+
+##################
+# Callable Types #
+##################
+
+def _callback() -> int:
+    return 1
+
+class CallableTypes(param.Parameterized):
+    callable_param = param.Callable(default=_callback, allow_None=False)
+    optional_callable_param = param.Callable(default=None, allow_None=True)
+    action = param.Action(default=_callback, allow_None=False)
+    optional_action = param.Action(default=None, allow_None=True)
+
+catypes = CallableTypes()
+assert_type(catypes.callable_param, t.Callable[..., t.Any])
+assert_type(catypes.optional_callable_param, t.Callable[..., t.Any] | None)
+assert_type(catypes.action, t.Callable[[], t.Any])
+assert_type(catypes.optional_action, t.Callable[[], t.Any] | None)
+
+##################
+# Composite Type #
+##################
+
+class CompositeTypes(param.Parameterized):
+    value = param.Number(default=1)
+    comp = param.Composite(attribs=["value"])
+
+comptypes = CompositeTypes()
+assert_type(comptypes.comp, list[t.Any])
+
+##################
+# Selector Types #
+##################
+
+class SelectorTypes(param.Parameterized):
+    selector = param.Selector(objects=[1,2,3], allow_None=False)
+    optional_selector = param.Selector(objects=[1,2,3], allow_None=True)
+
+stypes = SelectorTypes()
+assert_type(stypes.selector, t.Any)
+assert_type(stypes.optional_selector, t.Any)
+
+class ObjectSelectorTypes(param.Parameterized):
+    object_selector = param.ObjectSelector(default=1, objects=[1, 2, 3], allow_None=False)
+    optional_object_selector = param.ObjectSelector(
+        default=None, objects=[1, 2, 3], allow_None=True
+    )
+
+ostypes = ObjectSelectorTypes()
+assert_type(ostypes.object_selector, t.Any)
+assert_type(ostypes.optional_object_selector, t.Any)
+
+class FileSelectorTypes(param.Parameterized):
+    file_selector = param.FileSelector(path="*")
+    list_selector = param.ListSelector(objects=["a", "b"], allow_None=True)
+    multi_file_selector = param.MultiFileSelector(path="*")
+
+fstypes = FileSelectorTypes()
+assert_type(fstypes.file_selector, t.Any)
+assert_type(fstypes.list_selector, t.Any)
+assert_type(fstypes.multi_file_selector, t.Any)
+
+##############
+# Path Types #
+##############
+
+class PathTypes(param.Parameterized):
+    path_param = param.Path(default=pathlib.Path("."), allow_None=False)
+    optional_path_param = param.Path(default=None, allow_None=True)
+    filename = param.Filename(default=pathlib.Path("type_tests.py"), allow_None=False)
+    optional_filename = param.Filename(default=None, allow_None=True)
+    foldername = param.Foldername(default=pathlib.Path("."), allow_None=False)
+    optional_foldername = param.Foldername(default=None, allow_None=True)
+
+ptypes = PathTypes()
+assert_type(ptypes.path_param, os.PathLike | str)
+assert_type(ptypes.optional_path_param, os.PathLike | str | None)
+assert_type(ptypes.filename, os.PathLike | str)
+assert_type(ptypes.optional_filename, os.PathLike | str | None)
+assert_type(ptypes.foldername, os.PathLike | str)
+assert_type(ptypes.optional_foldername, os.PathLike | str | None)
+
+##############
+# List Types #
+##############
+
+class HookListTypes(param.Parameterized):
+    hook_list = param.HookList(default=[], allow_None=False)
+    optional_hook_list = param.HookList(default=None, allow_None=True)
+
+hltypes = HookListTypes()
+assert_type(hltypes.hook_list, t.Any)
+assert_type(hltypes.optional_hook_list, t.Any)
+
+#####################
+# String-like Types #
+#####################
+
+class ColorAndBytesTypes(param.Parameterized):
+    color = param.Color(allow_None=False)
+    optional_color = param.Color(allow_None=True)
+    bytes_param = param.Bytes(allow_None=False)
+    optional_bytes_param = param.Bytes(allow_None=True)
+
+cbtypes = ColorAndBytesTypes()
+assert_type(cbtypes.color, str)
+assert_type(cbtypes.optional_color, str | None)
+assert_type(cbtypes.bytes_param, bytes)
+assert_type(cbtypes.optional_bytes_param, bytes | None)

param-2.4.0rc2/tests/pyrightconfig-bare.json

@@ -0,0 +1 @@
+{}

{param-2.4.0rc0 → param-2.4.0rc2}/tests/testpickle.py

@@ -5,7 +5,8 @@ import pytest
 
 try:
     import cloudpickle
-except ModuleNotFoundError:
+except (AttributeError, ModuleNotFoundError):
+    # Not installed or PyPy on Windows
     cloudpickle = None
 try:
     import numpy as np