Implementation:TA Lib Ta lib python Abstract Function Run

Knowledge Sources	ta-lib-python
Domains	Technical_Analysis, Software_Architecture
Last Updated	2026-02-09 22:00 GMT

Overview

Concrete tool for executing Abstract API indicator computations via Function.__call__, Function.run, and Function.outputs provided by the Cython _Function class.

Description

The _Function class provides three execution methods:

__call__(*args, **kwargs) — Most flexible. Accepts positional arrays (like Function API), named parameters, and dict/DataFrame inputs. Restores parameters after execution (does not permanently modify the object).
run(input_arrays=None) — Sets input arrays (if provided) and returns outputs. Simpler than __call__.
outputs (property) — Returns cached results, recomputing only if inputs/parameters changed.

Usage

Use __call__ for one-shot computation, run for setting data + executing, and outputs for accessing cached results after configuration.

Code Reference

Source Location

Repository: ta-lib-python
File: talib/_abstract.pxi
Lines: L411-474 (__call__), L399-409 (run), L367-397 (outputs property)

Signature

class Function:
    def __call__(self, *args, **kwargs):
        """
        Call the function with the same signature as talib.func module functions.
        Accepts positional numpy arrays, dict/DataFrame, and keyword parameters.
        Does NOT permanently modify parameters (restores after call).

        Returns:
            np.ndarray for single-output indicators
            list[np.ndarray] for multi-output indicators
            pd.Series/DataFrame if input was pandas DataFrame
            pl.Series/DataFrame if input was polars DataFrame
        """

    def run(self, input_arrays=None):
        """
        Shortcut: optionally sets input_arrays, then returns self.outputs.
        """

    @property
    def outputs(self):
        """
        Returns computed results. Recomputes if inputs/params changed.
        Single output: np.ndarray (or pd.Series/pl.Series)
        Multiple outputs: list of arrays (or pd.DataFrame/pl.DataFrame)
        """

Import

from talib import abstract

I/O Contract

Inputs

Name	Type	Required	Description
*args	np.ndarray / dict / DataFrame	No	Positional price arrays or input data structure
**kwargs	int / float	No	Named parameters (e.g., timeperiod=20)
input_arrays (run)	dict / DataFrame	No	Input data for run() method

Outputs

Name	Type	Description
result	np.ndarray / pd.Series / pl.Series	Single-output indicator result
result_list	list[np.ndarray] / pd.DataFrame / pl.DataFrame	Multi-output indicator results

Usage Examples

Using call

import numpy as np
from talib import abstract

inputs = {
    'open': np.random.random(100),
    'high': np.random.random(100) + 1,
    'low': np.random.random(100),
    'close': np.random.random(100) + 0.5,
    'volume': np.random.random(100) * 1000,
}

sma = abstract.Function('SMA')
# Call like a function
result = sma(inputs, timeperiod=20)

Using run()

sma = abstract.Function('SMA')
sma.parameters = {'timeperiod': 20}
result = sma.run(inputs)

Using outputs Property

sma = abstract.Function('SMA')
sma.set_input_arrays(inputs)
sma.parameters = {'timeperiod': 20}
result = sma.outputs  # Computes and caches

# Change parameters
sma.parameters = {'timeperiod': 50}
result2 = sma.outputs  # Recomputes with new params

Calling Like Function API

# __call__ accepts positional arrays like the Function API
close = np.random.random(100)
sma = abstract.Function('SMA')
result = sma(close, timeperiod=20)

Related Pages

Page Connections

Double-click a node to navigate. Hold to expand connections.

Principle

Implementation

Heuristic

Environment