backcall is a Python module designed to create backwards-compatible callback APIs. It enables developers to add new parameters to API calls without breaking existing third-party callback functions that may not be aware of these new parameters. The library is currently at version 0.2.0, last released on June 9, 2020, and appears to be in a maintenance state with infrequent updates.
pip install backcallVerified import paths — ran on the pinned version, not inferred.
To use `backcall`, define a 'callback prototype' function using the `@callback_prototype` decorator. This prototype's signature specifies all parameters that your API might pass. Then, use the `prototype.adapt(callback)` method to inspect and potentially wrap user-provided callback functions. If a callback takes fewer arguments than the prototype, `adapt` creates a wrapper that discards the extra arguments. If a callback takes *more* arguments than the prototype, `adapt` will raise a `TypeError`.
Ensure that any callback function you pass to `prototype.adapt()` has a signature that is a subset of or exactly matches the prototype's signature. Remove any extra parameters from the callback that are not present in the prototype.
If using a compiled function, wrap it in a standard Python `def` function to expose an introspectable signature to `backcall`.
Factor in the project's maintenance status when planning long-term dependencies or if requiring new features/bug fixes. Consider vendoring the code if deep customization or active support becomes critical.
Ensure the callback function's signature *exactly* matches the prototype's signature, or explicitly provide values for all parameters defined in the prototype when calling the adapted function, even for those with default values in the prototype that are not present in the callback's signature. Alternatively, consider adjusting the prototype's signature to align more closely with the callback's needs.
Ensure that the callback function being adapted takes fewer or the same number of arguments as the `callback_prototype`. If the callback requires additional arguments, they must be optional (with default values) in the prototype, or the callback's signature needs to be adjusted.
```python
from backcall import callback_prototype
@callback_prototype
def my_prototype(arg1, arg2=None): # Prototype can take arg1 and optional arg2
pass
def my_callback_correct(arg1):
print(f"Callback received: {arg1}")
def my_callback_wrong(arg1, arg2, arg3): # This callback expects too many arguments
print(f"Callback received: {arg1}, {arg2}, {arg3}")
# Correct usage
adapted_callback = my_prototype.adapt(my_callback_correct)
adapted_callback("hello", 123) # arg2 is discarded by adapter
# Incorrect usage (will raise TypeError)
# adapted_callback_error = my_prototype.adapt(my_callback_wrong)
# adapted_callback_error("a", "b", "c")
```Install the `backcall` library using pip. If it's already installed, ensure you are running your script with the Python interpreter where `backcall` was installed, or that your IDE is configured to use the correct environment. ```bash pip install backcall ```
Verify the spelling of `callback_prototype` and ensure it's exactly as defined in the library. If the spelling is correct, try reinstalling `backcall` to resolve potential corruption issues, or check for Python environment conflicts. ```python # Ensure correct import statement from backcall import callback_prototype # If reinstalling is needed # pip uninstall backcall # pip install backcall ```
No dependency data recorded yet.