param 2.4.0rc3__tar.gz → 2.4.1__tar.gz

{param-2.4.0rc3 → param-2.4.1}/.gitignore

@@ -26,7 +26,7 @@ doc/reference/param/generated
 .coverage
 coverage.xml
 
-# Versionning
+# Versioning
 param/_version.py
 
 # asv benchmark

{param-2.4.0rc3 → param-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: param
-Version: 2.4.0rc3
+Version: 2.4.1
 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.0rc3 → param-2.4.1}/numbergen/__init__.py

@@ -244,21 +244,21 @@ class Hash:
         """Convert the given value to a rational, if necessary."""
         I32 = 4294967296 # Maximum 32 bit unsigned int (i.e. 'I') value
         if isinstance(val, int):
-            numer, denom = val, 1
+            numerator, denominator = val, 1
         elif isinstance(val, fractions.Fraction):
-            numer, denom = val.numerator, val.denominator
+            numerator, denominator = val.numerator, val.denominator
         elif hasattr(val, 'numerator') and hasattr(val, 'denominator'):
             # gmpy2 mpq objects have these attributes
-            numer, denom = val.numerator, val.denominator
-        elif hasattr(val, 'numer'):
+            numerator, denominator = val.numerator, val.denominator
+        elif hasattr(val, 'numer'): # typos: ignore
             # I think this branch supports gmpy (i.e. not gmpy2)
-            (numer, denom) = (int(val.numer()), int(val.denom()))
+            (numerator, denominator) = (int(val.numer()), int(val.denom()))  # typos: ignore
         else:
             param.main.param.log(param.WARNING, "Casting type '%s' to Fraction.fraction"
                                % type(val).__name__)
             frac = fractions.Fraction(str(val))
-            numer, denom = frac.numerator, frac.denominator
-        return numer % I32, denom % I32
+            numerator, denominator = frac.numerator, frac.denominator
+        return numerator % I32, denominator % I32
 
     def __getstate__(self):
         """Avoid Hashlib.md5 TypeError in deepcopy (hashlib issue)."""
@@ -279,7 +279,7 @@ class Hash:
         Given integer or rational inputs, generate a cross-platform,
         architecture-independent 32-bit integer hash.
         """
-        # Convert inputs to (numer, denom) pairs with integers
+        # Convert inputs to (numerator, denominator) pairs with integers
         # becoming (int, 1) pairs to match gmpy2.mpqs for int values.
         pairs = [self._rational(val) for val in vals]
         # Unpack pairs and fill struct with ints to update md5 hash

{param-2.4.0rc3 → param-2.4.1}/param/_utils.py

@@ -15,6 +15,8 @@ from textwrap import dedent
 from threading import get_ident
 
 if t.TYPE_CHECKING:
+    import asyncio
+
     from param.parameterized import Parameter
 
     _P = t.ParamSpec("_P")
@@ -604,7 +606,7 @@ def _in_ipython():
     except NameError:
         return False
 
-_running_tasks = set()
+_running_tasks: set[asyncio.Task] = set()
 
 def async_executor(func):
     import asyncio

{param-2.4.0rc3 → param-2.4.1}/param/_version.py

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

{param-2.4.0rc3 → param-2.4.1}/param/ipython.py

@@ -58,7 +58,7 @@ class ParamPager:
 
     def get_param_info(self, obj, include_super=True):
         """
