API Reference¶

Classes¶

signified.Signal ¶

Bases: Variable[T]

Mutable state.

Signal stores a value and notifies observers when that value changes. The value property is read/write:

reading value returns the current plain value
assigning value updates the stored value and notifies observers if it changed

Parameters:

Name	Type	Description	Default
`value`	`HasValue[T]`	Value to wrap.	required

Example

>>> count = Signal(1)
>>> doubled = count * 2
>>> doubled.value
2
>>> count.value = 3
>>> doubled.value
6

value `property` `writable` ¶

value

The current value.

Getting this property returns the plain Python value, unwrapping any nested reactive. Setting it updates the stored value and notifies observers if the value changed.

at ¶

at(value)

Temporarily set the signal to a given value within a context.

Restores the previous value when the context exits, even if an exception is raised.

Parameters:

Name	Type	Description	Default
`value`	`T`	The temporary value to set.	required

Example

>>> s = Signal(1)
>>> with s.at(99):
...     print(s.value)
99
>>> s.value
1

signified.Computed ¶

Bases: Variable[T]

Reactive value derived from a computation.

Computed lazily re-runs its function and updates its value whenever a dependency changes. Dependencies are inferred automatically from which reactive values are read during evaluation.

In most cases Computed instances should be created implicitly by using overloaded operators or the computed decorator rather than directly using the Computed class.

Unlike Signal, Computed.value is read-only.

Parameters:

Name	Type	Description	Default
`f`	`Callable[[], T]`	Zero-argument function used to compute the current value.	required

Example

>>> count = Signal(2)
>>> squared = Computed(lambda: count.value ** 2)
>>> squared.value
4
>>> count.value = 5
>>> squared.value
25

value `property` ¶

value

Get the current value, recomputing lazily when stale.

invalidate ¶

invalidate()

Force a full recomputation on the next .value read.

Use this when a reactive attribute is replaced with a new object and the normal change-detection path may not pick up the change. Unlike a regular update, this always triggers re-evaluation regardless of whether dependencies appear unchanged.

Warning

This method is fragile and should be a last resort. Incorrect use can cause unnecessary recomputation or missed updates. Prefer assigning to .value whenever possible, as this triggers the standard change-detection path.

Example

>>> external = {"value": 1}
>>> c = Computed(lambda: external["value"])
>>> c.value
1
>>> external["value"] = 99  # mutation not tracked by reactivity
>>> c.value  # still cached
1
>>> c.invalidate()
>>> c.value
99

signified.Effect ¶

Run a function (for its side effects) and re-run it whenever its reactive dependencies change.

Any reactive value read inside fn — via .value or unref — is automatically tracked as a dependency. The function runs once immediately on construction, then again each time a dependency changes.

Warning

Dependencies are tracked dynamically on each run. Only values that are read on the branch executed in the last run are tracked.

This means that if a reactive value within the function is not read, then updates to that value will not trigger the effect.

For example: in Effect(lambda: x.value if y.value else z.value), if y.value was truthy then only x and y will be tracked.

The effect stays active as long as you hold a reference to this object. Call Effect.dispose to stop it explicitly.

Warning

The Effect instance must be assigned to a variable. If the result is discarded, it is immediately eligible for garbage collection and the effect will silently stop running:

Effect(lambda: print(s.value))   # GC'd immediately — never re-runs!
e = Effect(lambda: print(s.value))  # kept alive — runs on every change

Parameters:

Name	Type	Description	Default
`fn`	`Callable[[], None]`	Zero-argument callable run for its side effects.	required

Example

>>> seen = []
>>> s = Signal(1)
>>> e = Effect(lambda: seen.append(s.value))
>>> seen
[1]
>>> s.value = 2
>>> s.value = 3
>>> seen
[1, 2, 3]
>>> e.dispose()
>>> s.value = 99
>>> seen
[1, 2, 3]

dispose ¶

dispose()

Unsubscribe from all dependencies and stop the effect.

signified.Variable ¶

Bases: ABC, _ReactiveMixIn[T]

Abstract base class for reactive values.

Both Signal and Computed extend this class. You should use them directly.

Variable is only exposed for type hinting or subclassing purposes.

Reactive Namespace¶

The rx property on any reactive value exposes a namespace of additional operations — reactive equivalents of things Python's dunder protocol cannot return as reactive values (identity checks, containment, ternary, etc.):

Helper methods available under signal_or_computed.rx.

map ¶

map(fn)

Return a reactive value by applying fn to the source.

Parameters:

Name	Type	Description	Default
`fn`	`Callable[[T], R]`	Function used to transform the current source value.	required

Returns:

Type	Description
`Computed[R]`	A reactive value for `fn(source.value)`.

Example

>>> s = Signal(4)
>>> doubled = s.rx.map(lambda x: x * 2)
>>> doubled.value
8
>>> s.value = 5
>>> doubled.value
10

effect ¶

effect(fn)

Eagerly run fn for side effects whenever the source changes.

fn is called immediately on creation and again on every subsequent change — without requiring the caller to read .value.

This is a convenience wrapper around Effect. The source value is passed as the single argument to fn on each run. For effects that need to read multiple reactive values, use Effect directly.

The effect is active as long as the caller holds the returned Effect instance. Call Effect.dispose to stop it explicitly.

Parameters:

Name	Type	Description	Default
`fn`	`Callable[[T], None]`	Callback that receives the current source value on each change.	required

Returns:

Type	Description
`'Effect'`	An Effect instance whose lifetime controls the subscription.

Example

>>> seen = []
>>> s = Signal(1)
>>> e = s.rx.effect(seen.append)
>>> seen
[1]
>>> s.value = 2
>>> s.value = 3
>>> seen
[1, 2, 3]
>>> e.dispose()
>>> s.value = 99
>>> seen
[1, 2, 3]

peek ¶

peek(fn)

Run fn for side effects and pass through the original value.

fn only executes when the returned Computed is read, not on every upstream change. Intermediate values are skipped if the source changes multiple times between reads.

Warning

The returned Computed must be kept alive by the caller. Observers are held as weak references, so if nothing holds a strong reference to the returned value, it will be garbage-collected and fn will silently stop running.

fn fires on each explicit .value read — not on creation and not on upstream changes alone. If the returned object is garbage-collected before any .value read, fn never fires at all:

s.rx.peek(print)  # GC'd immediately — print never called

For eager side effects, use the effect method or Effect directly.

Parameters:

Name	Type	Description	Default
`fn`	`Callable[[T], Any]`	Side-effect callback that receives the current source value.	required

Returns:

Type	Description
`Computed[T]`	A reactive value that always equals `source.value`.

Example

>>> seen = []
>>> s = Signal(1)
>>> passthrough = s.rx.peek(lambda x: seen.append(x))
>>> passthrough.value
1
>>> s.value = 3
>>> passthrough.value
3
>>> seen
[1, 3]

len ¶

len()

Return a reactive value for len(source.value).

Returns:

Type	Description
`Computed[int]`	A reactive value for `len(source.value)`.

Example

>>> s = Signal([1, 2, 3])
>>> length = s.rx.len()
>>> length.value
3
>>> s.value = [10]
>>> length.value
1

is_ ¶

is_(other)

Return a reactive value for identity check source.value is other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	Value to compare against with identity semantics.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `source.value is other`.

Example

>>> marker = object()
>>> s = Signal(marker)
>>> result = s.rx.is_(marker)
>>> result.value
True
>>> s.value = object()
>>> result.value
False

is_not ¶

is_not(other)

Return a reactive value for identity check source.value is not other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	Value to compare against with identity semantics.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `source.value is not other`.

Example

>>> marker = object()
>>> s = Signal(marker)
>>> result = s.rx.is_not(marker)
>>> result.value
False
>>> s.value = object()
>>> result.value
True

in_ ¶

in_(container)

Return a reactive value for containment check source.value in container.

Parameters:

Name	Type	Description	Default
`container`	`Any`	Value checked for membership, e.g. list/string/set.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `source.value in container`.

Example

>>> needle = Signal("a")
>>> haystack = Signal("cat")
>>> result = needle.rx.in_(haystack)
>>> result.value
True
>>> needle.value = "z"
>>> result.value
False

contains ¶

contains(other)

Return a reactive value for whether other is in self._source.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to check for containment.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `other in source.value`.

Example

>>> s = Signal([1, 2, 3, 4])
>>> result = s.rx.contains(3)
>>> result.value
True
>>> s.value = [5, 6, 7, 8]
>>> result.value
False

eq ¶

eq(other)

Return a reactive value for whether source.value == other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	Value to compare against.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `source.value == other`.

Example

>>> s = Signal(10)
>>> result = s.rx.eq(10)
>>> result.value
True
>>> s.value = 25
>>> result.value
False

where ¶

where(a, b)

Return a reactive value for a if source is truthy, else b.

Parameters:

Name	Type	Description	Default
`a`	`HasValue[A]`	The value to return if source is truthy.	required
`b`	`HasValue[B]`	The value to return if source is falsy.	required

Returns:

Type	Description
`Computed[A \| B]`	A reactive value for `a if source.value else b`.

Example

>>> condition = Signal(True)
>>> result = condition.rx.where("Yes", "No")
>>> result.value
'Yes'
>>> condition.value = False
>>> result.value
'No'

as_bool ¶

as_bool()

Return a reactive value for the boolean value of self._source.

Note

__bool__ cannot be implemented to return a non-bool, so it is provided as a method.

Returns:

Type	Description
`Computed[bool]`	A reactive value for `bool(source.value)`.

Example

>>> s = Signal(1)
>>> result = s.rx.as_bool()
>>> result.value
True
>>> s.value = 0
>>> result.value
False

Magic Methods¶

Reactive values support Python's operator protocol. Arithmetic, comparison, subscript, and attribute-access operations all return reactive Computed values derived from their operands.

Methods for easily creating reactive values.

getattr ¶

__getattr__(name: Literal['value', '_value']) -> T

__getattr__(name: str) -> Computed[Any]

__getattr__(name)

Create a reactive value for retrieving an attribute from self.value.

Parameters:

Name	Type	Description	Default
`name`	`str`	The name of the attribute to access.	required

Returns:

Type	Description
`Union[T, Computed[Any]]`	A reactive value for the attribute access.

Raises:

Type	Description
`AttributeError`	If the attribute doesn't exist.

Note

Type inference is poor whenever __getattr__ is used.

Example

>>> class Person:
...     def __init__(self, name):
...         self.name = name
>>> s = Signal(Person("Alice"))
>>> result = s.name
>>> result.value
'Alice'
>>> s.value = Person("Bob")
>>> result.value
'Bob'

call ¶

__call__(*args, **kwargs)

Create a reactive value for calling self.value(*args, **kwargs).

Parameters:

Name	Type	Description	Default
`*args`	`P.args`	Positional arguments to pass to the callable value.	`()`
`**kwargs`	`P.kwargs`	Keyword arguments to pass to the callable value.	`{}`

Returns:

Type	Description
`Computed[R]`	A reactive value for the function call.

Raises:

Type	Description
`ValueError`	If the value is not callable.

Example

>>> class Person:
...     def __init__(self, name):
...         self.name = name
...     def greet(self):
...         return f"Hi, I'm {self.name}!"
>>> s = Signal(Person("Alice"))
>>> result = s.greet()
>>> result.value
"Hi, I'm Alice!"
>>> s.name = "Bob"
>>> result.value
"Hi, I'm Bob!"

abs ¶

__abs__() -> Computed[float]

__abs__() -> Computed[int]

__abs__() -> Computed[T]

__abs__()

Return a reactive value for the absolute value of self.

Returns:

Type	Description
`Computed[T] \| Computed[float] \| Computed[int]`	A reactive value for `abs(self.value)`.

Example

>>> s = Signal(-5)
>>> result = abs(s)
>>> result.value
5
>>> s.value = -10
>>> result.value
10

round ¶

__round__() -> Computed[int]

__round__(ndigits: None) -> Computed[int]

__round__(ndigits: int) -> Computed[int]

__round__() -> Computed[int]

__round__(ndigits: None) -> Computed[int]

__round__(ndigits: int) -> Computed[int]

__round__() -> Computed[int]

__round__(ndigits: None) -> Computed[int]

__round__(ndigits: int) -> Computed[float]

__round__(ndigits: int | None = None) -> Computed[int] | Computed[float]

__round__(ndigits=None)

Return a reactive value for the rounded value of self.

Parameters:

Name	Type	Description	Default
`ndigits`	`int \| None`	Number of decimal places to round to.	`None`

Returns:

Type	Description
`Computed[int] \| Computed[float]`	A reactive value for `round(self.value, ndigits)`.

Example

>>> s = Signal(3.14159)
>>> result = round(s, 2)
>>> result.value
3.14
>>> s.value = 2.71828
>>> result.value
2.72

ceil ¶

__ceil__()

Return a reactive value for the ceiling of self.

Returns:

Type	Description
`Computed[int]`	A reactive value for `math.ceil(self.value)`.

Example

>>> from math import ceil
>>> s = Signal(3.14)
>>> result = ceil(s)
>>> result.value
4
>>> s.value = 2.01
>>> result.value
3

floor ¶

__floor__()

Return a reactive value for the floor of self.

Returns:

Type	Description
`Computed[int]`	A reactive value for `math.floor(self.value)`.

Example

>>> from math import floor
>>> s = Signal(3.99)
>>> result = floor(s)
>>> result.value
3
>>> s.value = 4.01
>>> result.value
4

trunc ¶

__trunc__() -> Computed[int]

__trunc__() -> Computed[int]

__trunc__() -> Computed[int]

__trunc__() -> Computed[T]

__trunc__()

Return a reactive value for the truncated value of self.

Returns:

Type	Description
`Computed[T] \| Computed[int]`	A reactive value for `math.trunc(self.value)`.

Example

>>> from math import trunc
>>> s = Signal(3.99)
>>> result = trunc(s)
>>> result.value
3
>>> s.value = -4.01
>>> result.value
-4

neg ¶

__neg__() -> Computed[int]

__neg__() -> Computed[T]

__neg__()

Return a reactive value for the negation of self.

Returns:

Type	Description
`Computed[T] \| Computed[int]`	A reactive value for `-self.value`.

Example

>>> s = Signal(5)
>>> result = -s
>>> result.value
-5
>>> s.value = -3
>>> result.value
3

pos ¶

__pos__() -> Computed[int]

__pos__() -> Computed[T]

__pos__()

Return a reactive value for the positive of self.

Returns:

Type	Description
`Computed[T] \| Computed[int]`	A reactive value for `+self.value`.

Example

>>> s = Signal(-5)
>>> result = +s
>>> result.value
-5
>>> s.value = 3
>>> result.value
3

invert ¶

__invert__() -> Computed[int]

__invert__() -> Computed[T]

__invert__()

Return a reactive value for the bitwise inversion of self.

Returns:

Type	Description
`Computed[T] \| Computed[int]`	A reactive value for `~self.value`.

Example

>>> s = Signal(5)
>>> result = ~s
>>> result.value
-6
>>> s.value = -3
>>> result.value
2

add ¶

__add__(other: HasValue[int] | HasValue[float]) -> Computed[float]

__add__(other: HasValue[float]) -> Computed[float]

__add__(other: HasValue[Y]) -> Computed[R]

__add__(other: Any) -> Computed[Any]

__add__(other)

Return a reactive value for the sum of self and other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to add.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value + other.value`.

Example

>>> s = Signal(5)
>>> result = s + 3
>>> result.value
8
>>> s.value = 10
>>> result.value
13

radd ¶

__radd__(other: HasValue[int] | HasValue[float]) -> Computed[float]

__radd__(other: HasValue[_SupportsAdd[T, R]]) -> Computed[R]

__radd__(other: Any) -> Computed[Any]

__radd__(other)

Return a reactive value for the sum of self and other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to add.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value + other.value`.

Example

>>> s = Signal(5)
>>> result = 3 + s
>>> result.value
8
>>> s.value = 10
>>> result.value
13

sub ¶

__sub__(other)

Return a reactive value for the difference of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to subtract.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value - other.value`.

Example

>>> s = Signal(10)
>>> result = s - 3
>>> result.value
7
>>> s.value = 15
>>> result.value
12

rsub ¶

__rsub__(other)

Return a reactive value for the difference of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to subtract from.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `other.value - self.value`.

Example

>>> s = Signal(10)
>>> result = 15 - s
>>> result.value
5
>>> s.value = 15
>>> result.value
0

mul ¶

__mul__(other: HasValue[int]) -> Computed[str]

__mul__(other: HasValue[int]) -> Computed[list[V]]

__mul__(other: HasValue[Y]) -> Computed[T | Y]

__mul__(other)

Return a reactive value for the product of self and other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to multiply with.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value * other.value`.

Example

>>> s = Signal(4)
>>> result = s * 3
>>> result.value
12
>>> s.value = 5
>>> result.value
15

rmul ¶

__rmul__(other: HasValue[int]) -> Computed[str]

__rmul__(other: HasValue[int]) -> Computed[list[V]]

__rmul__(other: HasValue[Y]) -> Computed[T | Y]

__rmul__(other)

