Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-param for openSUSE:Factory checked in at 2026-06-28 21:07:19 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-param (Old) and /work/SRC/openSUSE:Factory/.python-param.new.11887 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-param" Sun Jun 28 21:07:19 2026 rev:38 rq:1362049 version:2.4.1 Changes: -------- --- /work/SRC/openSUSE:Factory/python-param/python-param.changes 2026-05-25 22:00:25.505904278 +0200 +++ /work/SRC/openSUSE:Factory/.python-param.new.11887/python-param.changes 2026-06-28 21:07:59.617024818 +0200 @@ -1,0 +2,8 @@ +Sat Jun 27 21:02:24 UTC 2026 - Dirk Müller <[email protected]> + +- update to 2.4.1: + * Add mypy plugin to handle descriptor __set__ issue + * Reorder param.List overloads to allow default type inference + * Fix spelling mistakes and add typos to pre-commit + +------------------------------------------------------------------- Old: ---- param-2.4.0.tar.gz New: ---- param-2.4.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-param.spec ++++++ --- /var/tmp/diff_new_pack.4dr4fJ/_old 2026-06-28 21:08:00.301047866 +0200 +++ /var/tmp/diff_new_pack.4dr4fJ/_new 2026-06-28 21:08:00.305048001 +0200 @@ -18,7 +18,7 @@ %{?sle15_python_module_pythons} Name: python-param -Version: 2.4.0 +Version: 2.4.1 Release: 0 Summary: Declarative Python programming using Parameters License: BSD-3-Clause ++++++ param-2.4.0.tar.gz -> param-2.4.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/.gitignore new/param-2.4.1/.gitignore --- old/param-2.4.0/.gitignore 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/.gitignore 2020-02-02 01:00:00.000000000 +0100 @@ -26,7 +26,7 @@ .coverage coverage.xml -# Versionning +# Versioning param/_version.py # asv benchmark diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/PKG-INFO new/param-2.4.1/PKG-INFO --- old/param-2.4.0/PKG-INFO 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/PKG-INFO 2020-02-02 01:00:00.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 2.4 Name: param -Version: 2.4.0 +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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/numbergen/__init__.py new/param-2.4.1/numbergen/__init__.py --- old/param-2.4.0/numbergen/__init__.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/numbergen/__init__.py 2020-02-02 01:00:00.000000000 +0100 @@ -244,21 +244,21 @@ """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 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/param/_utils.py new/param-2.4.1/param/_utils.py --- old/param-2.4.0/param/_utils.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/param/_utils.py 2020-02-02 01:00:00.000000000 +0100 @@ -15,6 +15,8 @@ from threading import get_ident if t.TYPE_CHECKING: + import asyncio + from param.parameterized import Parameter _P = t.ParamSpec("_P") @@ -604,7 +606,7 @@ except NameError: return False -_running_tasks = set() +_running_tasks: set[asyncio.Task] = set() def async_executor(func): import asyncio diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/param/_version.py new/param-2.4.1/param/_version.py --- old/param-2.4.0/param/_version.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/param/_version.py 2020-02-02 01:00:00.000000000 +0100 @@ -18,7 +18,7 @@ commit_id: str | None __commit_id__: str | None -__version__ = version = '2.4.0' -__version_tuple__ = version_tuple = (2, 4, 0) +__version__ = version = '2.4.1' +__version_tuple__ = version_tuple = (2, 4, 1) __commit_id__ = commit_id = None diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/param/ipython.py new/param-2.4.1/param/ipython.py --- old/param-2.4.0/param/ipython.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/param/ipython.py 2020-02-02 01:00:00.000000000 +0100 @@ -58,7 +58,7 @@ 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. """ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/param/mypy_plugin.py new/param-2.4.1/param/mypy_plugin.py --- old/param-2.4.0/param/mypy_plugin.py 1970-01-01 01:00:00.000000000 +0100 +++ new/param-2.4.1/param/mypy_plugin.py 2020-02-02 01:00:00.000000000 +0100 @@ -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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/param/parameterized.py new/param-2.4.1/param/parameterized.py --- old/param-2.4.0/param/parameterized.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/param/parameterized.py 2020-02-02 01:00:00.000000000 +0100 @@ -190,7 +190,7 @@ 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 @@ 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 @@ @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 @@ if t.TYPE_CHECKING: @t.overload def __init__( - self, + self: Parameter[t.Any], default: t.Any = ..., *, doc: str | None = None, @@ -1462,7 +1462,7 @@ @t.overload def __init__( - self, + self: Parameter[t.Any], default: t.Any | None = ..., *, allow_None: t.Literal[True] = True, @@ -2323,7 +2323,7 @@ """ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/param/parameters.py new/param-2.4.1/param/parameters.py --- old/param-2.4.0/param/parameters.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/param/parameters.py 2020-02-02 01:00:00.000000000 +0100 @@ -60,6 +60,8 @@ #----------------------------------------------------------------------------- if t.TYPE_CHECKING: + from types import NoneType + import numpy as np import pandas as pd @@ -150,7 +152,7 @@ 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 @@ # 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 @@ 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 @@ 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 @@ @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: ... diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/param/version.py new/param-2.4.1/param/version.py --- old/param-2.4.0/param/version.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/param/version.py 2020-02-02 01:00:00.000000000 +0100 @@ -162,7 +162,7 @@ @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 @@ @property def dirty(self): - """True if there are uncommited changes, False otherwise.""" + """True if there are uncommitted changes, False otherwise.""" return self.fetch()._dirty diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/pyproject.toml new/param-2.4.1/pyproject.toml --- old/param-2.4.0/pyproject.toml 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/pyproject.toml 2020-02-02 01:00:00.000000000 +0100 @@ -120,7 +120,7 @@ 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 @@ [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 @@ "**/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" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/assert_types.py new/param-2.4.1/tests/assert_types.py --- old/param-2.4.0/tests/assert_types.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/assert_types.py 2020-02-02 01:00:00.000000000 +0100 @@ -211,11 +211,11 @@ 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.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 @@ 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 @@ 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 @@ ################## 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 @@ 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 # diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testdefaultfactory.py new/param-2.4.1/tests/testdefaultfactory.py --- old/param-2.4.0/tests/testdefaultfactory.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testdefaultfactory.py 2020-02-02 01:00:00.000000000 +0100 @@ -282,7 +282,7 @@ 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: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testfiledeserialization.py new/param-2.4.1/tests/testfiledeserialization.py --- old/param-2.4.0/tests/testfiledeserialization.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testfiledeserialization.py 2020-02-02 01:00:00.000000000 +0100 @@ -29,7 +29,7 @@ xlsxm = None try: - import odf as ods + import odf as ods # typos: ignore except ModuleNotFoundError: ods = None diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testparameterizedobject.py new/param-2.4.1/tests/testparameterizedobject.py --- old/param-2.4.0/tests/testparameterizedobject.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testparameterizedobject.py 2020-02-02 01:00:00.000000000 +0100 @@ -132,7 +132,7 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testparameterizedrepr.py new/param-2.4.1/tests/testparameterizedrepr.py --- old/param-2.4.0/tests/testparameterizedrepr.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testparameterizedrepr.py 2020-02-02 01:00:00.000000000 +0100 @@ -218,7 +218,7 @@ 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): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testpathparam.py new/param-2.4.1/tests/testpathparam.py --- old/param-2.4.0/tests/testpathparam.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testpathparam.py 2020-02-02 01:00:00.000000000 +0100 @@ -133,7 +133,7 @@ # 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 @@ 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( diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testreactive.py new/param-2.4.1/tests/testreactive.py --- old/param-2.4.0/tests/testreactive.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testreactive.py 2020-02-02 01:00:00.000000000 +0100 @@ -557,9 +557,9 @@ 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]) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testsignatures.py new/param-2.4.1/tests/testsignatures.py --- old/param-2.4.0/tests/testsignatures.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testsignatures.py 2020-02-02 01:00:00.000000000 +0100 @@ -50,10 +50,10 @@ 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 @@ 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, _ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/param-2.4.0/tests/testwatch.py new/param-2.4.1/tests/testwatch.py --- old/param-2.4.0/tests/testwatch.py 2020-02-02 01:00:00.000000000 +0100 +++ new/param-2.4.1/tests/testwatch.py 2020-02-02 01:00:00.000000000 +0100 @@ -576,7 +576,7 @@ 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):
