Constantly: Symbolic Constants

23.10.4 · active · verified Thu Apr 09

constantly is a Python library providing symbolic constants, particularly useful for creating enumerated types and immutable values that are easily comparable by identity. It is maintained by the Twisted project, with releases appearing periodically. The current version is 23.10.4.

Warnings

breaking Python 3.7 support was dropped in `constantly` version 23.10.0.
Fix: Ensure your environment uses Python 3.8 or newer. If you need Python 3.7 support, pin `constantly<23.10.0`.
gotcha NamedConstants defined within a `Values` class are singletons. Prefer identity comparison (`is`) over value comparison (`==`) for correctness, especially when comparing against other objects or similar strings.
Fix: Always use `constant_a is constant_b` for comparing two `NamedConstant` instances. While `==` works for comparing a `NamedConstant` to its string name, `is` ensures you're comparing the exact symbolic object.
gotcha Attempting to modify the `name` or `value` attributes of a `Constant` or `NamedConstant` after definition will result in an `AttributeError`, as they are designed to be immutable.
Fix: Constants are immutable by design. Define them once and treat them as fixed values throughout your application.

Install

pip install constantly Install latest version

Imports

Constant
```
from constantly import Constant
```
For simple, standalone symbolic constants.
NamedConstant
```
from constantly import NamedConstant
```
Used as attributes within a Values class for enumerated types.
Values
```
from constantly import Values
```
A base class to group NamedConstants into an enumerable type.

Quickstart

This example demonstrates how to define a set of named constants using `Values` and `NamedConstant`, and how to access and compare them. `NamedConstant` instances within a `Values` class are singletons.

from constantly import NamedConstant, Values

class Fruit(Values):
    apple = NamedConstant()
    banana = NamedConstant()
    orange = NamedConstant()

# Accessing constants
print(f"Apple constant: {Fruit.apple}")
print(f"Apple name: {Fruit.apple.name}")
print(f"Apple value: {Fruit.apple.value}")

# Comparing constants by identity (preferred)
print(f"Is Fruit.apple the same object as Fruit.apple? {Fruit.apple is Fruit.apple}")
print(f"Is Fruit.apple the same object as Fruit.banana? {Fruit.apple is Fruit.banana}")

# Iterating over constants in the class
print("All fruits:")
for fruit in Fruit.iterconstants():
    print(f"- {fruit.name}")

view raw JSON →