Return a reactive value for the product of self and other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to multiply with.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value * other.value`.

Example

>>> s = Signal(4)
>>> result = 3 * s
>>> result.value
12
>>> s.value = 5
>>> result.value
15

truediv ¶

__truediv__(other: HasValue[int]) -> Computed[float]

__truediv__(other: HasValue[float]) -> Computed[float]

__truediv__(other: HasValue[int]) -> Computed[float]

__truediv__(other: HasValue[float]) -> Computed[float]

__truediv__(other: HasValue[bool] | HasValue[int] | HasValue[float]) -> Computed[float]

__truediv__(other: HasValue[Y]) -> Computed[T | Y]

__truediv__(other)

Return a reactive value for self divided by other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to use as the divisor.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value / other.value`.

Example

>>> s = Signal(20)
>>> result = s / 4
>>> result.value
5.0
>>> s.value = 30
>>> result.value
7.5

rtruediv ¶

__rtruediv__(other: HasValue[int]) -> Computed[float]

__rtruediv__(other: HasValue[float]) -> Computed[float]

__rtruediv__(other: HasValue[int]) -> Computed[float]

__rtruediv__(other: HasValue[float]) -> Computed[float]

__rtruediv__(other: HasValue[bool] | HasValue[int] | HasValue[float]) -> Computed[float]

__rtruediv__(other: HasValue[Y]) -> Computed[T | Y]

__rtruediv__(other)

Return a reactive value for self divided by other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to use as the divisor.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value / other.value`.

Example

>>> s = Signal(2)
>>> result = 30 / s
>>> result.value
15.0
>>> s.value = 3
>>> result.value
10.0

floordiv ¶

__floordiv__(other: HasValue[bool] | HasValue[int]) -> Computed[int]

__floordiv__(other: HasValue[Y]) -> Computed[T | Y]

__floordiv__(other)

Return a reactive value for the floor division of self by other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to use as the divisor.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for self.value // other.value.

Example

>>> s = Signal(20)
>>> result = s // 3
>>> result.value
6
>>> s.value = 25
>>> result.value
8

rfloordiv ¶

__rfloordiv__(other: HasValue[bool] | HasValue[int]) -> Computed[int]

__rfloordiv__(other: HasValue[Y]) -> Computed[T | Y]

__rfloordiv__(other)

Return a reactive value for the floor division of other by self.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to use as the numerator.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `other.value // self.value`.

Example

>>> s = Signal(3)
>>> result = 10 // s
>>> result.value
3
>>> s.value = 4
>>> result.value
2

mod ¶

__mod__(other: HasValue[bool] | HasValue[int]) -> Computed[int]

__mod__(other: HasValue[Y]) -> Computed[T | Y]

__mod__(other)

Return a reactive value for self modulo other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The divisor.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value % other.value`.

Example

>>> s = Signal(17)
>>> result = s % 5
>>> result.value
2
>>> s.value = 23
>>> result.value
3

rmod ¶

__rmod__(other: HasValue[bool] | HasValue[int]) -> Computed[int]

__rmod__(other: HasValue[Y]) -> Computed[T | Y]

__rmod__(other)

Return a reactive value for other modulo self.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The dividend.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `other.value % self.value`.

Example

>>> s = Signal(3)
>>> result = 10 % s
>>> result.value
1
>>> s.value = 4
>>> result.value
2

pow ¶

__pow__(other: HasValue[bool] | HasValue[int]) -> Computed[int]

__pow__(other: HasValue[Y]) -> Computed[T | Y]

__pow__(other)

Return a reactive value for self raised to the power of other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The exponent.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value ** other.value`.

Example

>>> s = Signal(2)
>>> result = s ** 3
>>> result.value
8
>>> s.value = 3
>>> result.value
27

rpow ¶

__rpow__(other: HasValue[bool] | HasValue[int]) -> Computed[int]

__rpow__(other: HasValue[Y]) -> Computed[T | Y]

__rpow__(other)

Return a reactive value for self raised to the power of other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The base.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value ** other.value`.

Example

>>> s = Signal(2)
>>> result = 3 ** s
>>> result.value
9
>>> s.value = 3
>>> result.value
27

matmul ¶

__matmul__(other)

Return a reactive value for the matrix multiplication of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to multiply with.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value @ other.value`.

Example

>>> import numpy as np
>>> s = Signal(np.array([1, 2]))
>>> result = s @ np.array([[1, 2], [3, 4]])
>>> result.value
array([ 7, 10])
>>> s.value = np.array([2, 3])
>>> result.value
array([11, 16])

and ¶

__and__(other)

