fugazi 0.1.1__tar.gz

fugazi-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,54 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  rust:
+    name: Rust (test + clippy)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+      # Scope to the core crate: the `fugazi-python` member links libpython via
+      # pyo3's extension-module feature and can't be `cargo test`ed standalone.
+      # Its Rust + Python surface is exercised by the `python` job below.
+      - name: Test
+        run: cargo test -p fugazi
+      - name: Clippy
+        run: cargo clippy -p fugazi --all-targets -- -D warnings
+
+  python:
+    name: Python bindings (pytest)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Build + install wheel
+        working-directory: python
+        run: |
+          pip install maturin
+          maturin build --release --out dist
+          pip install --no-index --find-links dist fugazi
+      - name: Install test deps
+        run: pip install pytest numpy pandas polars
+      - name: pytest
+        working-directory: python
+        run: pytest

fugazi-0.1.1/.github/workflows/release.yml

@@ -0,0 +1,91 @@
+name: Release
+
+# Publishes on a version tag, e.g. `git tag v0.1.0 && git push origin v0.1.0`.
+# Builds multi-platform wheels + sdist, then publishes to PyPI (Trusted
+# Publishing / OIDC, no token) and the core crate to crates.io (token secret).
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  wheels:
+    name: wheels (${{ matrix.platform.runner }} ${{ matrix.platform.target }})
+    runs-on: ${{ matrix.platform.runner }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - { runner: ubuntu-22.04, target: x86_64, manylinux: auto }
+          - { runner: ubuntu-22.04, target: aarch64, manylinux: auto }
+          # Both macOS arches build on the Apple-Silicon runner; the x86_64
+          # wheel is cross-compiled. The Intel macos-13 runner is scarce and
+          # being deprecated — it routinely queued 10+ min while this leg ran.
+          - { runner: macos-14, target: x86_64 }
+          - { runner: macos-14, target: aarch64 }
+          - { runner: windows-latest, target: x64 }
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build wheel
+        uses: PyO3/maturin-action@v1
+        with:
+          working-directory: python
+          target: ${{ matrix.platform.target }}
+          args: --release --out dist
+          manylinux: ${{ matrix.platform.manylinux }}
+          sccache: "true"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist-${{ matrix.platform.runner }}-${{ matrix.platform.target }}
+          path: python/dist
+
+  sdist:
+    name: sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          working-directory: python
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist-sdist
+          path: python/dist
+
+  publish-pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: [wheels, sdist]
+    if: startsWith(github.ref, 'refs/tags/')
+    environment: pypi
+    permissions:
+      id-token: write # Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: dist-*
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist
+
+  publish-crates:
+    name: Publish to crates.io
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: cargo publish
+        run: cargo publish -p fugazi
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

fugazi-0.1.1/.gitignore

@@ -0,0 +1,8 @@
+/target
+/tests/data/talib_expected.csv
+
+# TA-Lib fixture generator (Python) internals
+__pycache__/
+*.py[cod]
+.mypy_cache/
+.ruff_cache/

fugazi-0.1.1/CLAUDE.md

@@ -0,0 +1,89 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+`fugazi` is a Rust library (edition 2024, no external dependencies) of **incremental** technical-analysis primitives. Every primitive owns its internal state and is advanced one sample at a time via `update()`, carrying just enough intermediate state to produce the next output in ~O(1). The same code therefore serves both live streaming and batch backtesting.
+
+## Commands
+
+- Build: `cargo build`
+- Test (unit + integration + doctests): `cargo test`
+- Single test by name: `cargo test warms_up_then_averages`
+- All tests in one module: `cargo test indicators::rsi`
+- One integration-test file: `cargo test --test composition`
+- Lint (keep clean): `cargo clippy --all-targets`
+- API docs: `cargo doc --open`
+
+## Architecture
+
+Three composable layers: indicators (numeric sources), signals (boolean-valued indicators — `Indicator<Output = bool>`), and strategies (the decision layer that trades into a wallet).
+
+### Indicators = the numeric *sources* (`src/indicator.rs`, `src/indicators/`)
+
+`Indicator` has associated `Input`/`Output`, `update(&mut self, Input) -> Option<Output>`, `value()` (the latest output, matching the public `value` field), `is_ready()`, `reset()`. Output is `Option` because most indicators need a warm-up (`None` until ready).
+
+The defining design choice: **price-series indicators own their input source** and are generic over it — `Ema<S>`, `Sma<S>`, `Rma<S>`, `Rsi<S>`, `Macd<S>` where `S: Indicator<Output = Real>`, with `Input = S::Input`. So composition is just nesting constructors:
+
+```rust
+Ema::new(Current::close(), 20)          // EMA-20 of the close (Input = Candle)
+Ema::new(Sma::new(src, 10), 20)         // EMA of an SMA
+Rsi::new(Identity::new(), 14)           // RSI of a raw Real stream
+```
+
+There is **no pipe/`then`/`Chain`** — chaining *is* construction.
+
+- **Leaf sources** terminate the chain: `Value` (constant), `Identity` (raw `Real` passthrough), and the candle accessors under `Current` (`Current::close()`, `Current::volume()`, …; built on the `Field<F>` / `CandleField` carrier in `candle.rs`).
+- **Bar indicators** consume the whole `Candle` directly (they are not "of a price"): `Atr`, `Adx`, `TrueRange`, and the volume indicators `Obv`, `Vwap`, `Ad` (Chaikin A/D line), `Mfi` (money-flow index). These take only parameters, or none, e.g. `Atr::new(14)`, `Obv::new()`, `Mfi::new(14)`. The cumulative ones (`Obv`/`Vwap`/`Ad`) anchor at construction; `reset()` re-anchors — e.g. at a session boundary for `Vwap`.
+- **Two-source indicators**: `Donchian<H, L>` takes a high source and a low source, e.g. `Donchian::new(Current::high(), Current::low(), 20)`.
+- `Real = f64` and `Candle` (OHLCV) live in `src/types.rs`.
+- Multi-output indicators (`Macd`, `Adx`, `Bollinger`, `Donchian`, `Keltner`, `Aroon`, `Dmi`) expose one named field per output and set `Output` to a small `Copy` struct (`MacdValue`, `AdxValue`, …); single-output ones expose `value: Option<Real>`. Each also has a **component accessor per output** (`macd.line()`/`.signal()`/`.histogram()`, `bands.upper()`/`.middle()`/`.lower()`, `adx.adx()`, `dmi.plus_di()`, …) returning a `Component<Self>` — a single field projected back into an `Indicator<Output = Real>`, so one output of a struct-valued indicator composes and compares like any other source: `macd.line().crosses_above(macd.signal())`, `Current::close().gt(bands.upper())`. Each accessor **clones** the source (one independently-advanced instance per component, like `crosses_above`'s operand clone). The `Component` carrier (`indicators/component.rs`) holds the source plus a `fn(Output) -> Real` selector — one generic carrier, no per-field marker types.
+- `StochRsi<S>` is a type alias for `Stochastic<Rsi<S>>` — StochRSI is just the stochastic transform over an RSI source: `Stochastic::new(Rsi::new(src, 14), 14)`.
+
+### Signals = boolean-valued *indicators* (`src/signal.rs`, `src/indicators/{compare,logic,ext}.rs`)
+
+A **signal is just an `Indicator<Output = bool>`** — there is no second trait hierarchy. `Signal` is a thin marker, `trait Signal: Indicator<Input = Candle, Output = bool>` (blanket-impl'd, `?Sized`), naming "a boolean condition over a `Candle`" so a strategy can hold one as `Box<dyn Signal>`. Like any indicator a signal is `None` until warmed; read it as a plain `bool` (false until ready) with `BoolIndicatorExt::is_true` (= `value().unwrap_or(false)`). There is no `src/signals/` module — the comparison/logic/ext pieces live under `indicators/` and are imported from there.
+
+- **Comparisons are bool-output binary ops** over two real sources: aliases `Gt`/`Lt`/`Ge`/`Le`/`Eq`/`Ne` for `Combine<L, R, GtOp>` etc. (`indicators/compare.rs`). The op is **value-carrying** — each holds an absolute `epsilon` (default `DEFAULT_EPSILON = 1e-8`); the fluent `.gt()`/`.lt()`/… builders use the default, `Gt::with_epsilon(a, b, eps)` overrides.
+- **Boolean logic** (`indicators/logic.rs`): `And`/`Or`/`Xor` are `Combine<L, R, AndOp>` etc. over two bool sources; `Not` and `Change` are dedicated unary bool-output carriers; `Const<In>` is the constant-bool leaf (the twin of `Value`).
+- `IndicatorExt` (blanket over every `Real`-output indicator, in `indicators/ext.rs`) is the fluent builder for **operators only** — comparisons (`gt`/`lt`/`ge`/`le`/`eq`/`ne`, `above`/`below`), arithmetic (`add`/`sub`/`mul`/`div`), lookback (`lag`/`diff`/`ratio`/`roc`), rolling extremum (`rolling_max`/`rolling_min`), and the composed `crosses_above`/`crosses_below`. Named indicators (`Sma`, `Bollinger`, …) are **not** builder methods; construct via their own `::new`. Do not add `.sma()`/`.bollinger()`-style builders.
+- `BoolIndicatorExt` (blanket over every `Indicator<Output = bool>`, `?Sized` so it works on `Box<dyn Signal>`) adds the bool view `is_true()` and the combinators `and`/`or`/`xor`/`not` + the single edge primitive `changed` (a `Change` toggle detector).
+- **A crossover is not a primitive**: `crosses_above(a,b)` expands to `a.gt(b).and(a.gt(b).changed())` — "comparison is true *and* it just changed". (Clones the operands, so ~2× the source work.)
+
+### Strategies = the decision layer (`src/strategy.rs`)
+
+Unlike the pure layers below it, a strategy **acts**, in two phases: `Strategy` has `update(&mut self, Input)` (advance its signals/indicators — touches only `&mut self`, so updates across strategies are independent and parallelizable), `trade(&self, &mut dyn Wallet<Symbol>)` (read that state and open/adjust/close positions — `&self`, *price-free*; trades against a shared wallet are serial since sizing resolves against its running state), and `reset()` (associated `Input`/`Symbol`). A driver does, each bar: feed the wallet its prices, `update` every strategy, then `trade` each. There is deliberately **no one-shot `evaluate`**. Almost every classical single-asset strategy shares one shape — a long/flat/short position driven by a few boolean signals, sized all-in — so the crate ships **`SingleAssetStrategy<Sym>`** (`strategies/single_asset.rs`): a concrete `Strategy` (Input = Candle) holding four `Box<dyn Signal>` slots (open/close long, open/close short, each defaulting to constant-false) and built with three builders — `long_on(enter, exit)`, `short_on(enter, exit)` (chainable; an opposite-side entry reverses an open position) and the `buy_and_hold(symbol)` constructor. Its `trade` runs entries first (all-in, reversal-capable) then flatten-to-flat exits. (This is the generic `(signal, action)` shape earlier designs deliberately avoided — a policy-object/`RuleStrategy`/combined-`evaluate` lineage; it was reintroduced **on request**. `SingleAssetStrategy` is still just "a concrete type implementing the trait", parameterised over its signals — not a rule engine. Don't add policy traits or a `(signal, action)` table beyond it without being asked.) The `src/strategies/` **catalogue of classical strategies** is then a set of **free-function specializations** returning a `SingleAssetStrategy` (`ma_crossover`, `rsi_reversal`, `donchian_breakout`, `keltner_breakout`, … grouped under `trend`/`mean_reversion`/`momentum`/`volume`/`composite`): long/flat = `new(sym).long_on(enter, exit)`, always-in long/short = `new(sym).long_on(up, down).short_on(down, up)`. The one strategy that doesn't fit the long/flat/short, all-in mould — `ZScoreReversion` (reads its `z` indicator directly; long/short with a flat rest) — stays its own bespoke `Strategy` type. Shared code is limited to tiny mechanical helpers (`is_long`/`is_short`, taking the position's `.amount`) in `strategies/mod.rs`. Positions size all-in via `value_frac(1.0)`, which survives a reversal (equity, unlike cash), so one `set` reverses and re-sizes all-in exactly — no `enter_all_in` helper.
+
+All in `src/strategy.rs`:
+- **`Wallet<Sym>` is a trait** (the portfolio interface taken as `&mut dyn`) — the single **seam** between pure fugazi and a downstream execution system. fugazi stays pure (ships only the in-memory paper impl); a downstream crate implements `Wallet` with a type whose `set_position` *publishes to an event bus / routes to a broker*. The wallet is **priced from outside**: it carries no market view; `update(symbol, price)` feeds each symbol's worth every tick (fugazi is agnostic to where prices come from), and `funds()`/`position(&Sym)`/`price(&Sym)`/`equity()` query it. The single execution primitive is `set_position(Quantity)` (drive a symbol to an absolute signed-unit target); `set` (a `Side` + `Size`, absolute target — opposite side reverses) and `close` (flat) are **default methods** over it, resolving `Size` once so only execution is per-impl. Movements return `Result<Option<Order>, WalletError>` — `Ok(None)` is "nothing to trade", and `WalletError` (`UnknownPrice`, `InvalidPrice` for a non-positive price, `InsufficientFunds` for a no-margin overdraft) flags an impossible move instead of silently no-op'ing. There is deliberately **no `trade(delta)` primitive and no additive `open`** — scale-in is `set_position(position + delta)`. NB: the trading/event-bus/market system itself is **not** in fugazi — it's a separate project that imports fugazi; keep market/IO code out of this crate.
+- **Unit-tagged amounts** keep reference currency and instrument units from mixing: `Reference(Real)` (quote/funds currency — `funds`/`equity`/`price`) and `Quantity<Sym> { symbol, amount }` (signed instrument units — `position`, `set_position`). `Order` stays plain `Real` (its `symbol`+`side` already imply the unit).
+- **`PaperWallet<Sym>`** is the built-in **pure** `Wallet` impl: in-memory `funds` + `HashMap<Sym,Real>` positions + a `HashMap<Sym,Real>` price map + a blotter (`Vec<Order>`); its `set_position` assumes the fill at the symbol's last fed price and books it. Caller-owned; adds inherent `new`, `is_flat`, `positions()`, `orders()`, `clear_blotter()` (`equity()` is the trait method, arg-free).
+- **`Size`** (the magnitude vocabulary): `Units(n)` absolute, `FundsFraction(f)` (= `f·funds/price`, cash), `ValueFraction(f)` (= `f·equity/price`, all-in/target-weight; `1.0` flips cleanly on a reversal), `PositionFraction(f)` (= `f·|position|`, adjust-only). `resolve(price, position, funds, equity) -> magnitude`. Direction comes from `Side` (`Buy`/`Sell`, `.sign()`), not the size.
+- `Order<Sym>` (`{ symbol, side, quantity }`); `Order::from_delta(symbol, delta)` builds the buy/sell for a position change (`None` within `DEFAULT_EPSILON`).
+- There is **no `Market` trait**: the wallet holds its own fed prices, so a multi-asset input just feeds several symbols via `update` and a strategy's `trade` acts on several symbols in one call (multi-asset/pairs in the same type).
+- Sizing/direction/short-selling/always-in-market are all just *what the strategy's code does* — no flags. Python (`python/src/lib.rs`) binds `PaperWallet`/`Order`/`Size` (sides as `"buy"`/`"sell"` strings, symbols as `str`; `update`/`set`/`set_position`/`close`, `WalletError` → `ValueError`); a Python "strategy" is plain Python code driving a `PaperWallet`.
+
+### Generic transform ops (`src/indicators/ops.rs`)
+
+Source-wrapping carriers, each driven by an operator type so a new operator is a trait impl, not a new type:
+- `Combine<L, R, Op>` (binary, `BinaryOp`): **one carrier for all binary ops**, generic over the op's input/output via associated `Lhs`/`Rhs`/`Output` and holding the op **by value**. Serves arithmetic `Add`/`Sub`/`Mul`/`Div` (`Real,Real→Real`; `Div` → `None` on /0), the comparisons in `indicators/compare.rs` (`Real,Real→bool`, the op carrying its epsilon) and the boolean logic in `indicators/logic.rs` (`bool,bool→bool`). `Combine::new` needs `Op: Default`; comparison ops also get `Combine::with_epsilon`.
+- `Lookback<I, Op>` (unary, relates a source to its value `period` steps ago, `LookbackOp`, zero-sized markers): `Lag` (past value), `Diff` (`x[t]-x[t-n]`), `Ratio` (`x[t]/x[t-n]`), `Roc`.
+- `Extreme<S, Op>` (rolling extremum, `ExtremeOp` = `MaxOp`/`MinOp`): `RollingMax`/`RollingMin`.
+
+### Shared cores (`pub(crate)`)
+
+Bare `Real -> Real` math with **no source and no `Indicator` impl**, so both source-wrapping indicators and indicators smoothing values they compute *internally* share one implementation:
+- `smoothing.rs`: `EmaState` (EMA recurrence) and `WilderState` (Wilder/RMA, mean-seed). `Ema`/`Macd` use `EmaState`; `Rma` uses `WilderState`; `Rsi` uses two (gain/loss); `Atr` = `TrueRange` + `WilderState`; `Adx` uses four.
+- `stats.rs`: `WindowStats` (windowed sum + sum-of-squares → `mean`/`variance`/`stddev`) backs `Sma`/`StdDev`/`Bollinger`; `WindowExtreme<Op>` (monotonic-deque rolling extremum) backs `Extreme`/`RollingMax`/`RollingMin` and `Stochastic`.
+
+## Conventions and gotchas
+
+- **Composition is construction.** A new "X of Y" indicator takes its source `S: Indicator<Output = Real>` in `new`; don't add pipe combinators.
+- **Use the cores, not each other's public types.** Internal smoothing of computed scalars uses `EmaState`/`WilderState` (Real recurrence). The public `Rma<S>`/`Ema<S>` wrap a *source* and can't smooth values you computed inline.
+- **Adding an operator** (arithmetic/comparison/boolean/lookback): add an `*Op` type implementing the relevant `*Op` trait plus a type alias — never a macro. Arithmetic/boolean/lookback ops are zero-sized `Default` markers; comparison ops are value structs carrying `epsilon`. They live by their carrier — `indicators/{compare,logic}.rs` for the `Combine`-based ones, `indicators/ops.rs` for `Lookback`/`Extreme`.
+- `Combine` (arithmetic, comparisons, and `And`/`Or`/`Xor`) feeds the *same* input to both sides, so it requires `Input: Clone`. Use `lhs`/`rhs` naming for binary operands.
+- `Combine` holds its op **by value** (so a comparison can carry epsilon); `Lookback`/`Extreme` hold a zero-sized op as `PhantomData<fn() -> Op>`. Input-ignoring leaves (`Value`, `Const`, `Field`) use `PhantomData<fn(I)>` / `fn() -> F` to satisfy the constraint rules (avoids E0207).
+- `Change` is a **bidirectional** toggle detector (fires on any transition); directional events come from pairing it with a comparison (see `crosses_above`).
+- Constructors `assert!(period > 0, ...)`; document warm-up length in the type's doc comment.
+- A comparison/edge is **`None` until** every source it depends on is warmed up (it reads `false` via `.is_true()`); a boolean op (`And`/`Or`/…) is likewise `None` until both sources are ready, so an edge that would coincide with warm-up is not detected (no spurious first-bar trade).

fugazi-0.1.1/Cargo.lock

@@ -0,0 +1,137 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "fugazi"
+version = "0.1.1"
+
+[[package]]
+name = "fugazi-python"
+version = "0.1.1"
+dependencies = [
+ "fugazi",
+ "pyo3",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

fugazi-0.1.1/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "fugazi"
+version = "0.1.1"
+edition = "2024"
+description = "A library of incremental technical-analysis indicators, signals and strategies"
+license = "MIT"
+repository = "https://github.com/acpuchades/fugazi"
+readme = "README.md"
+keywords = ["trading", "technical-analysis", "indicators", "finance", "incremental"]
+categories = ["finance", "mathematics"]
+
+[lib]
+name = "fugazi"
+path = "src/lib.rs"
+
+[dependencies]
+
+# The core crate stays dependency-free. The Python bindings live in their own
+# workspace member (`python/`), which is the only crate that pulls in PyO3 —
+# see that crate's README for build instructions.
+[workspace]
+members = ["python"]
+resolver = "2"

fugazi-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 acpuchades
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.