fugazi (Python)

Python bindings for fugazi, a library of incremental, composable technical-analysis primitives.

Incremental — every indicator and signal carries its own state and is advanced one sample at a time with update(), in ~O(1) and with no full-history recomputation. The same object serves live streaming and batch backtesting.
Composable — indicators own their input source, so you build complex indicators and signals by nesting constructors. There is no pipe or glue step: an "EMA of an SMA of the close" is literally ta.ema(ta.sma(ta.close(), 10), 20), and a trade condition is a single object you can feed bars.

Install

pip install fugazi

Then import fugazi. Prebuilt wheels are published for Linux, macOS (Intel + Apple Silicon) and Windows.

To build from a checkout instead (for development):

pip install maturin
maturin develop --release   # editable install into the active virtualenv

Quick start

You build indicators by nesting constructors. Every indicator is rooted at a leaf source — usually a candle field (close(), high(), volume(), ...):

import fugazi as ta

ema = ta.ema(ta.close(), 20)                  # EMA-20 of the close
node = ta.ema(ta.sma(ta.close(), 10), 20)     # EMA-20 of an SMA-10 — just keep nesting

The root decides what the indicator consumes. A candle-rooted indicator takes Candles (any of OHLCV); to work on a bare stream of numbers instead, root it at identity() — the leaf that passes raw values straight through:

prices = ta.rsi(ta.identity(), 14)            # RSI of a plain float series

Then drive it one of two ways: streaming (a bar at a time) or batch (a whole series at once). They share the same indicators; pick by how your data arrives.

What you feed update()/feed() follows from the root: a candle-rooted indicator consumes candles, an identity()-rooted one consumes plain numbers.

Streaming API — one sample at a time

Feed one sample to update(); it returns a float, or None until warmed up. This is the live/incremental path. Every node also has value() (or is_true() for a boolean Signal), is_ready(), and reset().

node = ta.ema(ta.sma(ta.close(), 10), 20)        # candle-rooted

for o, h, l, c, v in bars:
    value = node.update(ta.Candle(o, h, l, c, v))   # feed a Candle -> float | None
    print(value)

prices = ta.rsi(ta.identity(), 14)               # identity-rooted
for px in [100.0, 101.5, 100.8]:
    prices.update(px)                            # feed a float

Batch API — a whole series at once

feed(data) computes every bar in one call. For a candle-rooted indicator, data is a dataframe with OHLCV columns — pandas and polars both work (also a dict of columns) — and only the columns an indicator needs have to be present:

import pandas as pd      # or: import polars as pl

# df is your OHLCV frame (open/high/low/close/volume columns)
df["ema20"] = ta.ema(ta.close(), 20).feed(df)   # assigns straight back
ta.atr(14).feed(df)                             # uses high/low/close
ta.vwap().feed(df)                              # uses high/low/close/volume

Column names are matched case-insensitively (Close/CLOSE/close), and close is required. An identity()-rooted indicator instead takes a plain 1-D series — a list, NumPy array, or pandas/polars Series:

ta.ema(ta.identity(), 20).feed([100.0, 101.5, 100.8, 102.3, 101.9])
ta.ema(ta.identity(), 20).feed(df["close"])

(The root is the contract: a candle indicator won't silently treat a bare array as the close, and a value indicator won't accept a frame — pick the root that matches your data.)

The output mirrors the input library, one value per bar, with warm-up bars as NaN (so the result lines up with your rows and assigns straight back):

Input	Indicator	Multi-line (macd, bollinger, …)	Signal
pandas	`Series` (index preserved)	`DataFrame` (one column per line)	bool `Series`
polars	`Series`	`DataFrame`	bool `Series`
list / dict / NumPy	`ndarray`	`dict` of `ndarray`s	bool `ndarray`

ta.ema(ta.close(), 20).feed(df)            # pandas Series, df.index
ta.macd(ta.close()).feed(df)               # pandas DataFrame: macd/signal/histogram
ta.macd(ta.identity()).feed(prices_list)   # {"macd": ndarray, "signal": ndarray, ...}

