[Adelagric]

Fixes #352.

Problem

An input passed explicitly to Feature.__call__() stays in the _input node, so a later call without input reuses it:

s = dt.Stack(value=2)
s(3)
s()          # [3, 2], expected [2]

s = dt.Stack(value=2)
s(1)
(1 & s)()    # [1, 1, 2], expected [1, 2]

The second case is the one from the issue: 1 & s builds Value(1) >> Stack(value=s), and s is evaluated as a property, i.e. without input, so it picks up the 1 left over from the direct call.

Why "no input ⇒ reset" is not enough

Writing None into _input whenever no input is given (the approach of #357) fails test_broadcast_list, and a variant that only resets inputs previously set by __call__ fails test_Feature_arithmetic. Two existing behaviours get in the way:

1. _input can be a computed node. Reducer (hence Mean, Sum, …) accepts feature= and wires it as _input. Overwriting that node with None discards the feature's output, so inp - Mean(inp) ends up with [].
2. "No input" means two things. In inp - inp * 2 the same inp receives 10 and is then re-evaluated as a property, without input, within the same resolution. It must keep the 10. The issue is about an input left over from a previous call.

Fix

Resolution epochs. A process-wide counter gives every top-level Feature.__call__() a new epoch; nesting depth and current epoch live in contextvars.ContextVars, so independent threads or asyncio tasks do not see each other's calls as nested. A small context manager wraps the existing with config.with_backend(...).

Per-cell records. When a feature receives an input explicitly, it records the current epoch against the cache cell of _input that _ID resolves to, in a WeakKeyDictionary. Keying by cell rather than by raw _ID means that _IDs the cache resolves to the same entry share one record, and that records disappear with their cells when update() replaces the caches, for every component of a pipeline.

Stale check. When called without input, the feature looks at the records of the cells _ID refers to. A record from the current epoch is kept (same-pipeline reuse, as in inp - inp * 2). A record from a previous epoch is stale: the record is dropped and the _input cell is invalidated, so it falls back to its action (the default [], or the wired feature for Reducer). Invalidating rather than overwriting is what keeps Reducer(feature=...) working.

_ID resolution per cache. The caches resolve a read at an _ID longer than their key length by trimming it, but reject a write there (DeepTrackDataDict.create_index). __call__ therefore resolves, per cache, the _ID under which that cache holds the entry: _input operations (explicit input, stale check, reset) use the _ID of the _input cache, the output node is evaluated under the _ID of its own cache, and properties and arguments keep the logical _ID, so distinct _IDs still sample independently. This is what makes a feature called directly and then nested in Repeat (which calls it at _ID + (n,)) behave, and it keeps sibling cells and key lengths untouched. An _ID shorter than the key length still fails at store, as on develop.

Results:

s = dt.Stack(value=2); s(3); s()                     # 2        (was [3, 2])
s = dt.Stack(value=2); s(1); (1 & s)()               # [1, 2]   (was [1, 1, 2])
p = dt.Stack(value=2) >> dt.Add(b=1); p(5); p()      # 3        (was [6, 3])
s = dt.Stack(value=2); s(3); dt.Repeat(s, N=1)()     # 2        (was [3, 2])
s = dt.Stack(value=2); s(3); (dt.Repeat(s, N=1) & s)()   # [2, 2]  (was [3, 2, 3, 2])
inp = dt.DummyFeature(); (inp - inp * 2)(10)         # -10      (unchanged)
inp = dt.Value([1, 0]); (inp - dt.statistics.Mean(inp))()   # [0, 0] (unchanged)

Behaviour change to confirm

The __call__ docstring documented the reported behaviour as a feature:

>>> feature()  # Uses stored input
array([3, 4, 5])

With this change, feature() after feature(x) evaluates on an empty input ([] for a distributed feature), which is what the issue asks for. No test depended on the old behaviour. The __call__ and Stack docstrings are updated. Flagging it since it is user-visible.

Tests

New tests in tests/test_features.py:

• the issue cases, the nested-pipeline case and same-resolution reuse (inp - inp * 2);
• a get() call counter for the explicit → empty → empty sequence (one call, one recomputation on [], then cached) and a Mean(inp) falling back to its wired feature after an explicit input;
• _ID aliases: reset through a longer _ID then a call at the original one, Repeat, the Repeat(s, N=1) & s composition, the same-resolution alias case, per-cell independence, a stale sibling next to a cell set in the current resolution, round trips between _ID lengths;
• distinct _IDs sampling independently after a targeted property.update(), with a deterministic counter and an _ID-dependent value;
• purge of component records after update();
• thread isolation with a deterministic blocked call.

python -m unittest discover -s tests on this revision: 520 tests, OK (129 skipped), numpy backend only (no PyTorch, OpenCV or Deeplay installed here). The two pytest collection errors (test_elementwise.py::test_method, test_features.py::test_operator) are pre-existing on develop: helper functions named test_* that pytest picks up.

Notes

• Epoch numbers are drawn from one locked counter, so they never collide across contexts.
• If a feature is first touched in an epoch through the node API (e.g. as the _input of a Reducer, which calls action() directly) and only later through Feature.__call__() without input, the stale reset triggers on that later call and re-evaluates the downstream nodes once more in the same epoch. Results are consistent; it is one extra computation in a rare pattern.

Files

• deeptrack/features.py: resolution scope, per-cell records, per-cache _ID resolution, stale check in __call__, docstrings of __call__ and Stack.
• tests/test_features.py: regression tests.