Return a reactive value for the bitwise AND of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to AND with.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value & other.value`.

Example

>>> s = Signal(True)
>>> result = s & False
>>> result.value
False
>>> s.value = True
>>> result.value
False

rand ¶

__rand__(other)

Return a reactive value for the bitwise AND of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to AND with.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value and other.value`.

Example

>>> s = Signal(True)
>>> result = False & s
>>> result.value
False
>>> s.value = True
>>> result.value
False

or ¶

__or__(other)

Return a reactive value for the bitwise OR of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to OR with.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value or other.value`.

Example

>>> s = Signal(False)
>>> result = s | True
>>> result.value
True
>>> s.value = True
>>> result.value
True

ror ¶

__ror__(other)

Return a reactive value for the bitwise OR of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to OR with.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value or other.value`.

Example

>>> s = Signal(False)
>>> result = True | s
>>> result.value
True
>>> s.value = True
>>> result.value
True

xor ¶

__xor__(other)

Return a reactive value for the bitwise XOR of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to XOR with.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value ^ other.value`.

Example

>>> s = Signal(True)
>>> result = s ^ False
>>> result.value
True
>>> s.value = False
>>> result.value
False

rxor ¶

__rxor__(other)

Return a reactive value for the bitwise XOR of self and other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The value to XOR with.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value ^ other.value`.

Example

>>> s = Signal(True)
>>> result = False ^ s
>>> result.value
True
>>> s.value = False
>>> result.value
False

lshift ¶

__lshift__(other)

