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.3

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.3
File	Size	Uploaded
fugazi-0.10.3.tar.gz	331.5 kB	Jul 3, 2026	Details

Built distributions (wheels)

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

Total release size: 11.1 MB

Release files / fugazi-0.10.3.tar.gz

Download URL	fugazi-0.10.3.tar.gz
Size	331.5 kB
Tags	Source
SHA-256 checksum How to use checksums	`c5a355e2104a17a9da813564e5a3755f94affd3f8040c1ece67720bd3fd40689`
BLAKE2b-256 checksum How to use checksums	`5000eb655b7446927ce273d86012f7593a6d105178fc1a19a969b65272a94834`
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/1d2f363b655ec1e1759b386b51b14a925882d471

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/1d2f363b655ec1e1759b386b51b14a925882d471/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686296596/attempts/1

Artifact

Subject: fugazi-0.10.3.tar.gz
SHA-256 checksum: c5a355e2104a17a9da813564e5a3755f94affd3f8040c1ece67720bd3fd40689 Verifying attestations

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

Download URL	fugazi-0.10.3-cp39-abi3-win_amd64.whl
Size	1.9 MB
Tags	CPython 3.9 Windows x86-64 abi3
SHA-256 checksum How to use checksums	`c83b7655603089abea0aec5461acada246bf98634ec7a61c0355715f8558c605`
BLAKE2b-256 checksum How to use checksums	`ef6902e41664574849d638deadda2d7311f84f7f1e3a3a56fbf6ef50d22eac5d`
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/1d2f363b655ec1e1759b386b51b14a925882d471

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/1d2f363b655ec1e1759b386b51b14a925882d471/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686296596/attempts/1

Artifact

Subject: fugazi-0.10.3-cp39-abi3-win_amd64.whl
SHA-256 checksum: c83b7655603089abea0aec5461acada246bf98634ec7a61c0355715f8558c605 Verifying attestations

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

Download URL	fugazi-0.10.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
Size	2.3 MB
Tags	CPython 3.9 Linux glibc 2.17+ x86-64 abi3
SHA-256 checksum How to use checksums	`903dd7cfdc45805631aff7bd1a6136777d0afbe899cfd7f254899db75cd897d1`
BLAKE2b-256 checksum How to use checksums	`27214896a808117c414f4bb3d5c942c37400bea3624c7729b1672c48661c2bc8`
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/1d2f363b655ec1e1759b386b51b14a925882d471

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/1d2f363b655ec1e1759b386b51b14a925882d471/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686296596/attempts/1

Artifact

Subject: fugazi-0.10.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
SHA-256 checksum: 903dd7cfdc45805631aff7bd1a6136777d0afbe899cfd7f254899db75cd897d1 Verifying attestations

Release files / fugazi-0.10.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

Download URL	fugazi-0.10.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
Size	2.3 MB
Tags	CPython 3.9 Linux glibc 2.17+ ARM64 abi3
SHA-256 checksum How to use checksums	`c60b2af8abae6cc0e7fb7f066eb666d8ed33944d1e802f3e41610eaca3fd71f1`
BLAKE2b-256 checksum How to use checksums	`850d7d17a1abd9aabf2d2a380199ea262e50639ac9045383f8be30211f206670`
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/1d2f363b655ec1e1759b386b51b14a925882d471

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/1d2f363b655ec1e1759b386b51b14a925882d471/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686296596/attempts/1

Artifact

Subject: fugazi-0.10.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
SHA-256 checksum: c60b2af8abae6cc0e7fb7f066eb666d8ed33944d1e802f3e41610eaca3fd71f1 Verifying attestations

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

Download URL	fugazi-0.10.3-cp39-abi3-macosx_11_0_arm64.whl
Size	2.1 MB
Tags	CPython 3.9 abi3 macOS 11.0+ ARM64
SHA-256 checksum How to use checksums	`5d398be17f920af4dbab29642b408030f51e12c1e0526d80497183cafc2c156a`
BLAKE2b-256 checksum How to use checksums	`f28d91929ac7a76c296e899dbca056cba6f8a8a2b9c874b0de59a917f831f828`
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/1d2f363b655ec1e1759b386b51b14a925882d471

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/1d2f363b655ec1e1759b386b51b14a925882d471/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686296596/attempts/1

Artifact

Subject: fugazi-0.10.3-cp39-abi3-macosx_11_0_arm64.whl
SHA-256 checksum: 5d398be17f920af4dbab29642b408030f51e12c1e0526d80497183cafc2c156a Verifying attestations

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

Download URL	fugazi-0.10.3-cp39-abi3-macosx_10_12_x86_64.whl
Size	2.1 MB
Tags	CPython 3.9 abi3 macOS 10.12+ x86-64
SHA-256 checksum How to use checksums	`50322dedcaa05c5724e12d290344dc85bb1b37881704f6b500a1d7e3824c9770`
BLAKE2b-256 checksum How to use checksums	`70e310bac136d9abe57b8955b1e996f956ec9ffa8c47302b05b42b95251be9dc`
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/1d2f363b655ec1e1759b386b51b14a925882d471

Workflow

Publishing configuration: github.com/acpuchades/fugazi/blob/1d2f363b655ec1e1759b386b51b14a925882d471/.github/workflows/release.yml
Publishing logs: github.com/acpuchades/fugazi/actions/runs/28686296596/attempts/1

Artifact

Subject: fugazi-0.10.3-cp39-abi3-macosx_10_12_x86_64.whl
SHA-256 checksum: 50322dedcaa05c5724e12d290344dc85bb1b37881704f6b500a1d7e3824c9770 Verifying attestations