-        Get the parameter dictionary, the list of modifed parameters
+        Get the parameter dictionary, the list of modified parameters
         and the dictionary of parameter values. If include_super is
         True, parameters are also collected from the super classes.
         """

param-2.4.1/param/mypy_plugin.py

@@ -0,0 +1,95 @@
+"""Mypy plugin for param.
+
+Works around mypy issue #9758: metaclass __setattr__ is not consulted
+for class-level assignment to descriptor attributes. Without this plugin,
+``MyClass.flag = True`` on a Boolean parameter raises:
+
+    Incompatible types in assignment
+    (expression has type "bool", variable has type "Boolean[bool]")
+
+The fix: intercept class-attribute access via get_class_attribute_hook and,
+when it's an lvalue, return the Parameter's value type (the first type arg
+of Parameter[_T]) instead of the raw descriptor type.
+
+Usage: add ``plugins = ["param.mypy_plugin"]`` to your mypy configuration.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from mypy.nodes import TypeInfo, Var
+from mypy.plugin import AttributeContext, Plugin
+from mypy.types import AnyType, Instance, Type, TypeOfAny, get_proper_type
+
+
+def _is_parameter_type(typ: Type) -> bool:
+    proper = get_proper_type(typ)
+    if not isinstance(proper, Instance):
+        return False
+    return any(
+        base.fullname == "param.parameterized.Parameter"
+        for base in proper.type.mro
+    )
+
+
+def _is_parameterized_class(info: TypeInfo) -> bool:
+    return any(
+        base.fullname == "param.parameterized.Parameterized"
+        for base in info.mro
+    )
+
+
+def _find_attr_in_mro(info: TypeInfo, name: str) -> Var | None:
+    for base in info.mro:
+        sym = base.names.get(name)
+        if sym is not None and isinstance(sym.node, Var):
+            return sym.node
+    return None
+
+
+def _class_attribute_hook(ctx: AttributeContext) -> Type:
+    if not ctx.is_lvalue:
+        return ctx.default_attr_type
+
+    default_type = get_proper_type(ctx.default_attr_type)
+    if not isinstance(default_type, Instance):
+        return ctx.default_attr_type
+
+    if not _is_parameter_type(default_type):
+        return ctx.default_attr_type
+
+    if default_type.args:
+        return default_type.args[0]
+
+    return AnyType(TypeOfAny.special_form)
+
+
+class _ParamPlugin(Plugin):
+    def get_class_attribute_hook(
+        self, fullname: str
+    ) -> t.Callable[[AttributeContext], Type] | None:
+        parts = fullname.rsplit(".", 1)
+        if len(parts) != 2:
+            return None
+        class_fullname, attr_name = parts
+
+        sym = self.lookup_fully_qualified(class_fullname)
+        if sym is None or not isinstance(sym.node, TypeInfo):
+            return None
+
+        info = sym.node
+        if not _is_parameterized_class(info):
+            return None
+
+        var = _find_attr_in_mro(info, attr_name)
+        if var is None or var.type is None:
+            return None
+        if not _is_parameter_type(var.type):
+            return None
+
+        return _class_attribute_hook
+
+
+def plugin(version: str) -> type[Plugin]:
+    return _ParamPlugin

{param-2.4.0rc3 → param-2.4.1}/param/parameterized.py

@@ -190,7 +190,7 @@ object_count = 0
 warning_count = 0
 
 # Hook to apply to depends and bind arguments to turn them into valid parameters
-_reference_transforms = []
+_reference_transforms: list[t.Callable[[t.Any], t.Any]] = []
 
 def register_reference_transform(transform):
     """
@@ -1189,7 +1189,7 @@ class ParameterMetaclass(type):
             return type.__getattribute__(mcs, name)
 
 
-_UDPATE_PARAMETER_SIGNATURE = _in_ipython() or (os.getenv("PARAM_PARAMETER_SIGNATURE", "false").lower() in ("1" , "true"))
+_UPDATE_PARAMETER_SIGNATURE = _in_ipython() or (os.getenv("PARAM_PARAMETER_SIGNATURE", "false").lower() in ("1" , "true"))
 _PARAMETER_CACHE_ATTRS = ('instantiate', 'constant', 'default_factory')
 
 
@@ -1208,7 +1208,7 @@ class _ParameterBase(metaclass=ParameterMetaclass):
     @classmethod
     def __init_subclass__(cls):
         super().__init_subclass__()
-        if not _UDPATE_PARAMETER_SIGNATURE:
+        if not _UPDATE_PARAMETER_SIGNATURE:
             return
         # _update_signature has been tested against the Parameters available
         # in Param, we don't want to break the Parameters created elsewhere
@@ -1442,7 +1442,7 @@ class Parameter(_ParameterBase, t.Generic[_T]):
     if t.TYPE_CHECKING:
         @t.overload
         def __init__(
-            self,
+            self: Parameter[t.Any],
             default: t.Any = ...,
             *,
             doc: str | None = None,
@@ -1462,7 +1462,7 @@ class Parameter(_ParameterBase, t.Generic[_T]):
 
         @t.overload
         def __init__(
-            self,
+            self: Parameter[t.Any],
             default: t.Any | None = ...,
             *,
             allow_None: t.Literal[True] = True,
@@ -2323,7 +2323,7 @@ class Comparator:
     """
     Comparator defines methods for determining whether two objects
     should be considered equal. It works by registering custom
-    comparison functions, which may either be registed by type or with
+    comparison functions, which may either be registered by type or with
     a predicate function. If no matching comparison can be found for
     the two objects the comparison will return False.
 