Return a reactive value for self left-shifted by other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The number of positions to shift.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value << other.value`.

Example

>>> s = Signal(8)
>>> result = s << 2
>>> result.value
32
>>> s.value = 3
>>> result.value
12

rshift ¶

__rshift__(other)

Return a reactive value for self right-shifted by other.

Parameters:

Name	Type	Description	Default
`other`	`HasValue[Y]`	The number of positions to shift.	required

Returns:

Type	Description
`Computed[T \| Y]`	A reactive value for `self.value >> other.value`.

Example

>>> s = Signal(32)
>>> result = s >> 2
>>> result.value
8
>>> s.value = 24
>>> result.value
6

divmod ¶

__divmod__(other: HasValue[int]) -> Computed[tuple[int, int]]

__divmod__(other: HasValue[bool] | HasValue[int]) -> Computed[tuple[int, int]]

__divmod__(other: Any) -> Computed[tuple[float, float]]

__divmod__(other)

Return a reactive value for the divmod of self and other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to use as the divisor.	required

Returns:

Type	Description
`Computed[tuple[int, int]] \| Computed[tuple[float, float]]`	A reactive value for `divmod(self.value, other)`.

Example

>>> s = Signal(10)
>>> result = divmod(s, 3)
>>> result.value
(3, 1)
>>> s.value = 20
>>> result.value
(6, 2)

rdivmod ¶

__rdivmod__(other: HasValue[int]) -> Computed[tuple[int, int]]

__rdivmod__(other: HasValue[int]) -> Computed[tuple[int, int]]

__rdivmod__(other: HasValue[bool]) -> Computed[tuple[int, int]]

__rdivmod__(other: Any) -> Computed[tuple[float, float]]

__rdivmod__(other)

Return a reactive value for the divmod of self and other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to use as the numerator.	required

Returns:

Type	Description
`Computed[tuple[int, int]] \| Computed[tuple[float, float]]`	A reactive value for `divmod(other, self.value)`.

Example

>>> s = Signal(3)
>>> result = divmod(10, s)
>>> result.value
(3, 1)
>>> s.value = 4
>>> result.value
(2, 2)

lt ¶

__lt__(other)

Return a reactive value for whether self is less than other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to compare against.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `self.value < other`.

Example

>>> s = Signal(5)
>>> result = s < 10
>>> result.value
True
>>> s.value = 15
>>> result.value
False

le ¶

__le__(other)

Return a reactive value for whether self is less than or equal to other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to compare against.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `self.value <= other`.

Example

>>> s = Signal(5)
>>> result = s <= 5
>>> result.value
True
>>> s.value = 6
>>> result.value
False

ge ¶

__ge__(other)

Return a reactive value for whether self is greater than or equal to other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to compare against.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for self.value >= other.

Example

>>> s = Signal(10)
>>> result = s >= 5
>>> result.value
True
>>> s.value = 3
>>> result.value
False

gt ¶

__gt__(other)

Return a reactive value for whether self is greater than other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to compare against.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for self.value > other.

Example

>>> s = Signal(10)
>>> result = s > 5
>>> result.value
True
>>> s.value = 3
>>> result.value
False

ne ¶

__ne__(other)

Return a reactive value for whether self is not equal to other.

Parameters:

Name	Type	Description	Default
`other`	`Any`	The value to compare against.	required

Returns:

Type	Description
`Computed[bool]`	A reactive value for `self.value != other`.

Example

>>> s = Signal(5)
>>> result = s != 5
>>> result.value
False
>>> s.value = 6
>>> result.value
True

getitem ¶

__getitem__(key: slice) -> Computed[list[V]]

__getitem__(key: slice) -> Computed[tuple[V, ...]]

__getitem__(key: slice) -> Computed[str]

__getitem__(key: HasValue[SupportsIndex] | HasValue[int]) -> Computed[V]

__getitem__(key: HasValue[SupportsIndex] | HasValue[int]) -> Computed[V]

__getitem__(key: HasValue[SupportsIndex] | HasValue[int]) -> Computed[str]

__getitem__(key: HasValue[K]) -> Computed[V]

__getitem__(key: HasValue[K]) -> Computed[V]

__getitem__(key: Any) -> Computed[Any]

__getitem__(key)

Return a reactive value for the item or slice of self.

Parameters:

Name	Type	Description	Default
`key`	`Any`	The index or slice to retrieve.	required

Returns:

Type	Description
`Computed[Any]`	A reactive value for `self.value[key]`.

Example

>>> s = Signal([1, 2, 3, 4, 5])
>>> result = s[2]
>>> result.value
3
>>> s.value = [10, 20, 30, 40, 50]
>>> result.value
30

setattr ¶

__setattr__(name, value)

Assign name on the wrapper or forward it to the wrapped value.

Private attributes and names owned by the wrapper type are assigned on the wrapper itself. Other names are forwarded to the wrapped value when that object already defines the attribute, then observers are notified so dependents recompute.

This allows signal.name = "Bob" to update the wrapped object while still preserving the wrapper's own API such as .value and .rx.

Parameters:

Name	Type	Description	Default
`name`	`str`	The attribute name to assign.	required
`value`	`Any`	The value to assign.	required

Example

>>> class Person:
...     def __init__(self, name: str):
...         self.name = name
...     def greet(self) -> str:
...         return f"Hi, I'm {self.name}!"
>>> s = Signal(Person("Alice"))
>>> result = s.greet()
>>> result.value
"Hi, I'm Alice!"
>>> s.name = "Bob"
>>> result.value
"Hi, I'm Bob!"

setitem ¶

__setitem__(key, value)

Set an item on the underlying self.value.

Note

It is necessary to set the item via the Signal, rather than the underlying signal.value, to properly notify downstream observers of changes. Reason being, mutable objects that, for example, fallback to id comparison for equality checks will appear as if nothing changed even an element of the object is changed.

Parameters:

Name	Type	Description	Default
`key`	`Any`	The key to change.	required
`value`	`Any`	The value to set it to.	required

Example

```py

s = Signal([1, 2, 3]) result = computed(sum)(s) result.value 6 s[1] = 4 result.value 8

Functions¶

signified.computed ¶

computed(func)

Wrap a function so calls produce a reactive Computed result.

The returned wrapper accepts plain values, reactive values, or nested containers. On each recomputation, arguments are resolved with deep_unref, so func always receives plain Python values.

Any reactive value read during evaluation becomes a dependency; the Computed updates automatically when any dependency changes.

Parameters:

Name	Type	Description	Default
`func`	`Callable[..., R]`	Function that computes a derived value from its inputs.	required

Returns:

Type	Description
`Callable[..., Computed[R]]`	A wrapper that returns a Computed when called.

signified.unref ¶

unref(value)

Unwrap a reactive value to its plain Python value.

Repeatedly follows the .value chain until a non-reactive value is reached. When called inside a Computed or Effect evaluation, each unwrapped reactive registers as a dependency — equivalent to reading .value directly.

Parameters:

Name	Type	Description	Default
`value`	`HasValue[T]`	Plain value, reactive value, or nested reactive value.	required

Returns:

Type	Description
`T`	The fully unwrapped value.

Example

>>> nested = Signal(Signal(5))
>>> unref(nested)
5

signified.deep_unref ¶

deep_unref(value)

Recursively resolve reactive values within nested containers.

