gavindiaz/quant-trading-strategy-templates
1
0
Fork 0
mirror of https://github.com/PyP-Quant/quant-trading-strategy-templates.git synced 2026-07-27 18:47:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
quant-trading-strategy-temp…/tools/generate_template_batch.py
T

481 lines
22 KiB
Python
Raw Permalink Blame History

from __future__ import annotations
import json
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
TEMPLATE_ROOT = ROOT / "templates"
SPECS = [
("audusd-logistic-30m", "AUDUSD", "30m", "sklearn LogisticRegression", "AUDUSD momentum classifier", "logistic"),
("audjpy-randomforest-1h", "AUDJPY", "1h", "sklearn RandomForest", "AUDJPY carry-risk classifier", "forest"),
("cadjpy-breakout-1h", "CADJPY", "1h", "sklearn RandomForest", "CADJPY breakout classifier", "breakout"),
("chfjpy-mean-reversion-1h", "CHFJPY", "1h", "custom Python", "CHFJPY mean-reversion baseline", "mean_reversion"),
("eurgbp-range-classifier-30m", "EURGBP", "30m", "sklearn LogisticRegression", "EURGBP range classifier", "logistic"),
("eurjpy-trend-rf-1h", "EURJPY", "1h", "sklearn RandomForest", "EURJPY trend classifier", "forest"),
("eurnzd-volatility-rf-4h", "EURNZD", "4h", "sklearn RandomForest", "EURNZD volatility classifier", "forest"),
("gbpjpy-breakout-rf-1h", "GBPJPY", "1h", "sklearn RandomForest", "GBPJPY breakout classifier", "breakout"),
("gbpusd-logistic-15m", "GBPUSD", "15m", "sklearn LogisticRegression", "GBPUSD directional baseline", "logistic"),
("nzdusd-mean-reversion-1h", "NZDUSD", "1h", "custom Python", "NZDUSD mean-reversion baseline", "mean_reversion"),
("usdcad-trend-rf-1h", "USDCAD", "1h", "sklearn RandomForest", "USDCAD trend classifier", "forest"),
("usdchf-range-logistic-1h", "USDCHF", "1h", "sklearn LogisticRegression", "USDCHF range classifier", "logistic"),
("usdmxn-volatility-rf-4h", "USDMXN", "4h", "sklearn RandomForest", "USDMXN volatility classifier", "forest"),
("xagusd-atr-breakout-1h", "XAGUSD", "1h", "custom Python", "Silver ATR breakout baseline", "atr_breakout"),
("xagusd-mean-reversion-30m", "XAGUSD", "30m", "custom Python", "Silver mean-reversion baseline", "mean_reversion"),
("xauusd-london-breakout-15m", "XAUUSD", "15m", "custom Python", "Gold London breakout baseline", "breakout"),
("xauusd-scalp-logistic-5m", "XAUUSD", "5m", "sklearn LogisticRegression", "Gold scalp classifier", "logistic"),
("xptusd-trend-rf-1h", "XPTUSD", "1h", "sklearn RandomForest", "Platinum trend classifier", "forest"),
("btcusdt-breakout-rf-15m", "BTCUSDT", "15m", "sklearn RandomForest", "BTC breakout classifier", "breakout"),
("btcusdt-mean-reversion-5m", "BTCUSDT", "5m", "custom Python", "BTC mean-reversion baseline", "mean_reversion"),
("bnbusdt-trend-rf-30m", "BNBUSDT", "30m", "sklearn RandomForest", "BNB trend classifier", "forest"),
("dogeusdt-scalp-logistic-1m", "DOGEUSDT", "1m", "sklearn LogisticRegression", "DOGE high-volatility scalp classifier", "logistic"),
("adausdt-volatility-rf-15m", "ADAUSDT", "15m", "sklearn RandomForest", "ADA volatility classifier", "forest"),
("xrpusdt-breakout-rf-15m", "XRPUSDT", "15m", "sklearn RandomForest", "XRP breakout classifier", "breakout"),
("linkusdt-trend-logistic-30m", "LINKUSDT", "30m", "sklearn LogisticRegression", "LINK trend classifier", "logistic"),
("avaxusdt-volatility-rf-30m", "AVAXUSDT", "30m", "sklearn RandomForest", "AVAX volatility classifier", "forest"),
("maticusdt-scalp-baseline-5m", "MATICUSDT", "5m", "custom Python", "MATIC scalp baseline", "atr_breakout"),
("dotusdt-mean-reversion-30m", "DOTUSDT", "30m", "custom Python", "DOT mean-reversion baseline", "mean_reversion"),
("ltcusdt-trend-rf-1h", "LTCUSDT", "1h", "sklearn RandomForest", "LTC trend classifier", "forest"),
("nas100-breakout-rf-15m", "NAS100", "15m", "sklearn RandomForest", "NASDAQ index breakout classifier", "breakout"),
("us30-mean-reversion-30m", "US30", "30m", "custom Python", "Dow index mean-reversion baseline", "mean_reversion"),
("spx500-trend-logistic-1h", "SPX500", "1h", "sklearn LogisticRegression", "S&P 500 trend classifier", "logistic"),
("ger40-breakout-rf-30m", "GER40", "30m", "sklearn RandomForest", "DAX breakout classifier", "breakout"),
("uk100-range-logistic-1h", "UK100", "1h", "sklearn LogisticRegression", "FTSE range classifier", "logistic"),
("oilwtico-atr-breakout-1h", "WTICOUSD", "1h", "custom Python", "WTI crude oil ATR breakout baseline", "atr_breakout"),
("brentoil-trend-rf-1h", "BRENTUSD", "1h", "sklearn RandomForest", "Brent crude trend classifier", "forest"),
("naturalgas-volatility-rf-4h", "NATGAS", "4h", "sklearn RandomForest", "Natural gas volatility classifier", "forest"),
("copperusd-mean-reversion-1h", "COPPERUSD", "1h", "custom Python", "Copper mean-reversion baseline", "mean_reversion"),
]
STRATEGIES = {
"logistic": '''import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
SYMBOL = "{symbol}"
MODEL_NAME = "{slug}"
def _prep(data):
df = data.copy()
df.columns = [str(c).strip().lower() for c in df.columns]
if "volume" not in df.columns:
df["volume"] = 1.0
for col in ["open", "high", "low", "close", "volume"]:
df[col] = pd.to_numeric(df[col], errors="coerce")
return df.dropna(subset=["open", "high", "low", "close"]).reset_index(drop=True)
def _features(df):
c = df["close"]
rng = (df["high"] - df["low"]).replace(0, np.nan)
f = pd.DataFrame(index=df.index)
for n in [1, 3, 6, 12, 24]:
f[f"ret{{n}}"] = c.pct_change(n)
f["range_pct"] = rng / c
f["body_pct"] = (c - df["open"]) / (rng + 1e-9)
f["close_pos"] = (c - df["low"]) / (rng + 1e-9)
f["ema_8_21"] = (c.ewm(span=8, adjust=False).mean() - c.ewm(span=21, adjust=False).mean()) / c
f["ema_21_55"] = (c.ewm(span=21, adjust=False).mean() - c.ewm(span=55, adjust=False).mean()) / c
f["volatility"] = c.pct_change().rolling(24).std()
f["volume_ratio"] = df["volume"] / (df["volume"].rolling(24).mean() + 1e-9)
return f.replace([np.inf, -np.inf], np.nan).dropna()
def train(data, config):
p = config.get("parameters", {{}})
df = _prep(data)
x = _features(df)
horizon = int(p.get("horizon", 4))
threshold = float(p.get("threshold", {threshold}))
fwd = df["close"].pct_change(horizon).shift(-horizon)
y = pd.Series(1, index=df.index)
y[fwd > threshold] = 2
y[fwd < -threshold] = 0
y = y.reindex(x.index).fillna(1).astype(int)
model = Pipeline([
("scaler", StandardScaler()),
("clf", LogisticRegression(max_iter=1000, class_weight="balanced")),
])
model.fit(x.values.astype(np.float32), y.values)
pred = model.predict(x.values.astype(np.float32))
return {{"model": model, "features": list(x.columns), "symbol": SYMBOL}}, {{"training_bars": int(len(x)), "feature_count": int(x.shape[1]), "buy_signals": int((pred == 2).sum()), "sell_signals": int((pred == 0).sum()), "hold_signals": int((pred == 1).sum())}}
def predict(model, market_data, config):
p = config.get("parameters", {{}})
candles = market_data.get("candles", [])
if len(candles) < int(p.get("lookback", {lookback})):
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "not_enough_candles", "model": MODEL_NAME}}}}
df = _prep(pd.DataFrame(candles, columns=["open", "high", "low", "close", "volume"]))
row = _features(df).tail(1)
if row.empty:
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "no_features", "model": MODEL_NAME}}}}
prob = model["model"].predict_proba(row[model["features"]].values.astype(np.float32))[0]
klass = int(np.argmax(prob))
conf = float(np.max(prob))
signal = {{0: "DOWN", 1: "HOLD", 2: "UP"}}[klass]
if conf < float(p.get("min_confidence", 0.48)):
signal = "HOLD"
return {{"signal": signal, "confidence": round(conf, 4), "metadata": {{"p_sell": round(float(prob[0]), 4), "p_hold": round(float(prob[1]), 4), "p_buy": round(float(prob[2]), 4), "model": MODEL_NAME, "symbol": SYMBOL}}}}
''',
"forest": '''import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
SYMBOL = "{symbol}"
MODEL_NAME = "{slug}"
def _prep(data):
df = data.copy()
df.columns = [str(c).strip().lower() for c in df.columns]
if "volume" not in df.columns:
df["volume"] = 1.0
for col in ["open", "high", "low", "close", "volume"]:
df[col] = pd.to_numeric(df[col], errors="coerce")
return df.dropna(subset=["open", "high", "low", "close"]).reset_index(drop=True)
def _features(df):
c = df["close"]
v = df["volume"]
f = pd.DataFrame(index=df.index)
for n in [1, 4, 8, 16, 32, 64]:
f[f"ret{{n}}"] = c.pct_change(n)
f["ema_12_48"] = (c.ewm(span=12, adjust=False).mean() - c.ewm(span=48, adjust=False).mean()) / c
f["ema_24_96"] = (c.ewm(span=24, adjust=False).mean() - c.ewm(span=96, adjust=False).mean()) / c
f["volatility_fast"] = c.pct_change().rolling(16).std()
f["volatility_slow"] = c.pct_change().rolling(64).std()
f["volatility_ratio"] = f["volatility_fast"] / (f["volatility_slow"] + 1e-9)
f["volume_z"] = (v - v.rolling(48).mean()) / (v.rolling(48).std() + 1e-9)
return f.replace([np.inf, -np.inf], np.nan).dropna()
def train(data, config):
p = config.get("parameters", {{}})
df = _prep(data)
x = _features(df)
horizon = int(p.get("horizon", 6))
threshold = float(p.get("threshold", {threshold}))
fwd = df["close"].pct_change(horizon).shift(-horizon)
y = pd.Series(1, index=df.index)
y[fwd > threshold] = 2
y[fwd < -threshold] = 0
y = y.reindex(x.index).fillna(1).astype(int)
model = Pipeline([
("scaler", StandardScaler()),
("clf", RandomForestClassifier(n_estimators=350, max_depth=8, min_samples_leaf=8, class_weight="balanced_subsample", random_state=42, n_jobs=-1)),
])
model.fit(x.values.astype(np.float32), y.values)
pred = model.predict(x.values.astype(np.float32))
return {{"model": model, "features": list(x.columns), "symbol": SYMBOL}}, {{"training_bars": int(len(x)), "feature_count": int(x.shape[1]), "buy_signals": int((pred == 2).sum()), "sell_signals": int((pred == 0).sum()), "hold_signals": int((pred == 1).sum())}}
def predict(model, market_data, config):
p = config.get("parameters", {{}})
candles = market_data.get("candles", [])
if len(candles) < int(p.get("lookback", {lookback})):
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "not_enough_candles", "model": MODEL_NAME}}}}
df = _prep(pd.DataFrame(candles, columns=["open", "high", "low", "close", "volume"]))
row = _features(df).tail(1)
if row.empty:
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "no_features", "model": MODEL_NAME}}}}
prob = model["model"].predict_proba(row[model["features"]].values.astype(np.float32))[0]
klass = int(np.argmax(prob))
conf = float(np.max(prob))
signal = {{0: "DOWN", 1: "HOLD", 2: "UP"}}[klass]
if conf < float(p.get("min_confidence", 0.5)):
signal = "HOLD"
return {{"signal": signal, "confidence": round(conf, 4), "metadata": {{"p_sell": round(float(prob[0]), 4), "p_hold": round(float(prob[1]), 4), "p_buy": round(float(prob[2]), 4), "model": MODEL_NAME, "symbol": SYMBOL}}}}
''',
"breakout": '''import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
SYMBOL = "{symbol}"
MODEL_NAME = "{slug}"
def _prep(data):
df = data.copy()
df.columns = [str(c).strip().lower() for c in df.columns]
if "volume" not in df.columns:
df["volume"] = 1.0
for col in ["open", "high", "low", "close", "volume"]:
df[col] = pd.to_numeric(df[col], errors="coerce")
return df.dropna(subset=["open", "high", "low", "close"]).reset_index(drop=True)
def _features(df):
c = df["close"]
h = df["high"]
l = df["low"]
f = pd.DataFrame(index=df.index)
high_break = h.rolling(36).max().shift()
low_break = l.rolling(36).min().shift()
f["breakout_up"] = (c - high_break) / c
f["breakout_down"] = (c - low_break) / c
f["ret4"] = c.pct_change(4)
f["ret12"] = c.pct_change(12)
f["volatility"] = c.pct_change().rolling(24).std()
f["range_pct"] = (h - l) / c
f["ema_slope"] = c.ewm(span=12, adjust=False).mean().pct_change(6)
return f.replace([np.inf, -np.inf], np.nan).dropna()
def train(data, config):
p = config.get("parameters", {{}})
df = _prep(data)
x = _features(df)
horizon = int(p.get("horizon", 4))
threshold = float(p.get("threshold", {threshold}))
fwd = df["close"].pct_change(horizon).shift(-horizon)
y = pd.Series(1, index=df.index)
y[fwd > threshold] = 2
y[fwd < -threshold] = 0
y = y.reindex(x.index).fillna(1).astype(int)
clf = RandomForestClassifier(n_estimators=300, max_depth=7, min_samples_leaf=6, class_weight="balanced_subsample", random_state=42, n_jobs=-1)
clf.fit(x.values.astype(np.float32), y.values)
pred = clf.predict(x.values.astype(np.float32))
return {{"model": clf, "features": list(x.columns), "symbol": SYMBOL}}, {{"training_bars": int(len(x)), "feature_count": int(x.shape[1]), "buy_signals": int((pred == 2).sum()), "sell_signals": int((pred == 0).sum()), "hold_signals": int((pred == 1).sum())}}
def predict(model, market_data, config):
p = config.get("parameters", {{}})
candles = market_data.get("candles", [])
if len(candles) < int(p.get("lookback", {lookback})):
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "not_enough_candles", "model": MODEL_NAME}}}}
df = _prep(pd.DataFrame(candles, columns=["open", "high", "low", "close", "volume"]))
row = _features(df).tail(1)
if row.empty:
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "no_features", "model": MODEL_NAME}}}}
prob = model["model"].predict_proba(row[model["features"]].values.astype(np.float32))[0]
klass = int(np.argmax(prob))
conf = float(np.max(prob))
signal = {{0: "DOWN", 1: "HOLD", 2: "UP"}}[klass]
if conf < float(p.get("min_confidence", 0.5)):
signal = "HOLD"
return {{"signal": signal, "confidence": round(conf, 4), "metadata": {{"p_sell": round(float(prob[0]), 4), "p_hold": round(float(prob[1]), 4), "p_buy": round(float(prob[2]), 4), "model": MODEL_NAME, "symbol": SYMBOL}}}}
''',
"mean_reversion": '''import numpy as np
import pandas as pd
SYMBOL = "{symbol}"
MODEL_NAME = "{slug}"
def _prep(data):
df = data.copy()
df.columns = [str(c).strip().lower() for c in df.columns]
if "volume" not in df.columns:
df["volume"] = 1.0
for col in ["open", "high", "low", "close", "volume"]:
df[col] = pd.to_numeric(df[col], errors="coerce")
return df.dropna(subset=["open", "high", "low", "close"]).reset_index(drop=True)
def _zscore(close, window):
mean = close.rolling(window).mean()
std = close.rolling(window).std()
return (close - mean) / (std + 1e-9)
def train(data, config):
p = config.get("parameters", {{}})
return {{"window": int(p.get("window", 48)), "entry_z": float(p.get("entry_z", 1.4)), "exit_z": float(p.get("exit_z", 0.3)), "symbol": SYMBOL}}, {{"model_family": "rule_based_mean_reversion", "training_bars": int(len(data))}}
def predict(model, market_data, config):
p = config.get("parameters", {{}})
candles = market_data.get("candles", [])
lookback = int(p.get("lookback", {lookback}))
if len(candles) < lookback:
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "not_enough_candles", "model": MODEL_NAME}}}}
df = _prep(pd.DataFrame(candles, columns=["open", "high", "low", "close", "volume"]))
window = int(model.get("window", p.get("window", 48)))
z = float(_zscore(df["close"], window).iloc[-1])
entry_z = float(model.get("entry_z", p.get("entry_z", 1.4)))
signal = "HOLD"
if z <= -entry_z:
signal = "UP"
elif z >= entry_z:
signal = "DOWN"
confidence = min(abs(z) / max(entry_z, 1e-9), 1.0)
return {{"signal": signal, "confidence": round(float(confidence), 4), "metadata": {{"zscore": round(z, 4), "window": window, "model": MODEL_NAME, "symbol": SYMBOL}}}}
''',
"atr_breakout": '''import numpy as np
import pandas as pd
SYMBOL = "{symbol}"
MODEL_NAME = "{slug}"
def _prep(data):
df = data.copy()
df.columns = [str(c).strip().lower() for c in df.columns]
if "volume" not in df.columns:
df["volume"] = 1.0
for col in ["open", "high", "low", "close", "volume"]:
df[col] = pd.to_numeric(df[col], errors="coerce")
return df.dropna(subset=["open", "high", "low", "close"]).reset_index(drop=True)
def _atr(df, n=14):
h, l, c = df["high"], df["low"], df["close"]
tr = pd.concat([(h - l), (h - c.shift()).abs(), (l - c.shift()).abs()], axis=1).max(axis=1)
return tr.ewm(span=n, adjust=False).mean()
def train(data, config):
p = config.get("parameters", {{}})
return {{"atr_window": int(p.get("atr_window", 14)), "breakout_window": int(p.get("breakout_window", 36)), "atr_mult": float(p.get("atr_mult", 0.25)), "symbol": SYMBOL}}, {{"model_family": "rule_based_atr_breakout", "training_bars": int(len(data))}}
def predict(model, market_data, config):
p = config.get("parameters", {{}})
candles = market_data.get("candles", [])
lookback = int(p.get("lookback", {lookback}))
if len(candles) < lookback:
return {{"signal": "HOLD", "confidence": 0.0, "metadata": {{"reason": "not_enough_candles", "model": MODEL_NAME}}}}
df = _prep(pd.DataFrame(candles, columns=["open", "high", "low", "close", "volume"]))
atr_window = int(model.get("atr_window", p.get("atr_window", 14)))
breakout_window = int(model.get("breakout_window", p.get("breakout_window", 36)))
atr_mult = float(model.get("atr_mult", p.get("atr_mult", 0.25)))
atr = _atr(df, atr_window)
close = float(df["close"].iloc[-1])
upper = float(df["high"].rolling(breakout_window).max().shift().iloc[-1] + atr.iloc[-1] * atr_mult)
lower = float(df["low"].rolling(breakout_window).min().shift().iloc[-1] - atr.iloc[-1] * atr_mult)
signal = "HOLD"
distance = 0.0
if close > upper:
signal = "UP"
distance = (close - upper) / max(atr.iloc[-1], 1e-9)
elif close < lower:
signal = "DOWN"
distance = (lower - close) / max(atr.iloc[-1], 1e-9)
confidence = min(max(distance, 0.0), 1.0)
return {{"signal": signal, "confidence": round(float(confidence), 4), "metadata": {{"upper": round(upper, 6), "lower": round(lower, 6), "close": round(close, 6), "model": MODEL_NAME, "symbol": SYMBOL}}}}
''',
}
def default_threshold(symbol: str, family: str) -> float:
if symbol.endswith("USDT"):
return 0.004 if family != "logistic" else 0.003
if symbol in {"XAUUSD", "XAGUSD", "XPTUSD", "WTICOUSD", "BRENTUSD", "NATGAS", "COPPERUSD"}:
return 0.003
if symbol in {"NAS100", "US30", "SPX500", "GER40", "UK100"}:
return 0.0025
if "JPY" in symbol:
return 0.0018
if symbol.endswith("MXN"):
return 0.003
return 0.0012
def default_lookback(timeframe: str, family: str) -> int:
if timeframe == "1m":
return 120
if timeframe in {"5m", "15m"}:
return 100
if timeframe == "30m":
return 120
if timeframe == "4h":
return 180
return 140
def readme(slug: str, symbol: str, timeframe: str, model_family: str, purpose: str) -> str:
return f"""# {slug}
{purpose} for PyP Quant Mode.
This is an educational starter template for `{symbol}` on the `{timeframe}` timeframe. It implements the PyP Quant contract:
```python
train(data, config)
predict(model, market_data, config)
```
Use it as a baseline, then validate with PPE before any live deployment.
## Model
- Symbol: `{symbol}`
- Timeframe: `{timeframe}`
- Family: `{model_family}`
- Output: `UP`, `DOWN`, or `HOLD`
## PyP Links
- Quant docs: https://pyp.stanl.ink/docs/quant/what-is-quant-mode
- Quant landing page: https://pyp.stanl.ink/for-quant-traders
- Create project: https://pyp.stanlink.online/projects/quant/new
## Risk
This is not financial advice and is not a verified profitable strategy.
"""
def config(slug: str, symbol: str, timeframe: str, model_family: str, family: str) -> dict:
threshold = default_threshold(symbol, family)
lookback = default_lookback(timeframe, family)
requirements = ["numpy", "pandas"]
if family == "logistic":
requirements.append("scikit-learn")
if family in {"forest", "breakout"}:
requirements.append("scikit-learn")
return {
"name": slug,
"description": f"{model_family} PyP Quant template for {symbol} {timeframe}.",
"symbol": symbol,
"timeframe": timeframe,
"model_family": model_family,
"artifact_target": "joblib" if family in {"logistic", "forest", "breakout"} else "python",
"parameters": {
"lookback": lookback,
"horizon": 4 if timeframe in {"1m", "5m", "15m", "30m"} else 6,
"threshold": threshold,
"min_confidence": 0.48 if family == "logistic" else 0.5,
"sl_percent": 0.4 if symbol.endswith("USDT") else 0.25,
"tp_percent": 0.8 if symbol.endswith("USDT") else 0.5,
},
"requirements": requirements,
"disclaimer": "Educational template only. Not financial advice.",
}
def main() -> None:
created = 0
for slug, symbol, timeframe, model_family, purpose, family in SPECS:
target = TEMPLATE_ROOT / slug
if target.exists():
continue
target.mkdir(parents=True)
threshold = default_threshold(symbol, family)
lookback = default_lookback(timeframe, family)
(target / "README.md").write_text(readme(slug, symbol, timeframe, model_family, purpose), encoding="utf-8")
(target / "quant.config.json").write_text(json.dumps(config(slug, symbol, timeframe, model_family, family), indent=2) + "\n", encoding="utf-8")
strategy = STRATEGIES[family].format(slug=slug, symbol=symbol, threshold=threshold, lookback=lookback)
(target / "strategy.py").write_text(strategy, encoding="utf-8")
created += 1
print(f"Created {created} templates")
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink