DEV Community: 473185670

I Built a Natural Language -> pandas Code Generator (Open Source + Free)

473185670 — Thu, 13 Aug 2026 14:27:32 +0000

If you've spent more time in pandas documentation than in your actual data, this is for you.

The Problem

I analyze data with pandas every day. And every day, I spend a non-trivial chunk of time looking up syntax I've used a hundred times but can't remember exactly:

"Was it .agg() with a dict or a list of tuples?"
"How do I do a rolling average with a min period?"
"What's the seaborn one-liner for a correlation heatmap?"

Each lookup is 2-5 minutes of context-switching. Multiply by 30 lookups/day and that's an hour gone — not on analysis, just on syntax.

What I Built

A tool where you describe what you want in English, and it returns syntax-validated, copy-paste-ready pandas code.

Example input:

Group sales by month, calculate total revenue and average order size

Generated output:

df['month'] = df['date'].dt.to_period('M')
result = df.groupby('month').agg(
    total_revenue=('revenue', 'sum'),
    avg_order_size=('order_size', 'mean')
).reset_index()

Note the datetime handling — the kind of thing you'd forget on the first pass and debug for 10 minutes.

How It Works

Three components, no magic:

1. Few-Shot Examples (22 curated patterns)

The system prompt includes 22 examples covering the patterns developers actually use: groupby+agg, merge/join, datetime, string ops, missing data, pivots, visualization, binning, filtering, chaining. This isn't a generic LLM wrapper — it's specialized for pandas.

2. Schema Awareness

Upload a CSV or describe your columns, and the generator knows df['date'] is datetime and df['user_id'] is a string. No more "assume column X exists" placeholders.

3. AST Validation

Before returning code, it runs ast.parse() to catch syntax errors. If the model hallucinates a method, the validator flags it. You never get broken code — and it also scans for dangerous operations (eval, exec, subprocess, os.remove).

More Examples

Rolling average:

Calculate the 7-day rolling average of the close price column

df['rolling_avg'] = df['close'].rolling(window=7).mean()

Merge with conflict handling:

Merge orders and customers on customer_id, keep only matching rows

merged = pd.merge(orders, customers, on='customer_id', how='inner')

Quantile binning:

Create quartile bins for income and label them Q1 through Q4

df['income_quartile'] = pd.qcut(df['income'], q=4, labels=['Q1', 'Q2', 'Q3', 'Q4'])

Correlation heatmap:

Create a heatmap of the correlation matrix with annotations

import seaborn as sns
sns.heatmap(df.corr(numeric_only=True), annot=True, cmap='coolwarm')

What It's Not

Let me be honest about the boundaries:

It's not a black-box analyst. It generates code you should read and verify. df.groupby('date')['revenue'].sum() runs whether or not it answers your question.
It doesn't know your data. It doesn't know "revenue" is in cents, or that null means "not applicable." Domain knowledge stays human.
It's not for complex multi-step pipelines (yet). 2-3 step compositions work well. 10-step exploratory analysis is still your job.

The honest value prop: it saves the 20-30% of time spent on syntax lookup, so you can spend it on the 70-80% that matters — understanding your data and interpreting results.

Tech Stack

Backend: Python FastAPI, pluggable LLM providers (OpenAI / Anthropic / Ollama / stub)
Frontend: React + Vite, syntax highlighting, nature-themed UI
Validation: ast.parse() + dangerous-op scanner
Rate limiting: 5 free queries/day per IP

Try It

The free tier gives you 5 queries/day, no signup required:

→ PandasAI — try it here

Type a data operation in English, get validated pandas code. If you find a pattern it handles well (or badly), I'd love to hear about it.

I Backtested a Macro Scenario Classifier. The Signal Was Backwards.

473185670 — Mon, 10 Aug 2026 12:33:05 +0000

I spent two weeks building a classifier that sorts ISM Manufacturing PMI releases into "GOLDILOCKS" (growth without overheating) and "CONTRACTION" (economy shrinking) scenarios. The textbook hypothesis: GOLDILOCKS predicts positive S&P 500 forward returns, CONTRACTION predicts negative ones.

The backtest showed the exact opposite. CONTRACTION releases produced higher forward S&P 500 returns than GOLDILOCKS at every horizon I tested -- and the sign test confirms this is not noise (p < 10^-13 at 42 days).

The setup