@@ -2761,7 +2761,7 @@ class Parameters:
                     except Skip:
                         pass
         finally:
-            # Ensure we clean up but only if the task matches the currrent task
+            # Ensure we clean up but only if the task matches the current task
             if self_.self._param__private.async_refs.get(pname) is current_task:
                 del self_.self._param__private.async_refs[pname]
 
@@ -3377,7 +3377,7 @@ class Parameters:
 
         Additionally, sets ``_Dynamic_time_fn=time_fn`` on this class or
         instance object, so that any future changes to Dynamic
-        Parmeters can inherit ``time_fn`` (e.g. if a :class:`param.Number` is changed
+        Parameters can inherit ``time_fn`` (e.g. if a :class:`param.Number` is changed
         from a float to a number generator, the number generator will
         inherit ``time_fn``).
 
@@ -4659,7 +4659,7 @@ class Parameters:
         parameters = self.param.objects('existing')
         ordering = sorted(
             sorted(changed_params), # alphanumeric tie-breaker
-            key=lambda k: (- float('inf')  # No precedence is lowest possible precendence
+            key=lambda k: (- float('inf')  # No precedence is lowest possible precedence
                            if parameters[k].precedence is None else
                            parameters[k].precedence))
 
@@ -4693,7 +4693,7 @@ class Parameters:
                 arglist.append(value)
             elif k in kwargs or (spec.varkw is not None):
                 # Explicit modified keywords or parameters in
-                # precendence order (if **kwargs present)
+                # precedence order (if **kwargs present)
                 keywords.append(f'{k}={value}')
 
             processed.append(k)
@@ -5121,7 +5121,7 @@ class ParameterizedMetaclass(type):
                         f'made it invalid. Please fix the Parameter type.'
                     )
                 else:
-                    # type_change and slot_overriden is not possible as when
+                    # type_change and slot_overridden is not possible as when
                     # the type changes checking the slots is aborted for
                     # performance reasons.
                     pass
@@ -5512,7 +5512,7 @@ class _ClassPrivate:
     disable_instance_params: bool
         Whether to disable instance parameters
     renamed: bool
-        Whethe the class has been renamed by a super class
+        Whether the class has been renamed by a super class
     params: dict
         Dict of parameter_name:parameter.
     """
@@ -5873,7 +5873,7 @@ class Parameterized(metaclass=ParameterizedMetaclass):
                 explicit_no_refs=type(self)._param__private.explicit_no_refs
             )
         # Skip generating a custom instance name when a class in the hierarchy
-        # has overriden the default of the `name` Parameter.
+        # has overridden the default of the `name` Parameter.
         if self.param.name.default == self.__class__.__name__:
             self.param._generate_name()
         refs, deps = self.param._setup_params(**params)

{param-2.4.0rc3 → param-2.4.1}/param/parameters.py

@@ -60,6 +60,8 @@ from ._utils import (
 #-----------------------------------------------------------------------------
 
 if t.TYPE_CHECKING:
+    from types import NoneType
+
     import numpy as np
     import pandas as pd
 
@@ -150,7 +152,7 @@ def param_union(*parameterizeds: Parameterized, warn: bool = True) -> dict[str,
     Parameters
     ----------
     warn : bool, optional
-        Wether to warn if the same parameter have been given multiple values,
+        Whether to warn if the same parameter have been given multiple values,
         otherwise use the last value, by default True
 
     Returns
@@ -3175,7 +3177,7 @@ class ClassSelector(SelectorBase[_T]):
             # This will clobber separate classes with identical names.
             # Known historical issue, see https://github.com/holoviz/param/pull/1035
             all_classes.update({c.__name__: c for c in desc})
-        d = OrderedDict((name, class_) for name,class_ in all_classes.items())
+        d: dict[str, type | NoneType] = OrderedDict((name, class_) for name,class_ in all_classes.items())
         if self.allow_None:
             d['None'] = None
         return d
@@ -3608,7 +3610,7 @@ class List(Parameter[_T]):
             self: List[list[LT]],
             default: list[LT] = [],
             *,
-            item_type: type[LT] | tuple[type[LT], ...] = (),
+            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,
@@ -3632,7 +3634,7 @@ class List(Parameter[_T]):
             self: List[list[LT] | None],
             default: list[LT] | None = None,
             *,
-            item_type: type[LT] | tuple[type[LT], ...] = (),
+            item_type: type[LT] | tuple[type[LT], ...],
             allow_None: t.Literal[True] = True,
             **kwargs: Unpack[_ParameterKwargs]
         ) -> None:
@@ -3640,21 +3642,21 @@ class List(Parameter[_T]):
 
         @t.overload
         def __init__(
-            self: List[list[t.Any] | None],
-            default: list[t.Any] | None = None,
+            self: List[list[t.Any]],
+            default: list[t.Any] = [],
             *,
-            allow_None: t.Literal[True] = True,
+            item_type: None = None,
+            allow_None: t.Literal[False] = False,
             **kwargs: Unpack[_ParameterKwargs]
         ) -> None:
             ...
 
         @t.overload
         def __init__(
-            self: List[list[t.Any]],
-            default: list[t.Any] = [],
+            self: List[list[t.Any] | None],
+            default: list[t.Any] | None = None,
             *,
-            item_type: None = None,
-            allow_None: t.Literal[False] = False,
+            allow_None: t.Literal[True] = True,
             **kwargs: Unpack[_ParameterKwargs]
         ) -> None:
             ...

{param-2.4.0rc3 → param-2.4.1}/param/version.py

@@ -162,7 +162,7 @@ class Version:
 
     @property
     def dirty(self):
-        """True if there are uncommited changes, False otherwise."""
+        """True if there are uncommitted changes, False otherwise."""
         return self.fetch()._dirty
 
 
@@ -644,7 +644,7 @@ class OldDeprecatedVersion:
 
     @property
     def dirty(self):
-        """True if there are uncommited changes, False otherwise."""
+        """True if there are uncommitted changes, False otherwise."""
         return self.fetch()._dirty
 
 

{param-2.4.0rc3 → param-2.4.1}/pyproject.toml

@@ -120,7 +120,7 @@ asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope="function"
 
 [tool.coverage.report]
-omit = ["param/version.py", "tests/testimports.py"]
+omit = ["param/version.py", "param/mypy_plugin.py", "tests/testimports.py"]
 
 [tool.ruff]
 fix = true
@@ -184,7 +184,7 @@ infer-with-first-use = false
 
 [tool.mypy]
 files = ["param"]
-follow_imports = "skip"
+plugins = ["param.mypy_plugin"]
 disable_error_code = ["import-untyped", "import-not-found"]
 
 [tool.pyright]
@@ -201,3 +201,21 @@ ignore = [
     "**/node_modules",
     "**/.git",
 ]
+
+[tool.typos.default]
+extend-ignore-re = [
+    ".*(?:#|--|//|/*).*(?:typos):\\s?ignore[^\\n]*\\n",
+    ".*(?:typos):\\s?ignore-next-line[^\\n]*\\n[^\\n]*",
+]
+
+[tool.typos.default.extend-words]
+arange = "arange"
+ba = "ba"
+iy = "iy"
+lod = "lod"
+nd = "nd"
+numbre = "numbre" # used as a spelling mistake in upgrade_guide.md
+pn = "pn"
+ser = "ser"
+spreaded = "spreaded"
+writeable = "writeable"

{param-2.4.0rc3 → param-2.4.1}/tests/assert_types.py

@@ -211,11 +211,11 @@ class DateTypes(param.Parameterized):
     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)
+datetypes = DateTypes()
+assert_type(datetypes.date_param, datetime | date)
+assert_type(datetypes.optional_date_param, datetime | date | None)
+assert_type(datetypes.calendar_date_param, date)
+assert_type(datetypes.optional_calendar_date_param, date | None)
 
 class DateRangeTypes(param.Parameterized):
     date_range = param.DateRange(
@@ -253,8 +253,8 @@ 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)
+    selector_base = param.SelectorBase(default=1, allow_None=False)  # type: ignore[var-annotated]
+    optional_selector_base = param.SelectorBase(default=None, allow_None=True)  # type: ignore[var-annotated]
 
 sbtypes = SelectorBaseTypes()
 assert_type(sbtypes.selector_base, t.Any)
@@ -272,9 +272,9 @@ class TypeTypes(param.Parameterized):
         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)
+typtypes = TypeTypes()
+assert_type(typtypes.type_param, type[Foo])
+assert_type(typtypes.optional_type_param, type[Foo] | None)
 
 
 ##############
@@ -299,9 +299,9 @@ 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)
+sertypes = SeriesTypes()
+assert_type(sertypes.series, pandas.Series)
+assert_type(sertypes.optional_series, pandas.Series | None)
 
 ###########
 # Array   #
@@ -350,12 +350,12 @@ assert_type(comptypes.comp, list[t.Any])
 ##################
 
 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)
+    selector = param.Selector(objects=[1,2,3], allow_None=False)  # type: ignore[var-annotated]
+    optional_selector = param.Selector(objects=[1,2,3], allow_None=True)  # type: ignore[var-annotated]
 
-stypes = SelectorTypes()
-assert_type(stypes.selector, t.Any)
-assert_type(stypes.optional_selector, t.Any)
+seltypes = SelectorTypes()
+assert_type(seltypes.selector, t.Any)
+assert_type(seltypes.optional_selector, t.Any)
 
 class ObjectSelectorTypes(param.Parameterized):
     object_selector = param.ObjectSelector(default=1, objects=[1, 2, 3], allow_None=False)
@@ -389,13 +389,13 @@ class PathTypes(param.Parameterized):
     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)
+pathtypes = PathTypes()
+assert_type(pathtypes.path_param, os.PathLike | str)
+assert_type(pathtypes.optional_path_param, os.PathLike | str | None)
+assert_type(pathtypes.filename, os.PathLike | str)
+assert_type(pathtypes.optional_filename, os.PathLike | str | None)
+assert_type(pathtypes.foldername, os.PathLike | str)
+assert_type(pathtypes.optional_foldername, os.PathLike | str | None)
 
 ##############
 # List Types #

{param-2.4.0rc3 → param-2.4.1}/tests/testdefaultfactory.py

@@ -282,7 +282,7 @@ def test_default_factory_object_auto_name():
 
     def factory(cls, self, parameter):
         if self:
-            # When the class value is overriden.
+            # When the class value is overridden.
             if parameter and getattr(cls, parameter.name) != cls.__name__:
                 return getattr(cls, parameter.name)
             else:

{param-2.4.0rc3 → param-2.4.1}/tests/testfiledeserialization.py

@@ -29,7 +29,7 @@ except ModuleNotFoundError:
     xlsxm = None
 
 try:
-    import odf as ods
+    import odf as ods  # typos: ignore
 except ModuleNotFoundError:
     ods = None
 

{param-2.4.0rc3 → param-2.4.1}/tests/testparameterizedobject.py

@@ -132,7 +132,7 @@ class TestParameterized(unittest.TestCase):
         with pytest.raises(AttributeError):
             testpo.param.const.name = 'notconst'
 
-    def test_name_overriden(self):
+    def test_name_overridden(self):
         class P(param.Parameterized):
             name = param.String(default='other')
 
@@ -142,7 +142,7 @@ class TestParameterized(unittest.TestCase):
 
         assert p.name == 'other'
 
-    def test_name_overriden_without_default(self):
+    def test_name_overridden_without_default(self):
         class A(param.Parameterized):
             pass
         class B(param.Parameterized):
@@ -156,7 +156,7 @@ class TestParameterized(unittest.TestCase):
         assert C.name == 'C'
         assert C.param.name.doc == 'some help'
 
-    def test_name_overriden_constructor(self):
+    def test_name_overridden_constructor(self):
         class P(param.Parameterized):
             name = param.String(default='other')
 
@@ -164,7 +164,7 @@ class TestParameterized(unittest.TestCase):
 
         assert p.name == 'another'
 
-    def test_name_overriden_subclasses(self):
+    def test_name_overridden_subclasses(self):
         class P(param.Parameterized):
             name = param.String(default='other')
 
@@ -195,7 +195,7 @@ class TestParameterized(unittest.TestCase):
         assert r2.name == 'last'
 
 
-    def test_name_overriden_subclasses_name_set(self):
+    def test_name_overridden_subclasses_name_set(self):
         class P(param.Parameterized):
             name = param.String(default='other')
 
@@ -214,7 +214,7 @@ class TestParameterized(unittest.TestCase):
 
         assert q.name == 'yetanother'
 
-    def test_name_overriden_error_not_String(self):
+    def test_name_overridden_error_not_String(self):
 
         msg = "Parameterized class 'P' cannot override the 'name' Parameter " \
               "with type <class 'str'>. Overriding 'name' is only allowed with " \
@@ -247,7 +247,7 @@ class TestParameterized(unittest.TestCase):
         assert C.name == 'C'
         assert D.name == 'D'
 
-    def test_name_overriden_complex_hierarchy(self):
+    def test_name_overridden_complex_hierarchy(self):
         class Mixin1: pass
         class Mixin2: pass
         class Mixin3(param.Parameterized): pass
@@ -266,7 +266,7 @@ class TestParameterized(unittest.TestCase):
         assert C.name == 'another'
         assert D.name == 'another'
 
-    def test_name_overriden_multiple(self):
+    def test_name_overridden_multiple(self):
         class A(param.Parameterized):
             name = param.String(default='AA')
         class B(param.Parameterized):
@@ -1409,7 +1409,7 @@ def test_inheritance_constant_behavior():
     assert b.param.p.constant is True
 
 
-def test_inheritance_set_Parameter_instantiate_constant_before_instantation():
+def test_inheritance_set_Parameter_instantiate_constant_before_instantiation():
     # https://github.com/holoviz/param/issues/760
     class A(param.Parameterized):
         p0 = param.Parameter()

{param-2.4.0rc3 → param-2.4.1}/tests/testparameterizedrepr.py

@@ -218,7 +218,7 @@ def test_script_repr_parameterized_other():
     assert param.script_repr('2') == "\n\n'2'"
 
 
-def test_pprint_signature_overriden():
+def test_pprint_signature_overridden():
     # https://github.com/holoviz/param/issues/785
 
     class P(param.Parameterized):

{param-2.4.0rc3 → param-2.4.1}/tests/testpathparam.py

@@ -133,7 +133,7 @@ class TestPathParameters(unittest.TestCase):
 
         # Inheritance isn't working great with search_paths and this test
         # isn't designed to be run from the tmpdir directory.
-        startd = os.getcwd()
+        start_dir = os.getcwd()
         try:
             # a = param.Path()
             # b = param.Path(self.fb)
@@ -162,7 +162,7 @@ class TestPathParameters(unittest.TestCase):
             with pytest.raises(OSError, match='Path a.txt was not found'):
                 assert b.c is None
         finally:
-            os.chdir(startd)
+            os.chdir(start_dir)
 
     def test_notfound_instantiation_raises_error(self):
         with pytest.raises(

{param-2.4.0rc3 → param-2.4.1}/tests/testreactive.py

@@ -557,9 +557,9 @@ def test_reactive_clone_reevaluates(inputs: list[str], op: Callable[[rx], Any],
     assert transformed.rx.value == expecteds[0]
     assert fcalls == 1
 
-    for prev_fcalls, (inpt, expec) in enumerate(zip(inputs[1:], expecteds[1:]), start=fcalls):
-        base.rx.value = inpt
-        assert transformed.rx.value == expec
+    for prev_fcalls, (input, expect) in enumerate(zip(inputs[1:], expecteds[1:]), start=fcalls):
+        base.rx.value = input
+        assert transformed.rx.value == expect
         assert fcalls == (prev_fcalls + 1)
 
 @pytest.mark.parametrize('lazy', [False, True])

{param-2.4.0rc3 → param-2.4.1}/tests/testsignatures.py

@@ -50,10 +50,10 @@ def test_signature_parameters_constructors_overloaded_updated_match():
         init_overloads = typing.get_overloads(p_type.__init__)
         if not init_overloads:
             continue
-        usig = inspect.signature(p_type)
+        sig = inspect.signature(p_type)
         if any(
             parameter.kind in (inspect.Parameter.VAR_KEYWORD, inspect.Parameter.VAR_POSITIONAL)
-            for parameter in usig.parameters.values()
+            for parameter in sig.parameters.values()
         ):
             # Classes that still expose a variadic runtime signature cannot be
             # compared reliably to overload declarations.
@@ -68,7 +68,7 @@ def test_signature_parameters_constructors_overloaded_updated_match():
                     and parameter.kind not in (inspect.Parameter.VAR_KEYWORD, inspect.Parameter.VAR_POSITIONAL)
                 ]
             )
-            if _is_overload_compatible(osig, usig):
+            if _is_overload_compatible(osig, sig):
                 compatible = True
                 break
         assert compatible, _

{param-2.4.0rc3 → param-2.4.1}/tests/testwatch.py

@@ -576,7 +576,7 @@ class TestWatch(unittest.TestCase):
         assert len(store) == 2
 
         p.x = 30
-        # Watcher not triggerd on instance update
+        # Watcher not triggered on instance update
         assert len(store) == 2
 
     def test_param_watch_multiple_instances(self):