Param

2.3.3 · active · verified Sat Apr 11

Param is a zero-dependency Python library that enables the creation of classes with rich, declarative attributes (Parameter objects) for runtime validation, documentation, and serialization. It also provides a suite of expressive and composable APIs for reactive programming, allowing automatic updates on attribute changes and the declaration of complex reactive dependencies. Param is currently at version 2.3.3 and maintains a frequent release cadence with minor and patch updates.

Warnings

breaking Version 2.3.0 raised the minimum supported Python version to 3.10 and removed several previously deprecated APIs. Code running on older Python versions or relying on removed APIs will break.
Fix: Upgrade to Python 3.10+ and consult the changelog for specific API removals, updating your code accordingly. (e.g., https://github.com/holoviz/param/compare/v2.2.1...v2.3.0)
breaking Version 2.2.0 removed deprecated APIs and changed warnings for unsafe operations into errors. Code that previously received warnings but continued to function might now raise exceptions.
Fix: Review code for operations that previously emitted warnings from `param` and address them to avoid new errors. Consult the changelog for details on specific API removals and behavior changes. (e.g., https://github.com/holoviz/param/compare/v2.1.1...v2.2.0)
gotcha In version 2.3.2, the `Parameterized.__init__` docstring was removed because it shadowed user-defined class docstrings in IDEs like VSCode. While not breaking, developers relying on IDEs to show the `__init__` docstring might notice its absence.
Fix: No code fix is required, but be aware that IDEs will now display your class's own docstring for the `__init__` method, rather than a generic one from `param`.
gotcha Version 2.3.1 fixed a regression in the `param.parameterized.edit_constant` context manager, which previously allowed class value mutation even when not constant. Users relying on this unintended behavior might see a change in mutation prevention.
Fix: Ensure that `edit_constant` is used as intended to prevent mutation of constant parameters. If you were implicitly relying on the old, incorrect behavior, adjust your logic to respect the constant nature of parameters.

Install

pip install param Install latest version

Imports

param
```
import param
```
Commonly used for accessing parameter types and decorators directly.
Parameterized
```
from param import Parameterized
```
The base class for creating classes with declarative parameters.

Quickstart

This quickstart demonstrates defining a `Parameterized` class with `Integer`, `String`, and `Event` parameters. It shows how to bind a method (`save_user_to_db`) to react to changes in the `submit` parameter using the `@param.depends` decorator. Changing parameter values and triggering the event causes the dependent method to execute.

import param

class UserForm(param.Parameterized):
    age = param.Integer(bounds=(0, None), doc='User age')
    name = param.String(doc='User name')
    submit = param.Event()

    @param.depends('submit', watch=True)
    def save_user_to_db(self):
        print(f'Saving user to db: name={self.name}, age={self.age}')

user = UserForm(name='Alice', age=30)
print(f'Initial user name: {user.name}, age: {user.age}')
user.submit = True # Triggers save_user_to_db

user.name = 'Bob'
user.age = 25
user.submit = True # Triggers save_user_to_db with new values

view raw JSON →