Utilities for working with inspect.Signature objects

4.0.1 · active · verified Thu Apr 09

sigtools is a Python package that enhances introspection capabilities for determining function signatures, especially when decorators modify them. It provides utilities for boosting callable signature introspection, backports keyword-only parameters for older Python versions (though current versions are Python 3+), and tools for combining functions while preserving correct signatures. The current version is 4.0.1, with releases occurring periodically to maintain compatibility and add features.

Warnings

breaking Sigtools versions 4.0.0 and above officially require Python 3.6 or newer. Older versions offered Python 2 compatibility or backports, but this support has been removed.
Fix: Ensure your project runs on Python 3.6 or a more recent version. If Python 2 compatibility is essential, you may need to use an older `sigtools` version (e.g., <2.0) at your own risk, but this is not recommended due to Python 2's end-of-life.
gotcha When `sigtools` decorators (like `@signature`, `@specifiers.forwards_to`, `@modifiers.kwoargs`) are applied to a callable, the standard `inspect.signature` will often *not* reflect the modified or intended effective signature. Always use `sigtools.signature` for accurate introspection of callables managed by `sigtools`.
Fix: Replace `inspect.signature(your_callable)` with `sigtools.signature(your_callable)` to retrieve the signature that `sigtools` has established for the function.
gotcha Combining functions with `sigtools.wrappers` or managing argument forwarding with `sigtools.specifiers` can introduce complexity in understanding how arguments are mapped or interpreted. Misunderstanding these mechanisms can lead to unexpected `TypeError` or `AttributeError` exceptions.
Fix: Carefully review the `sigtools` documentation, particularly sections on `sigtools.wrappers` and 'Picking the appropriate arguments for forwards'. Use `sigtools.signature` frequently during development to verify the resulting signature of combined or modified callables.

Install

pip install sigtools Install stable version

Imports

signature
```
from sigtools import signature
```
When using `sigtools` decorators or features, `inspect.signature` may not reflect the *effective* signature of the callable. Always use `sigtools.signature` to get the correct signature managed by `sigtools`.
specifiers
```
from sigtools import specifiers
```
wrappers
```
from sigtools import wrappers
```
modifiers
```
from sigtools import modifiers
```

Quickstart

This example demonstrates how to use `sigtools.signature` to introspect a function and how the `@signature` decorator can be used to explicitly set a function's introspectable signature, making `wrapped_func` appear with the same signature as `original_func`.

from sigtools import signature

def original_func(a, b):
    pass

@signature(original_func)
def wrapped_func(c, d):
    # This function's signature is now effectively (a, b) due to @signature(original_func)
    pass

print(f"Original signature: {signature(original_func)}")
print(f"Wrapped signature: {signature(wrapped_func)}")

view raw JSON →