ISM Manufacturing PMI is a monthly survey of ~300 supply managers; above 50 = expanding, below 50 = contracting. The classification: GOLDILOCKS (PMI ~52-58, strong new orders) = textbook bullish. CONTRACTION (PMI < 50, weak new orders) = textbook bearish. This is not a controversial framework -- it's the kind of thing you'd find in any macro strategy deck.

The backtest

Event study on 72 ISM PMI releases (Feb 2019 - Dec 2024), measuring actual S&P 500 forward return after each release. S&P 500 data is 100% live (yfinance, 1,530 trading days).

Horizon	GOLDILOCKS	n	CONTRACTION	n	Spread (G-C)	p (parametric)	p (sign test)
5 days	+0.80%	22	+1.13%	33	-0.33%	0.643	0.882
10 days	+0.97%	22	+1.90%	33	-0.94%	0.317	0.00058
21 days	+1.19%	22	+2.37%	32	-1.18%	0.335	0.00083
42 days	+2.20%	22	+4.73%	31	-2.52%	0.100	7x10^-14

The spread is negative at all four horizons and widens with the holding period. A CONTRACTION release followed by a 2-month hold returned 4.73% on average -- more than double GOLDILOCKS's 2.20%.

Why the sign test matters here (and the parametric p doesn't kill this)

The parametric Welch t-test doesn't reach significance (p = 0.64 / 0.32 / 0.33 / 0.10). Here's why that's not the end of the story: with n = 22-33 per group and heavy-tailed return distributions (equity returns have fat tails), the parametric test is underpowered -- it needs large samples to detect a difference under non-normality. The parametric p = 0.64 means "can't confirm the mean difference with a normal-distribution assumption," not "there's no effect."

The non-parametric sign test doesn't assume any distribution. It just asks: "did CONTRACTION beat GOLDILOCKS more often than a coin flip would?" At 10, 21, and 42 days, the answer is yes with p = 0.00058 / 0.00083 / 7x10^-14. At 42 days, CONTRACTION outperformed GOLDILOCKS so consistently that the sign test is significant to 14 decimal places.

The sign test is significant in the wrong direction. That's the finding.

Why? (my best guess)

The most likely explanation: markets are forward-looking; contraction implies policy easing. When ISM PMI drops below 50, the market doesn't just see "economy shrinking" -- it sees "Fed will cut rates." Rate-cut expectations are themselves bullish: they lower the discount rate on future cash flows, raising equity valuations. The 2019 and 2024 CONTRACTION episodes both coincided with dovish Fed pivots that drove sharp rallies.

The classifier reads the current economic state. The market prices the future policy response. That's the disconnect.

A secondary possibility: mean reversion. CONTRACTION releases cluster around sentiment-washed-out troughs (2020 COVID PMI 41 -> fastest recovery in history); GOLDILOCKS releases cluster around complacency peaks (2021 PMI 60 -> 2022 bear market). And yes, 72 releases is a small sample spanning a unusual regime (COVID + bear->bull). The result may not generalize. But the sign test at p < 10^-13 is hard to dismiss as pure sample noise.

Reproduce it

git clone https://github.com/473185670/macro-scenario-api
cd macro-scenario-api
pip install yfinance pandas scipy
python multi_horizon_backtest.py

The script reuses the same classify_scenario() function the API exposes -- no look-ahead bias. S&P 500 pulls live from yfinance. Full results: multi_horizon_result.json.

The interesting part isn't the classifier. It's that "CONTRACTION -> higher forward equity returns" is a real, statistically significant, counter-intuitive empirical regularity with a plausible mechanism. Whether it survives out-of-sample is an open question.

If you found this counter-intuitive, the most useful thing you can do is try to refute it -- run the backtest on a different sample (services PMI, non-US equities, pre-2019 data) and tell me what you find.

Classify ISM PMI Macro Scenarios in 10 Lines of Python (Free API)

473185670 — Sun, 09 Aug 2026 22:20:03 +0000

Classify ISM PMI Macro Scenarios in 10 Lines of Python

Every first business day of the month, the Institute for Supply Management releases Manufacturing PMI. Traders scramble to interpret three numbers — headline PMI, New Orders, Prices Paid — into a macro posture: risk-on or risk-off?

I built a free REST API that does this classification for you. It takes the PMI triple and returns a scenario (Goldilocks, Moderate, Soft Landing, or Contraction) with a confidence score and concrete trading actions across SPY, US10Y, BTC, and CRDO.

No pip install. No API key for the demo. Copy-paste and run.

The 10-Line Version

import urllib.request, json

url = "https://macro-scenario-api.onrender.com/classify_scenario"
payload = {"headline_pmi": 52.8, "new_orders": 54.1, "prices_paid": 48.5}

req = urllib.request.Request(url, data=json.dumps(payload).encode(),
                             headers={"Content-Type": "application/json"})
with urllib.request.urlopen(req, timeout=30) as resp:
    result = json.loads(resp.read())
    print(json.dumps(result, indent=2))

Output:

{
  "scenario": "GOLDILOCKS",
  "confidence": 0.87,
  "label": "Growth above 52, prices contained — risk-on",
  "actions": [
    {"asset": "SPY",  "direction": "LONG",  "priority": "HIGH"},
    {"asset": "US10Y","direction": "SHORT", "priority": "MEDIUM"},
    {"asset": "BTC",  "direction": "LONG",  "priority": "MEDIUM"}
  ]
}

That's it. The API is live, hosted on Render with a keep-alive cron so the free-tier cold start stays warm.

🚀 Production-ready on RapidAPI — rate limits, Swagger docs, marketplace reliability. Get your API key → (free tier: 100 calls/mo, no credit card)

The Four Scenarios

Scenario	Trigger	Posture
🍯 Goldilocks	PMI > 52, prices contained	Risk-on
⚖️ Moderate	Solid growth, mild price pressure	Risk-on (selective)
🪂 Soft Landing	Growth cooling toward 50, prices easing	Neutral
📉 Contraction	Sub-50 headline, falling new orders	Risk-off

Full Markdown Report Endpoint

Want a human-readable report you can paste into a trading journal? Hit the second endpoint:

url = "https://macro-scenario-api.onrender.com/ism_report"
payload = {"headline_pmi": 48.2, "new_orders": 46.1, "prices_paid": 55.0}

req = urllib.request.Request(url, data=json.dumps(payload).encode(),
                             headers={"Content-Type": "application/json"})
with urllib.request.urlopen(req, timeout=30) as resp:
    print(json.loads(resp.read())["report"])

This returns a formatted Markdown reaction report with the scenario, confidence, and a prioritized action table — ready for Notion, Obsidian, or any markdown journal.

Batch Processing (CSV → Scenarios)

Processing a year of historical PMI data? Loop it:

import csv, urllib.request, json

API = "https://macro-scenario-api.onrender.com/classify_scenario"

with open("ism_history.csv") as f:
    for row in csv.DictReader(f):
        payload = {
            "headline_pmi": float(row["pmi"]),
            "new_orders":   float(row["new_orders"]),
            "prices_paid":  float(row["prices_paid"]),
        }
        req = urllib.request.Request(API, data=json.dumps(payload).encode(),
                                     headers={"Content-Type": "application/json"})
        with urllib.request.urlopen(req, timeout=30) as resp:
            r = json.loads(resp.read())
            print(f"{row['date']}: {r['scenario']} (conf={r['confidence']})")

Get the API on RapidAPI

The demo above hits the public Render instance directly. For production usage with rate limits, Swagger docs, and marketplace reliability, the API is also published on RapidAPI:

👉 Macro Scenario Analysis API on RapidAPI

Free tier: 100 calls/month. Paid tier: $0.01/call — pay only for what you use.

Try It Now

# Health check — confirms the API is awake
import urllib.request
with urllib.request.urlopen("https://macro-scenario-api.onrender.com/health", timeout=30) as r:
    print(r.read().decode())  # {"status":"ok","version":"1.0.0"}

If you build something with this, drop a comment — I'd love to see what scenarios you're tracking.

Honest Note on "Edge"

I ran a real event study on this classification: 72 ISM PMI releases mapped to actual S&P 500 returns. Result: the classification does NOT predict 5-day returns (GOLDILOCKS +0.80% vs CONTRACTION +1.13%, p=0.643, direction backwards at 5/10/21/42-day horizons).

So what's this API good for? Organization and journaling, not alpha. It gives you a consistent, reproducible framework to log your macro reactions and build a personal dataset over time. The edge — if you find one — comes from your reaction to the scenario, not the scenario label itself. Use it as a decision journal, not a crystal ball.

The API is open and documented at 473185670.github.io/macro-scenario-api. Source on GitHub. Built as a macro decision journal, not financial advice.

I Built a Macro Catalyst Trading Journal That Auto-Classifies ISM PMI Scenarios

473185670 — Fri, 07 Aug 2026 23:47:01 +0000

⚠️ Correction (Aug 9, 2026) — please read first.

A comment below claimed the backtest showed GOLDILOCKS fired 3× (each preceding a >2% SPX weekly gain) and CONTRACTION correctly flagged risk-off 2 of 2 cases. That was wrong. Those numbers came from a simulator with hardcoded return assumptions, not real market data.

I subsequently ran a real event-study backtest (72 ISM PMI releases, 2019–2024, actual S&P 500 5-day forward returns via yfinance):

Scenario n 5-day avg return

GOLDILOCKS 22 +0.80%

CONTRACTION 33 +1.13%

SOFT_LANDING 5 -2.47%

MODERATE 8 +0.25%

GOLDILOCKS vs CONTRACTION spread −0.33%, p=0.643 (not significant). The classification does not reliably predict 5-day forward returns. Backtest code is open-source: real_backtest.py.

So what is this about? The tool is still useful as a macro organizer/journal — it structures messy prints into 4 scenarios and logs your reasoning. But it is not a validated alpha signal, and I should not have implied it was. Apologies. The bundle is now described honestly on Gumroad as an organizer toolkit, not an edge product.

Scenario	n	5-day avg return
GOLDILOCKS	22	+0.80%
CONTRACTION	33	+1.13%
SOFT_LANDING	5	-2.47%
MODERATE	8	+0.25%

The Problem

Every macro print — ISM, NFP, CPI, FOMC — I was manually reasoning about what it meant for my book. Three problems:

Slow: By the time I'd thought through the implications, the move was done.
Inconsistent: Same print on different days → different conclusion depending on my mood.
Unlogged: Two weeks later I couldn't remember why I'd rotated into industrials.

The Solution

I built a scenario classifier that takes 3 inputs — ISM Headline, New Orders, Prices Paid — and outputs one of 4 scenarios:

Scenario	Condition	Bias
🟢 GOLDILOCKS	Strong growth, no overheat	RISK-ON
🟡 MODERATE	Growth with cost pressure	NEUTRAL
🟠 SOFT_LANDING	Cooling but positive	CAUTIOUS
🔴 CONTRACTION	Below 50 / decelerating	RISK-OFF

Each scenario maps to sector rotation calls, duration positioning, and crypto/risk-asset bias.

The July 2026 ISM Mfg PMI Test

Headline: 55.6 vs consensus 54.0 → beat by 1.6
New Orders: 54.2 → expansion accelerating
Employment: first expansion in 34 months
Prices Paid: 71.1 → cost pressure persists

Classifier output: GOLDILOCKS, 85% confidence.

Actions fired:

Rotate cyclicals > defensives (Industrials, Materials, Small Caps)
US10Y → test 4.80%+ → short duration
BTC risk-on, target $66k+
AI interconnect (CRDO) structural bid reinforced

The Code (Zero Dependencies)

import urllib.request, json

def classify_scenario(headline, new_orders, prices_paid):
    if headline >= 54 and new_orders >= 53 and prices_paid <= 72:
        return 'GOLDILOCKS', 'RISK-ON', 85
    elif headline >= 52 and prices_paid > 72:
        return 'MODERATE', 'NEUTRAL', 70
    elif headline >= 50:
        return 'SOFT_LANDING', 'CAUTIOUS', 60
    else:
        return 'CONTRACTION', 'RISK-OFF', 90

scenario, bias, conf = classify_scenario(55.6, 54.2, 71.1)
print(f'{scenario} | {bias} | {conf}% confidence')

Try the full engine live in your browser (no signup): Backtest Simulator

The Packaging

I packaged it as four products:

1. Notion Trading Journal Template ($7)
Four databases with 13 pre-loaded entries and 4 scenario playbooks.

2. Macro Scenario Analysis API (pay-per-call)
The classification engine wrapped in FastAPI, deployed on Render, listed on RapidAPI.

3. Pine Script Indicator
Displays the scenario classification directly on TradingView charts.

4. Semi Decoupling Dashboard ($9.99)
An HTML dashboard tracking NVDA vs semi equipment/storage decoupling.

The Bundle

All four for $14.99: gumroad.com/l/txmuvz

Notion template standalone: gumroad.com/l/nztlu

Free preview: notion.site

Why This Works

Zero competition on Gumroad.
Zero maintenance (static template).
Category creator on TradingView.
Marketplace distribution via RapidAPI.

🎁 Free Cheat Sheet

Grab the free ISM PMI Macro Scenario Cheat Sheet — one page, 4 scenarios, live API demo, no signup:

👉 Get the free cheat sheet
If you found this useful, the bundle is $14.99. Questions? Ask in the comments.