Like unref, but also descends into dict, list, tuple, and other iterables, replacing any reactive values found within them.

Supported containers:

scalars (int, float, str, bool, None) are returned unchanged
reactive values are unwrapped recursively
dict, list, and tuple contents are recursively unwrapped
generic iterables are reconstructed when possible; otherwise returned as-is
numpy.ndarray with dtype=object is unwrapped element-wise

Parameters:

Name	Type	Description	Default
`value`	`Any`	Any value, possibly containing reactive values.	required

Returns:

Type	Description
`Any`	Value with reactive nodes recursively replaced by plain values.

Example

>>> payload = {"a": Signal(1), "b": [Signal(2), 3]}
>>> deep_unref(payload)
{'a': 1, 'b': [2, 3]}

signified.has_value ¶

has_value(obj, type_)

Check whether an object's resolved value is an instance of type_.

A typed guard around unref. Useful when a parameter accepts either a plain value or a reactive wrapper and you need to narrow the type.

Parameters:

Name	Type	Description	Default
`obj`	`Any`	Value to inspect. May be plain or reactive.	required
`type_`	`type[T]`	Expected resolved value type.	required

Returns:

Type	Description
`TypeGuard[HasValue[T]]`	`True` if `unref(obj)` is an instance of `type_`; otherwise `False`.

Example

>>> candidate = Signal(42)
>>> has_value(candidate, int)
True
>>> has_value(candidate, str)
False

signified.as_rx ¶

as_rx(val)

Normalize a value to a reactive object.

If val is already reactive, it is returned unchanged. Otherwise a new Signal is created wrapping the value.

Parameters:

Name	Type	Description	Default
`val`	`HasValue[T]`	Plain value or reactive value.	required

Returns:

Type	Description
`ReactiveValue[T]`	A reactive value.

Types¶

HasValue[T] — T | Computed[T] | Signal[T]

A plain or reactive value that resolves to T. Use as a type hint when a parameter accepts either a raw value or a reactive wrapper.

ReactiveValue[T] — Computed[T] | Signal[T]

A reactive wrapper that resolves to T.

API Reference¶

Classes¶

signified.Signal ¶

value property writable ¶

at ¶

signified.Computed ¶

value property ¶

invalidate ¶

signified.Effect ¶

dispose ¶

signified.Variable ¶

Reactive Namespace¶

map ¶

effect ¶

peek ¶

len ¶

is_ ¶

is_not ¶

in_ ¶

contains ¶

eq ¶

where ¶

as_bool ¶

Magic Methods¶

__getattr__ ¶

__call__ ¶

__abs__ ¶

__round__ ¶

__ceil__ ¶

__floor__ ¶

__trunc__ ¶

__neg__ ¶

__pos__ ¶

__invert__ ¶

__add__ ¶

__radd__ ¶

__sub__ ¶

__rsub__ ¶

__mul__ ¶

__rmul__ ¶

__truediv__ ¶

__rtruediv__ ¶

__floordiv__ ¶

__rfloordiv__ ¶

__mod__ ¶

__rmod__ ¶

__pow__ ¶

__rpow__ ¶

__matmul__ ¶

__and__ ¶

__rand__ ¶

__or__ ¶

__ror__ ¶

__xor__ ¶

__rxor__ ¶

__lshift__ ¶

__rshift__ ¶

__divmod__ ¶

__rdivmod__ ¶

__lt__ ¶

__le__ ¶

__ge__ ¶

__gt__ ¶

__ne__ ¶

__getitem__ ¶

__setattr__ ¶

__setitem__ ¶

Functions¶

signified.computed ¶

signified.unref ¶

signified.deep_unref ¶

signified.has_value ¶

signified.as_rx ¶

Types¶

value `property` `writable` ¶

value `property` ¶

getattr ¶

call ¶

abs ¶

round ¶

ceil ¶

floor ¶

trunc ¶

neg ¶

pos ¶

invert ¶

add ¶

radd ¶

sub ¶

rsub ¶

mul ¶

rmul ¶

truediv ¶

rtruediv ¶

floordiv ¶

rfloordiv ¶

mod ¶

rmod ¶

pow ¶

rpow ¶

matmul ¶

and ¶

rand ¶

or ¶

ror ¶

xor ¶

rxor ¶

lshift ¶

rshift ¶

divmod ¶

rdivmod ¶

lt ¶

le ¶

ge ¶

gt ¶

ne ¶

getitem ¶

setattr ¶

setitem ¶