(If NumPy isn't installed, list/dict input falls back to plain Python lists.)

feed is itself incremental — it just loops update over the batch through the node's own state and never auto-resets. So calling it on successive chunks continues the same stream: the warm-up is paid once, and the concatenated outputs equal a single feed over the whole series. This is what lets you process data as it arrives without recomputing history:

node = ta.sma(ta.identity(), 3)
x1 = node.feed(series1)         # warms up, emits for series1
x2 = node.feed(series2)         # continues from where series1 left off
# np.concatenate([x1, x2]) == ta.sma(ta.identity(), 3).feed(series1 + series2)

node.reset()                   # call reset() to start a fresh, independent pass

A source can be reused after you pass it into a constructor:
src = ta.close()
fast = ta.ema(src, 10)
slow = ta.ema(src, 20)   # `src` is still usable here

Indicators

Constructor	Output
`open() high() low() close() volume() typical() median()`	the candle field
`identity()`	the raw value stream (root for a bare numeric series)
`value(x)`	a constant
`sma ema rma wma hma rsi stddev stochastic cci (source, period)`	a value
`stoch_rsi(source, rsi_period=14, stoch_period=14)`	a value
`atr mfi williams_r (period)`	a value
`obv() vwap() ad() true_range()`	a value
`sar(step=0.02, max=0.2)`	a value
`macd(source, fast=12, slow=26, signal=9)`	dict `{macd, signal, histogram}`
`bollinger(source, period=20, k=2.0)`	dict `{upper, middle, lower}`
`keltner(source, ema_period=20, atr_period=10, multiplier=2.0)`	dict `{upper, middle, lower}`
`donchian(high, low, period)`	dict `{upper, middle, lower}`
`adx(period)`	dict `{plus_di, minus_di, adx}`
`dmi(period)`	dict `{plus_di, minus_di}`
`aroon(period)`	dict `{up, down, oscillator}`

Multi-line indicators return a dict of their named lines (or None while warming up).

Operators

Combine value indicators into other indicators:

ta.close().add(other)        # also: sub, mul, div  — or the + - * / operators
ta.close().lag(1)            # also: diff, ratio, roc
ta.close().rolling_max(20)   # also: rolling_min

...or into signals (booleans):

fast.gt(slow)                        # also: lt, ge, le, eq, ne  (optional epsilon=...)
ta.rsi(ta.close(), 14).above(70.0)   # also: below(level)
fast.crosses_above(slow)             # also: crosses_below

Signals compose with each other and update to a bool:

sig = a.and_(b)     # also: or_, xor_, not_(), changed()  — or  a & b | ~c
sig.update(candle)  # -> bool

Example

"Fast EMA crosses above slow EMA while RSI is not already overbought" — one signal, usable either way:

import fugazi as ta

def golden():
    return (
        ta.ema(ta.close(), 12)
          .crosses_above(ta.ema(ta.close(), 26))
          .and_(ta.rsi(ta.close(), 14).below(70.0))
    )

# streaming: react bar by bar
signal = golden()
for bar in stream:
    if signal.update(bar):
        print("entry signal")

# batch: a boolean Series/array over the whole frame
entries = golden().feed(df)

Trading: the wallet

The strategy layer is exposed as a wallet you trade into. There is no strategy class to subclass — a "strategy" in Python is just your own code that, each bar, reads signals and calls wallet methods. PaperWallet is the built-in, in-memory book (funds + positions + a trade blotter); live execution belongs in your own code, not here.

import fugazi as ta

wallet = ta.PaperWallet(10_000.0)          # seed with cash

wallet.update("AAPL", 185.0)               # feed the price each tick (before trading)

# set: absolute target (opposite side reverses) · set_position: absolute units · close: flat
wallet.set("AAPL", "buy", 10)                       # target 10 units (a number = units)
wallet.set("AAPL", "buy", ta.Size.value_frac(0.25)) # target 25% of equity
wallet.set("AAPL", "buy", ta.Size.position_frac(0.5))  # trim to 50% of the position
wallet.set_position("AAPL", 4)                      # drive straight to 4 units
wallet.close("AAPL")                                # flatten

wallet.funds                 # cash balance
wallet.position("AAPL")      # signed position (negative = short)
wallet.price("AAPL")         # last fed price (or None)
wallet.positions()           # {symbol: units}
wallet.equity()              # funds + positions marked at the fed prices
wallet.orders()              # the blotter: list of Order(symbol, side, units)

The wallet is fed each symbol's price with update(symbol, price) and is otherwise market-agnostic. Sizes are an absolute number of units, or ta.Size.funds_frac(f) (cash) / ta.Size.value_frac(f) (equity; 1.0 is all-in) / ta.Size.position_frac(f); sides are "buy"/"sell". A movement that can't be carried out — no/zero price fed, or a buy beyond available funds — raises ValueError. A full strategy loop — price the wallet, advance every signal each bar, then act:

enter = ta.sma(ta.close(), 3).crosses_above(ta.sma(ta.close(), 10))
exit_ = ta.sma(ta.close(), 3).crosses_below(ta.sma(ta.close(), 10))
wallet = ta.PaperWallet(10_000.0)

for o, h, l, c, v in bars:
    candle = ta.Candle(o, h, l, c, v)
    wallet.update("AAPL", c)                          # price the wallet
    went_long, went_flat = enter.update(candle), exit_.update(candle)
    if went_long:
        wallet.set("AAPL", "buy", ta.Size.value_frac(1.0))   # all-in long
    elif went_flat:
        wallet.close("AAPL")

Metadata

Release files for fugazi 0.10.4

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for fugazi 0.10.4
File	Size	Uploaded
fugazi-0.10.4.tar.gz	333.7 kB	Jul 3, 2026	Details

Built distributions (wheels)

Table of built distributions (wheels) for fugazi 0.10.4
File	Interpreter	ABI	Platform	Reset
fugazi-0.10.4-cp39-abi3-win_amd64.whl 2.3 MB Jul 3, 2026	CPython 3.9	abi3	Windows x86-64	Details
fugazi-0.10.4-cp39-abi3-manylinux_2_28_aarch64.whl 2.9 MB Jul 3, 2026	CPython 3.9	abi3	Linux glibc 2.28+ ARM64	Details
fugazi-0.10.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl 3.0 MB Jul 3, 2026	CPython 3.9	abi3	Linux glibc 2.17+ x86-64	Details
fugazi-0.10.4-cp39-abi3-macosx_11_0_arm64.whl 2.7 MB Jul 3, 2026	CPython 3.9	abi3	macOS 11.0+ ARM64	Details
fugazi-0.10.4-cp39-abi3-macosx_10_12_x86_64.whl 2.9 MB Jul 3, 2026	CPython 3.9	abi3	macOS 10.12+ x86-64	Details

Total release size: 14.2 MB

Release files / fugazi-0.10.4.tar.gz

Download URL	fugazi-0.10.4.tar.gz
Size	333.7 kB
Tags	Source
SHA-256 checksum How to use checksums	`4ffaf64d15c1c8de3ec6b8f3f4f2d843ff2ce4bc1ed431984a18b3a17ef1bea9`
BLAKE2b-256 checksum How to use checksums	`1b668f3cddaf7788666270127036beec78c0cf462467d27dae89a3c7d5311ba1`
Upload date	Jul 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/6.1.0 CPython/3.13.12`

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/acpuchades/fugazi
Publishing commit: github.com/acpuchades/fugazi/tree/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686527175/attempts/1

Artifact

Subject: fugazi-0.10.4.tar.gz
SHA-256 checksum: 4ffaf64d15c1c8de3ec6b8f3f4f2d843ff2ce4bc1ed431984a18b3a17ef1bea9 Verifying attestations

Release files / fugazi-0.10.4-cp39-abi3-win_amd64.whl

Download URL	fugazi-0.10.4-cp39-abi3-win_amd64.whl
Size	2.3 MB
Tags	CPython 3.9 Windows x86-64 abi3
SHA-256 checksum How to use checksums	`934b5bd7921c927fa65f61f811d7217da4f1b97c80051c4be59d34642d24f911`
BLAKE2b-256 checksum How to use checksums	`02760884492d02a4f0d7334c5e5e4c91890835cc5700b677f5316e628e0a4f66`
Upload date	Jul 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/6.1.0 CPython/3.13.12`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/acpuchades/fugazi
Publishing commit: github.com/acpuchades/fugazi/tree/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686527175/attempts/1

Artifact

Subject: fugazi-0.10.4-cp39-abi3-win_amd64.whl
SHA-256 checksum: 934b5bd7921c927fa65f61f811d7217da4f1b97c80051c4be59d34642d24f911 Verifying attestations

Release files / fugazi-0.10.4-cp39-abi3-manylinux_2_28_aarch64.whl

Download URL	fugazi-0.10.4-cp39-abi3-manylinux_2_28_aarch64.whl
Size	2.9 MB
Tags	CPython 3.9 Linux glibc 2.28+ ARM64 abi3
SHA-256 checksum How to use checksums	`26d14c21a3cd8240a02781cf9e1519c1b920e347159ae9bd61ca553f2296cce4`
BLAKE2b-256 checksum How to use checksums	`e29d02d38cf577828df21d884a5f7fc2c246c49d9edd2c721fa4d913e53b2556`
Upload date	Jul 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/6.1.0 CPython/3.13.12`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/acpuchades/fugazi
Publishing commit: github.com/acpuchades/fugazi/tree/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686527175/attempts/1

Artifact

Subject: fugazi-0.10.4-cp39-abi3-manylinux_2_28_aarch64.whl
SHA-256 checksum: 26d14c21a3cd8240a02781cf9e1519c1b920e347159ae9bd61ca553f2296cce4 Verifying attestations

Release files / fugazi-0.10.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

Download URL	fugazi-0.10.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
Size	3.0 MB
Tags	CPython 3.9 Linux glibc 2.17+ x86-64 abi3
SHA-256 checksum How to use checksums	`b434dc8fbbb668e53bb48d3b9389d40e07a9c3008d6c9322f05ee9a0f04d610f`
BLAKE2b-256 checksum How to use checksums	`130e7c6929fa02fef1b1d134aeeb5f882fc8a80ba616a146098e08e65c14c1fc`
Upload date	Jul 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/6.1.0 CPython/3.13.12`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/acpuchades/fugazi
Publishing commit: github.com/acpuchades/fugazi/tree/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686527175/attempts/1

Artifact

Subject: fugazi-0.10.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
SHA-256 checksum: b434dc8fbbb668e53bb48d3b9389d40e07a9c3008d6c9322f05ee9a0f04d610f Verifying attestations

Release files / fugazi-0.10.4-cp39-abi3-macosx_11_0_arm64.whl

Download URL	fugazi-0.10.4-cp39-abi3-macosx_11_0_arm64.whl
Size	2.7 MB
Tags	CPython 3.9 abi3 macOS 11.0+ ARM64
SHA-256 checksum How to use checksums	`f2f6f89f347ed0246bb193472ec222ce41c4c39314c3517609a5bb063e2a0447`
BLAKE2b-256 checksum How to use checksums	`bab99dfa7a333348841946fd0756c9f2b4898e989f4a1fc919c06ef9080eeb0b`
Upload date	Jul 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/6.1.0 CPython/3.13.12`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/acpuchades/fugazi
Publishing commit: github.com/acpuchades/fugazi/tree/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686527175/attempts/1

Artifact

Subject: fugazi-0.10.4-cp39-abi3-macosx_11_0_arm64.whl
SHA-256 checksum: f2f6f89f347ed0246bb193472ec222ce41c4c39314c3517609a5bb063e2a0447 Verifying attestations

Release files / fugazi-0.10.4-cp39-abi3-macosx_10_12_x86_64.whl

Download URL	fugazi-0.10.4-cp39-abi3-macosx_10_12_x86_64.whl
Size	2.9 MB
Tags	CPython 3.9 abi3 macOS 10.12+ x86-64
SHA-256 checksum How to use checksums	`5ae6d7b4fb56c910386dea02a0cac42d28803db68856d55045ed033056b1e6fb`
BLAKE2b-256 checksum How to use checksums	`be5da32977e1910b6bfb3c7506e59703230a53b1e8153c9707252e44cfb410b5`
Upload date	Jul 3, 2026
Uploaded using Trusted Publishing? What is trusted publishing?	Yes
Uploaded via	`twine/6.1.0 CPython/3.13.12`

Provenance

Identity

Publishing platform: GitHub Actions
Publishing repository: github.com/acpuchades/fugazi
Publishing commit: github.com/acpuchades/fugazi/tree/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/571f01803a5333c3eebc4ebf6dfd222b0b51f8f8/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686527175/attempts/1

Artifact

Subject: fugazi-0.10.4-cp39-abi3-macosx_10_12_x86_64.whl
SHA-256 checksum: 5ae6d7b4fb56c910386dea02a0cac42d28803db68856d55045ed033056b1e6fb Verifying attestations