This patch release fixes a cluster of bugs in async rx pipelines (stale value propagation, cancellation leaks, branching, invalidation finalizers, and an unhandled exception in async operations), plus a memory leak on short-lived reactive pipelines, a thread-safety issue in the Parameter init cache, and a List item_type validation bug rejecting subclasses with a custom metaclass.

Many thanks to @philippjfr, @hoxbro, @maximlt, @s-t-e-v-e-n-k and @Coderambling for their contributions to this release.

🐛 Bug Fixes

• Fix memory leak on short-lived reactive pipelines (#1156)
• Fix List item_type validation rejecting subclasses with a custom metaclass (#1166)
• Switch to os.path.commonpath to fix FileSelector path abbreviation splitting on partial path components (#1165)
• Fix thread-unsafe init cache rebuild and unmask errors (#1171)
• Stop rx from propagating a stale value while an async node is awaiting (#1173)
• Fix rx invalidation finalizer keeping its own node alive (#1174)
• Fix superseded async references escaping cancellation (#1175)
• Fix branching off an async rx node (#1178)
• Fix an unhandled exception in an async rx operation (#1179)
• Fix async_executor leaking an event loop per call and leaking cancellations (#1180)

📚 Documentation

• A few minor text optimizations in Typing.ipynb (#1161)

🧪 Tests & CI

• Bump pyrefly compat to 1.1.0 (#1157)
• Run type CI in parallel (#1158)
• Fix feather serialization tests (#1168)
• Ignore python 3.10 for feather test (#1169)
• Update CI action versions (#1170)
• Ignore gmpy2 on Windows for now (#1172)

This patch release adds a mypy plugin to handle the descriptor __set__ type narrowing issue, reorders param.List overloads to allow default type inference, and fixes the conda build.

Many thanks to @philippjfr and @hoxbro for their contributions to this release.

🚀 Features

• Add mypy plugin to handle descriptor __set__ issue (#1148)

🐛 Bug Fixes

• Reorder param.List overloads to allow default type inference (#1149)

🏗️ Build

• Fix conda build (b7bcd74)

📚 Documentation

• Add instructions about basedpyright to Typing docs (#1151)

🧹 Maintenance

• Fix spelling mistakes and add typos to pre-commit (#1152)
• Bump TY version (#1150)

Full Changelog

Param 2.4.0 brings first-class static typing support to the entire Param ecosystem — all major parameter types now carry precise type information that flows through to your IDE and type checker, with types inferred directly from your existing parameter declarations. The release also adds a lazy mode to reactive expressions (rx) and includes performance optimizations that speed up parameter initialization in large class hierarchies.

Many thanks to @philippjfr, @hoxbro and @camriddell for their contributions to this release.

🚀 Features

• Implement descriptor factory typing system by implementing Parameter generics (Parameter[_T]) and add typed overloads for all major Parameter subclasses and add typing for public APIs (#1066, #1112, #1130, #1131, #1132, #1134, #1136, #1137, #1141)
• Add py.typed PEP 561 marker so type checkers automatically recognize Param's inline annotations without requiring separate stubs (#1066)
• Add rx(..., lazy=) argument (#1106)

⚡ Performance

• Add caches to speed up Parameter initialization (#1124)
• Optimize Parameter instantiation (#1122)
• Implement custom __copy__ for Parameter to speed up instance Parameter creation (#1128)

🐛 Bug Fixes

• Use re.search for param.String regex check (#1142)

📚 Documentation

• Add Typing user guide (#1139)

🧪 Tests & CI

• Add tests/assert_types.py with assert_type() assertions verified in CI (#1066)
• Add CI jobs for mypy, pyright, pyrefly, and ty (#1066, #1140)
• Add zizmor for GitHub Actions security scanning (#1143)

This patch release fixes an issue where rx pipelines with shared provenance would not use a shared cache, resulting in unnecessary re-evaluation of shared inputs.

Fixes:

• Ensure shared rx inputs are reused (#1117)

Full Changelog

This patch release fixes a regression introduced in Parameterized by adding a docstring to its __init__ method, shadowing user-defined class docstrings displayed in IDEs like VSCode.

Fixes:

• Remove Parameterized __init__ docstring as it shadows class user docstrings (#1104)

Compatibility / Tests:

• Pandas 3 test suite compatibility (#1107)

Full Changelog

This patch release fixes a regression introduced in the param.parameterized.edit_constant context manager.

Fixes:

• Fix edit_constant to prevent class value mutation when not constant

Full Changelog

This minor release brings a number of new features, enhancements, bug fixes, and documentation improvements. Notably, it introduces the new Parameter attributes default_factory and metadata, and the ParameterizedABC class to declare Parameterized abstract base classes. All the docstrings have been improved thanks to a massive effort from @MarcSkovMadsen. Several deprecated APIs have now been removed, and the minimum supported Python version has been bumped to 3.10. Many thanks to our new contributors @Azaya89, @Coderambling, and @ypsah, as well as to @MarcSkovMadsen, @hoxbro, @maximlt, @philippjfr, and all others for their continued maintenance and development efforts.

Features:

• Add a default_factory attribute to the base Parameter (#1092)
• Add a metadata attribute to the base Parameter (#1094)
• Allow declaring Parameterized abstract base classes by inheriting from ParameterizedABC => This approach should be favored over __abstract = True (#1031)
• Add .rx.set() method (#957)

Enhancements:

• Add missing docstrings and enhance existing ones (#992, #994, #997, #998)
• Better error when calling len() on a reactive expression (#1033)
• Raise AttributeError when attempting to set the value attribute of a reactive expression (#1022)
• Add an is_instance attribute to the List Parameter (#1023)
• Allow depends(..., on_init=True) to be applied to async method (#1067)
• Add concrete keyword to the descendents function => Prefer concrete(<cls>, descendents=True) over concrete_descendents(<cls>) (#1027)

Performance Enhancements:

• Improve import time by lazy importing "slow" modules (#1037)
• Only update Parameter signatures when needed (#1038)

Bug Fixes:

• Fix calling descendents on an object() instance (#1024)
• Ensure edit_constant resets class and instance level parameters (#1015)
• Ensure constant attribute is inherited (#1017)
• Ensure type checkers skip ParameterizedFunction.__init__ (#1039)
• Fix .values()/get_value_generator() dealing with Dynamic params and an updated default value (#1058)
• Do not remove nested_refs when updating another ref (#1061)
• Fix error message of ReactiveESMMetaClass (#1064)
• Fix reactive_ops.__call__ (#1069)
• unwatch no longer logs a warning and idempotent behavior clarified (#1018)
• Remove bad abstract declaration on SelectorBase (#1086)
• Do not override refs when parameter is triggered (#1089)

Documentation:

• Add a new page that lists deprecated and removed APIs (#1016)
• Add a version switcher (#1079)
• Small refactor and fixes to the API reference (#1082)
• README and landing page updates (#1095)
• Various minor fixes and improvements (#1006, #1034, #1036, #1049, #1052, #1054)

Breaking changes:

• Direct removal of the undocumented and broken print_all_param_defaults function (#1029)
• API removals that emitted a deprecation warning since 2.0.0, all included in the table below (#1085)

Warning	Description
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	Parameter slots / List._class: use instead item_type
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	Parameter slots / Number.set_hook: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.__init__ module / param.produce_value: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.__init__ module / param.as_unicode: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.__init__ module / param.is_ordered_dict: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.__init__ module / param.hashable: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.__init__ module / param.named_objs: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.__init__ module / param.normalize_path: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.__init__ module / param.abbreviate_paths: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.parameterized module / param.parameterized.all_equal: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.parameterized module / param.parameterized.add_metaclass: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.parameterized module / param.parameterized.batch_watch: use instead batch_call_watchers
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.parameterized module / param.parameterized.recursive_repr: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0	param.parameterized module / param.parameterized.overridable_property: no replacement
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.set_default: use instead for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param._add_parameter: use instead .param.add_parameter
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.params: use instead .param.values() or .param['param']
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.set_param: use instead .param.update
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.get_param_values: use instead .param.values().items() (or .param.values() for the common case of dict(....param.get_param_values()))
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.params_depended_on: use instead .param.method_dependencies
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.defaults: use instead {k:v.default for k,v in p.param.objects().items()}
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.print_param_defaults: use instead for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.print_param_values: use instead for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.message: use instead .param.log(param.MESSAGE, ...)
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.verbose: use instead .param.log(param.VERBOSE, ...)
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.0.0, soft-deprecated since 1.12.0	Parameterized .param namespace / .param.debug: use instead .param.log(param.DEBUG, ...)
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.1.0, ParamPendingDeprecationWarning since 2.0.0	Instantiating most parameters with positional arguments beyond default is deprecated
ParamFutureWarning since 2.2.0, ParamDeprecationWarning since 2.1.0, ParamPendingDeprecationWarning since 2.0.0	For Selector parameters that accept objects as first positional argument, and ClassSelector parameters that accept class_ as first positional argument, passing any argument by position is deprecated.

Deprecations:

• Deprecate setting a parameter value before full instance initialization (#1025)
• Deprecate the keyword what of .param.watch_values() (#1073)
• Deprecate the generic Parameter attribute pickle_default_value (#1019)
• Deprecate the module version.py (#1002)
• Deprecate Selector's compute_default_fn slot and compute_default() method (#1012)

Compatibility:

• Drop gmpy support in favor of gmpy2 (#1026)
• Ensure support for Python 3.14 (#1077)
• Bump the minimum Python version to 3.10 (#1084)
• Ensure support for PyPy 3.11 and stop testing PyPy 3.10 (#1080)

Internal:

• Introduce _find_stack_level() utility to emit warnings with the right stack level (#1083)

Infrastructure / Tests:

• Add sysmon for coverage (#1009)
• Small updates to the build infrastructure (#1008)
• Modify workflow to exclude forks (#1020)
• Update pre-commit (#1078)
• Make the generator tests more robust (#1080, #1088)

Governance:

• Add @maximlt (#1075)

Contributor Experience:

• Enhance developer experience with the setup-dev command (#1081)

Full Changelog

This patch release contains a bug fix for nested references. Thanks to @philippjfr for their contribution.

Bug Fixes:

• Do not remove nested_refs when updating another ref (#1061)

Full Changelog

This minor release brings a few enhancements and bugfixes. Importantly, it includes some breaking changes, removing deprecated APIs or raising errors during unsafe operations which would previously only emit warnings. Many thanks to @gandhis1 and @JRRudy1 for their first contributions, and to @hoxbro, @maximlt,and @MarcSkovMadsen for their continued maintenance and development efforts.

Enhancements:

• Annotate depends and accept_arguments decorators (#962)
• Stop directly importing numpy and add gen_types decorator (#966)

Bug Fixes:

• Added missing super().__init_subclass__ call in _ParameterBase.__init_subclass__ (#969)
• Remove _dict_update (#980)

Documentation:

• Improve some docstrings and set up ruff to validate them (#977, #982, and #983)

Breaking changes / Deprecations:

• Remove _param_watchers, raise RuntimeError on unsafe ops during init, and failed validation of a parameter default after inheritance (#973)
• Promote many deprecation warnings to future warnings (#974)

Compatibility:

• Test Python 3.13 (#971)
• Drop Python 3.8 support (#986)

Infrastructure / Tests:

• Replace hatch with pixi (#971)
• Fix reactive tests failing intermittently on Windows (#971, #967)
• Change linting to ruff (#978)

Full Changelog

This minor release contains bug fixes for reactive expressions and a few minor documentation improvements. Thanks to @jrycw for their first contribution! And to @ahuang11, @maximlt, and @philippjfr for their continued maintenance and development efforts.

Bug fixes:

• Ensure rx._callback resolves accessors (#949)
• Ensure refs can be updated by watcher of the same parameter (#929)
• Recursively resolve references on args and kwargs passed to a reactive operation (#944)
• Only override the name of a Parameterized instance on Parameter instantiation when instantiate=True (#938)

Documentation:

• Various minor documentation improvements (#933, #935, #941, #947)

Maintenance:

• Fix test_reactive_logic_unary_ops on Python 3.12 (#946)

Full Changelog

This minor release focuses on improving reactive expressions and support for asynchronous (and synchronous) generators. Many thanks to @maximlt, @Hoxbro and @philippjfr for their continued maintenance and development efforts.

Enhancements

• Improvements for synchronous and asychronous generators (#908)
• Additions to the .rx namespace including and_, bool, map, not_, or_ and updating (#906)
• Add support for adding asynchronous watcher to rx (#917)
• Make it possible to resolve reactive expressions recursively with .rx.resolve (#918)
• Add support for async and generator functions in .rx.pipe (#924)

Bug fixes

• Ensure that .param.update context manager restore refs (#915)
• Avoid overeager root invalidation on rx leading to unnecessary evaluation (#919)

Deprecations

• Passing positional arguments to Parameter now raises a ParamDeprecationWarning (#921)

This patch release fixes a few bugs and introduces a performance enhancement. Many thanks to @alfredocarella for their first contribution, and to the maintainers @maximlt and @philippjfr for contributing to this release.

Optimization:

• Minor optimizations in hot codepaths accessing class parameters (#893)

Bug fixes:

• Unpack partial callables in iscoroutinefunction (#894)
• Fix building Param with setuptools-scm<7 (#903)

Documentation:

• Replace Google Analytics with GoatCounter (#895)
• Fix a typo in Outputs.ipynb (#892)

Full Changelog

This minor release fixes a number of bugs, including a regression introduced by the replacement of the build backend (setuptools for hatchling) which led to the doc folder being wrongly packaged. Many thanks to @SultanOrazbayev for their first contribution, to @musicinmybrain for spotting the regression and submitting fixes, and to the maintainers @Hoxbro, @jbednar and @maximlt for contributing to this release.

Bug fixes:

• Do not install doc folder in site-packages (#878)
• Drop the feather-format test dependency (#879)
• Add tables to the tests-deser extra (#880)
• Fix _state_push and _state_pop (#884)
• version.py: new process should not create a window on Windows (#882, #886)
• Don't import setuptools_scm if the .git folder doesn't exist (#885)

Documentation:

• Add migration guide to Param 2.0 (#883)
• Update Parameter API reference (#881)

Full Changelog

20 years after its creation, Param has reached version 2.0! Can you guess when Param 3.0 will be released?

Param 2.0 is a major new release available for Python 3.8 and above, significantly streamlining, simplifying, and improving the Param API. Many long-supported but also long-obsolete functions, methods, and usages will now warn loudly so that you can make sure your code is only using the fully supported and safe current approaches. Because upgrading to Param 2 is likely to reveal compatibility issues with older codebases, new releases in the 1.x series are expected to continue for some time, focused on compatibility with the ecosystem rather than adding new features. Thus you can keep using Param 1.x with your older code, but Param 2 is the future!

We would like to thank @minimav for their first contribution, and @droumis, @Hoxbro, @jbednar, @maximlt, @philippjfr and @sdrobert for their contributions. We would also like to thank @ceball, who made the first plans for Param 2.0 quite a few years ago, and we are glad to be delivering on them at last!

Major enhancements and features

• Parameter slot values are now all inherited correctly across a hierarchy of Parameterized classes, making their behavior much clearer and more consistent. Let's say we have class B being a subclass of A, itself being a subclass of param.Parameterized. If A defines x = Number(1, bounds=(0, 10)) and B defines x = Number(2), B.param['x'].bounds is now going to be inherited from A and equal to (0, 10) as you would expect. Parameterized classes have always supported inheritance, but the previous mechanism was based on using None to indicate which values should be inherited, which was highly problematic because None was also a valid value for many slots. All Parameter slot signatures now default to the new Undefined sentinel, finally allowing None to be inherited where appropriate. (#605, #771, #791, #874)
• The objects slot of a Selector was previously highly confusing, because it accepted either a dictionary or a list for initialization but then was accessible only as a list, making it difficult to watch or update the objects. There is now a ListProxy wrapper around Selector.objects (with forward and backward compatibility) to easily update objects and watch objects updates (#598, #825)
• Parameterized classes and instances now have a rich HTML representation that is displayed automatically in a Jupyter/IPython notebook. For a class or instance p, just return p.param in a notebook cell to see a table of all the Parameters of the class/instance, their state, type, and range, plus the docstring on hover. It is likely we will improve the content and design of this repr based on feedback, so please let us know what you think! (#425, #781, #821, #831)
• Parameters have all gained the allow_refs and nested_refs attributes, bringing an exceptionally useful feature that was available in Panel since version 1.2 to Param. Declaring a Parameter with allow_refs=True (False by default) allows setting this Parameter value with a reference to automatically mirror the value of the reference. Supported references include class/instance Parameter objects, functions/methods decorated with param.depends, reactive functions and expressions, asynchronous generators and custom objects transformed into a valid reference with a hook registered with param.parameterized.register_reference_transform. nested_refs indicate whether references should be resolved even when they are nested inside a container (#843, #845, #849, #865, #862, #876)
• Experimental new rx reactive expressions: Param is widely used for building web apps in the HoloViz ecosystem, where packages have added various mechanisms for dynamic updates (e.g. pn.bind and pn.depends in Panel, and .interactive in hvPlot). These mechanisms were already built on Param and can be used far more widely than just in those packages, so that functionality has now been generalized, streamlined, and moved into Param. Nearly any Python expression can now be made reactive with param.rx(), at which point it will collect and be able to replay any operations (e.g. method calls) performed on them. This reactive programming approach lets you take just about any existing Python workflow and replace attributes with widgets or other reactive values, creating an app with fine-grained user control without having to design callbacks, event handlers, or any other complex logic! rx support is still experimental while we get feedback about the API, packaging, and documentation, but it's fully ready to try out and give us suggestions! (#460, #842, #841, #844, #846, #847, #850, #851, #856, #860, #854, #859, #858, #873)

Enhancements

• Parameter slot values that are set to mutable containers (e.g. Selector(objects=a_list)) will now be shallow-copied on instantiation, so that the container is no longer confusingly shared between the class and its subclasses and instances (#826)
• To further clean up the Parameterized namespace (first started in version 1.7.0), the remaining private attributes haven been collected under two private namespaces _param__private and _param__parameters (#766, #790)
• You can now use .param.update as a context manager for applying temporary updates (#779)
• The name Parameter has always had special behavior dating to its use in labeling objects in a GUI context, but this behavior is now able to be overriden at the class and instance level (#740)
• Improved Parameter signatures for static and dynamic code analysis (#742)
• Removed inferred Parameterized docstring signature and add basic __signature__ support (#802)
• For speed, only generate the Parameter docstring in an IPython context (#774)
• Improve Parameter validation error messages (#808)
• Support for deserialization of file types into Array and DataFrame (#482)
• Integer now accepts numpy.integer values (#735)
• Range now does stricter validation of the slot values (#725, #824)
• Path now has check_exists attribute, leading it to raise an error if path is not found on parameter instantiation (#800)
• Add top-level __all__ and move Parameter classes to parameters.py (#853)

Bug fixes

• Allow type change for DateRange and Date (#733)
• Ensure class watchers are not inherited by instance parameter (#833)
• Fix multi-level indirection in Parameters access (#840)
• Ensure non-function types are not resolved as empty function declarations (#753)
• Fix watchers support when the Parameterized instance is falsy (#769)
• Fix depending on the method of a sub-parameter object (#765)
• Raise an error on bad non-watched references (#777)
• Ensure that the root dependency can be resolved, and error otherwise (#813)
• Fix basic pickling (#783, #792)
• Validate that self is present in the __init__ signature of a Parameterized class (#786)
• No longer force instantiate to True when constant is True (#776)
• Instantiate default Parameter values based on all the Parameters available (#798)
• Array: fix param.pprint (#795)
• Array: don't hard-code allow_None to True (#726)
• Boolean: validate the default type (#722)
• FileSelector: made more consistent with Selector by defaulting to the first globbed path (#801)
• FileSelector: ensure path separators are consistent on Windows (#805)
• Path: raise a ValueError if set to None while not allowed (#799)
• Selector: populate objects when check_on_set is False and default is not in objects (#794, #817)
• File/MultiFileSelector: updating path updates objects (#814)

Documentation

• Build the site with sphinx directly and refactor the API reference (#810)
• Update to the latest version of pydata-sphinx-theme (#752)
• Update to Google Analytics 4 (#758)
• Fix minor errors in the Getting Started (#787)
• Add OpenCollective sponsor link on the repository page (#811)

Infrastructure

• Increase the test suite coverage (#716, #717, #719, #720, #739, #775, #778)
• Turn warnings into exceptions in the test suite (#738)
• Add notebook smoke tests (#750)
• Upgrades to leverage hatch, pyproject.toml and pre-commit (#749, #772)
• Add basic benchmark suite using asv (#788)
• Reduce the number of tested Python versions (#732)
• Run the tests with Python 3.12 (#863)

Compatibility

• Drop support for Python 2.7, 3.6, and 3.7 and upgrade the code base accordingly (#741, #784)

Breaking changes

• While it's a major improvement to the definition of Parameters, properly inheriting Parameter slots can result in some Parameter slot values being different in Param 2, because Param 1 was sometimes silently not inheriting slot values.
• User-defined Parameter classes should be updated to use Undefined as the formal default for any new slots, with the actual default defined on the new _slot_defaults dictionary. Otherwise, any new slot will fail to support inheritance, even if it was set to None, which would previously support inheritance.
• Parameterized methods that were deprecated since Param 1.7.0 have finally been removed. These are now mostly available on the .param namespace (#592)
• No longer supports setting non-Parameter class attributes during initialization, and no longer warns when setting non-Parameter class attributes directly (#729)
• instance.param.watchers no longer returns the transient dict of watchers but instead returns the instance watchers, as the now deprecated instance._param_watchers (#797)
• Removed deprecated Parameterized.pprint, Parameterized._pprint, Parameterized.script_repr, ParameterizedFunction.script_repr (#767)
• Removed Time.next method needed only for Param 2, and moved Parameterized.state_pop and Parameterized.state_push to the .param namespace (#767)
• Some removals were considered harmless and thus implemented immediately without a deprecation period:
  • Removed unused bounds slot from Boolean and Event (#744, #755)
  • Removed private Parameter _internal_name slot (#796)

Deprecations

This section lists functionality that is expected to be removed sometime in the next couple of 2.x releases, so if you use Param 2, please take care of these warnings as soon as you encounter them, and certainly before you upgrade to the next release!

Param 2.0 adds a validation step of the default value of a Parameter after the inheritance mechanism has completed if its type has changed (e.g. x in class A is a Number and in class B(A) is an Integer) or one of its slot values has changed (#812, #820, #857). We have decided to only emit a warning when this validation fails to make your life easier when upgrading your code from Param 1 to 2, as the validation is performed on class creation which means that any validation error breaks importing your code. You should definitely take care of these warnings, they indicate a Parameter is in an invalid state!

We continue to clean up Param's API (#734, #751, #768, #797, #834, #838) but have decided to do it in a gentle way, emitting deprecation warnings for a period of time before proceeding with removals. You will find below the complete list of deprecation warnings added in Param 2.0.

• Parameter signature:
  • Instantiating most parameters with positional arguments beyond default is deprecated:
    • String('prefix-test', '^prefix'): deprecated!
    • String('prefix-test', regex='^prefix'): OK
    • String(default='prefix-test', regex='^prefix'): OK
  • For Selector parameters that accept objects as first positional argument, and ClassSelector parameters that accept class_ as first positional argument, passing any argument by position is deprecated:
    • Selector([1, 2]): deprecated!
    • Selector(objects=[1, 2]): OK
    • ClassSelector((str, int)): deprecated!
    • ClassSelector(class_=(str, int)): OK
    • It's possible that in the future the signature of these two parameters will be aligned with the other parameters to accept default as first and only positional argument, but for now please use an explicit keyword so that your code will be compatible with all versions.
• Parameter slots:
  • List._class: use instead item_type.
  • Number.set_hook: no replacement
• param.__init__ module:
  • param.produce_value: no replacement
  • param.as_unicode: no replacement
  • param.is_ordered_dict: no replacement
  • param.is_ordered_dict: no replacement
  • param.hashable: no replacement
  • param.named_objs: no replacement
  • param.normalize_path: no replacement
  • param.abbreviate_paths: no replacement
• param.parameterized module:
  • param.parameterized.all_equal: no replacement
  • param.parameterized.add_metaclass: no replacement
  • param.parameterized.batch_watch: use instead batch_call_watchers
  • param.parameterized.recursive_repr: no replacement
  • param.parameterized.overridable_property: no replacement
• Parameterized .param namespace; many of these methods have been deprecated since version 1.12.0, however, this was just announced in the release notes and we realised many users missed them, sometimes even us included! They now all emit deprecation warnings when executed and are clearly marked as deprecated in the API reference:
  • .param.set_default: use instead for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")
  • .param._add_parameter: use instead .param.add_parameter
  • .param.params: use instead .param.values() or .param['param']
  • .param.set_param: use instead .param.update
  • .param.get_param_values: use instead .param.values().items() (or .param.values() for the common case of dict(....param.get_param_values()))
  • .param.params_depended_on: use instead .param.method_dependencies
  • .param.defaults: use instead {k:v.default for k,v in p.param.objects().items()}
  • .param.print_param_defaults: use instead for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")
  • .param.print_param_values: use instead for k,v in p.param.objects().items(): print(f"{p.__class__.name}.{k}={repr(v.default)}")
  • .param.message: use instead .param.log(param.MESSAGE, ...)
  • .param.verbose: use instead .param.log(param.VERBOSE, ...)
  • .param.debug: use instead .param.log(param.DEBUG, ...)
• Running unsafe operations during Parameterized instance initialization, instead run these operations after having called super().__init__(**params):
  • instance.param.objects(instance=True)
  • instance.param.trigger("<param_name>")
  • instance.param.watch(callback, "<param_name>")
• Parameterized namespace:
  • instance._param_watchers (getter and setter): use instead the property inst.param.watchers

Full Changelog