quantwave 0.5.2__py3-none-manylinux_2_34_aarch64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- quantwave/__init__.py +562 -0
- quantwave/_quantwave/__init__.py +1 -0
- quantwave/_quantwave/libquantwave_python.so +0 -0
- quantwave/_quantwave/quantwave_python.py +24608 -0
- quantwave/options.py +39 -0
- quantwave/polars.py +371 -0
- quantwave/results.py +32 -0
- quantwave/talib.py +30 -0
- quantwave-0.5.2.dist-info/METADATA +90 -0
- quantwave-0.5.2.dist-info/RECORD +13 -0
- quantwave-0.5.2.dist-info/WHEEL +4 -0
- quantwave-0.5.2.dist-info/licenses/LICENSE +21 -0
- quantwave-0.5.2.dist-info/sboms/quantwave-python.cyclonedx.json +6332 -0
quantwave/__init__.py
ADDED
|
@@ -0,0 +1,562 @@
|
|
|
1
|
+
"""
|
|
2
|
+
quantwave - High-performance technical analysis library (Python bindings).
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
from dataclasses import dataclass
|
|
6
|
+
from typing import Optional, List, Dict, Any
|
|
7
|
+
|
|
8
|
+
# Version
|
|
9
|
+
try:
|
|
10
|
+
from importlib.metadata import version, PackageNotFoundError
|
|
11
|
+
__version__ = version("quantwave")
|
|
12
|
+
except (PackageNotFoundError, Exception):
|
|
13
|
+
__version__ = "0.5.2.dev"
|
|
14
|
+
|
|
15
|
+
# Import everything from the Rust extension.
|
|
16
|
+
# Note: This still pollutes the namespace (a known issue being addressed in 0.5.2+).
|
|
17
|
+
# We are gradually cleaning this up.
|
|
18
|
+
from ._quantwave import * # noqa
|
|
19
|
+
from . import polars # noqa
|
|
20
|
+
|
|
21
|
+
# The ta namespace (Polars-style usage)
|
|
22
|
+
from . import ta # type: ignore
|
|
23
|
+
|
|
24
|
+
# New recommended namespaces (0.5.2+)
|
|
25
|
+
from . import results
|
|
26
|
+
from . import options
|
|
27
|
+
|
|
28
|
+
# Re-export key items from submodules for convenience (without polluting top level too badly)
|
|
29
|
+
# Users are encouraged to use quantwave.results.XXX and quantwave.options.XXX going forward.
|
|
30
|
+
|
|
31
|
+
import warnings
|
|
32
|
+
|
|
33
|
+
# =============================================================================
|
|
34
|
+
# Public Exception Hierarchy (quantwave-p3z9)
|
|
35
|
+
# =============================================================================
|
|
36
|
+
|
|
37
|
+
class QuantwaveError(Exception):
|
|
38
|
+
"""Base exception for all quantwave errors."""
|
|
39
|
+
pass
|
|
40
|
+
|
|
41
|
+
class InternalError(QuantwaveError):
|
|
42
|
+
"""Internal error (likely a bug). Please report it."""
|
|
43
|
+
pass
|
|
44
|
+
|
|
45
|
+
# --- Deprecation handling for old top-level access ---
|
|
46
|
+
_DEPRECATED_RESULTS = {
|
|
47
|
+
"MacdResult", "SuperTrendResult", "BbandsResult", "StochResult",
|
|
48
|
+
"IchimokuResult", "DonchianResult", "KeltnerResult", "PivotPointsResult",
|
|
49
|
+
# ... more will be added
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
_DEPRECATED_OPTIONS = {
|
|
53
|
+
"bs_call_price", "bs_delta", "bs_gamma", "max_pain", "chain_pcr",
|
|
54
|
+
"implied_vol", "nse_lot_size", "atm_straddle",
|
|
55
|
+
# etc.
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
def __getattr__(name: str):
|
|
59
|
+
if name in _DEPRECATED_RESULTS:
|
|
60
|
+
warnings.warn(
|
|
61
|
+
f"{name} is deprecated and will be removed in a future version. "
|
|
62
|
+
f"Use quantwave.results.{name} instead.",
|
|
63
|
+
DeprecationWarning,
|
|
64
|
+
stacklevel=2
|
|
65
|
+
)
|
|
66
|
+
return getattr(results, name)
|
|
67
|
+
|
|
68
|
+
if name in _DEPRECATED_OPTIONS:
|
|
69
|
+
warnings.warn(
|
|
70
|
+
f"{name} is deprecated and will be removed in a future version. "
|
|
71
|
+
f"Use quantwave.options.{name} instead.",
|
|
72
|
+
DeprecationWarning,
|
|
73
|
+
stacklevel=2
|
|
74
|
+
)
|
|
75
|
+
return getattr(options, name)
|
|
76
|
+
|
|
77
|
+
raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
|
|
78
|
+
|
|
79
|
+
|
|
80
|
+
# --- Basic Discovery API (quantwave-p3z9) ---
|
|
81
|
+
# This is a first-pass implementation. It will be backed by real metadata later.
|
|
82
|
+
|
|
83
|
+
def _build_indicator_names() -> set[str]:
|
|
84
|
+
"""Build the set of indicator names from the ta namespace."""
|
|
85
|
+
names = set()
|
|
86
|
+
for name in dir(ta):
|
|
87
|
+
if name.startswith("_"):
|
|
88
|
+
continue
|
|
89
|
+
obj = getattr(ta, name, None)
|
|
90
|
+
if callable(obj):
|
|
91
|
+
names.add(name)
|
|
92
|
+
return names
|
|
93
|
+
|
|
94
|
+
_INDICATOR_NAMES: set[str] = _build_indicator_names()
|
|
95
|
+
|
|
96
|
+
def indicators() -> list[str]:
|
|
97
|
+
"""Return a sorted list of all available indicator names."""
|
|
98
|
+
return sorted(_INDICATOR_NAMES)
|
|
99
|
+
|
|
100
|
+
def is_indicator(name: str) -> bool:
|
|
101
|
+
"""Check whether the given name is a known indicator."""
|
|
102
|
+
if not name:
|
|
103
|
+
return False
|
|
104
|
+
return name in _INDICATOR_NAMES or name.lower() in _INDICATOR_NAMES
|
|
105
|
+
|
|
106
|
+
|
|
107
|
+
# =============================================================================
|
|
108
|
+
# Rich Metadata API (quantwave-p3z9 - Critical)
|
|
109
|
+
# =============================================================================
|
|
110
|
+
|
|
111
|
+
@dataclass(frozen=True)
|
|
112
|
+
class IndicatorMeta:
|
|
113
|
+
"""Structured metadata for an indicator."""
|
|
114
|
+
name: str
|
|
115
|
+
required_params: List[str]
|
|
116
|
+
optional_params: Dict[str, Any] # name -> default value
|
|
117
|
+
data_inputs: List[str] # e.g. ["high", "low", "close"]
|
|
118
|
+
outputs: List[str]
|
|
119
|
+
warmup_bars: Optional[int] = None # Rough estimate or None if dynamic
|
|
120
|
+
category: Optional[str] = None
|
|
121
|
+
has_streaming: bool = True
|
|
122
|
+
has_polars: bool = True
|
|
123
|
+
description: Optional[str] = None
|
|
124
|
+
|
|
125
|
+
|
|
126
|
+
# Initial metadata registry (will grow significantly)
|
|
127
|
+
# This is the foundation for many other DX improvements.
|
|
128
|
+
_METADATA: Dict[str, IndicatorMeta] = {
|
|
129
|
+
"rsi": IndicatorMeta(
|
|
130
|
+
name="rsi",
|
|
131
|
+
required_params=["period"],
|
|
132
|
+
optional_params={},
|
|
133
|
+
data_inputs=["close"],
|
|
134
|
+
outputs=["rsi"],
|
|
135
|
+
warmup_bars=14,
|
|
136
|
+
category="Momentum",
|
|
137
|
+
description="Relative Strength Index",
|
|
138
|
+
),
|
|
139
|
+
"macd": IndicatorMeta(
|
|
140
|
+
name="macd",
|
|
141
|
+
required_params=[],
|
|
142
|
+
optional_params={"fast": 12, "slow": 26, "signal": 9},
|
|
143
|
+
data_inputs=["close"],
|
|
144
|
+
outputs=["macd", "signal", "histogram"],
|
|
145
|
+
warmup_bars=26,
|
|
146
|
+
category="Momentum",
|
|
147
|
+
description="Moving Average Convergence Divergence",
|
|
148
|
+
),
|
|
149
|
+
"supertrend": IndicatorMeta(
|
|
150
|
+
name="supertrend",
|
|
151
|
+
required_params=["period", "multiplier"],
|
|
152
|
+
optional_params={},
|
|
153
|
+
data_inputs=["high", "low", "close"],
|
|
154
|
+
outputs=["supertrend", "direction"],
|
|
155
|
+
warmup_bars=None, # Depends on ATR period
|
|
156
|
+
category="Volatility / Trend",
|
|
157
|
+
description="SuperTrend",
|
|
158
|
+
),
|
|
159
|
+
"atr": IndicatorMeta(
|
|
160
|
+
name="atr",
|
|
161
|
+
required_params=["period"],
|
|
162
|
+
optional_params={},
|
|
163
|
+
data_inputs=["high", "low", "close"],
|
|
164
|
+
outputs=["atr"],
|
|
165
|
+
warmup_bars=14,
|
|
166
|
+
category="Volatility",
|
|
167
|
+
description="Average True Range",
|
|
168
|
+
),
|
|
169
|
+
"bbands": IndicatorMeta(
|
|
170
|
+
name="bbands",
|
|
171
|
+
required_params=["period"],
|
|
172
|
+
optional_params={"std_dev": 2.0},
|
|
173
|
+
data_inputs=["close"],
|
|
174
|
+
outputs=["upper", "middle", "lower"],
|
|
175
|
+
warmup_bars=20,
|
|
176
|
+
category="Volatility",
|
|
177
|
+
description="Bollinger Bands",
|
|
178
|
+
),
|
|
179
|
+
"ema": IndicatorMeta(
|
|
180
|
+
name="ema",
|
|
181
|
+
required_params=["period"],
|
|
182
|
+
optional_params={},
|
|
183
|
+
data_inputs=["close"],
|
|
184
|
+
outputs=["ema"],
|
|
185
|
+
warmup_bars=20,
|
|
186
|
+
category="Overlap",
|
|
187
|
+
),
|
|
188
|
+
"sma": IndicatorMeta(
|
|
189
|
+
name="sma",
|
|
190
|
+
required_params=["period"],
|
|
191
|
+
optional_params={},
|
|
192
|
+
data_inputs=["close"],
|
|
193
|
+
outputs=["sma"],
|
|
194
|
+
warmup_bars=20,
|
|
195
|
+
category="Overlap",
|
|
196
|
+
),
|
|
197
|
+
"stoch": IndicatorMeta(
|
|
198
|
+
name="stoch",
|
|
199
|
+
required_params=["fastk", "slowk", "slowd"],
|
|
200
|
+
optional_params={},
|
|
201
|
+
data_inputs=["high", "low", "close"],
|
|
202
|
+
outputs=["slowk", "slowd"],
|
|
203
|
+
warmup_bars=14,
|
|
204
|
+
category="Momentum",
|
|
205
|
+
),
|
|
206
|
+
"willr": IndicatorMeta(
|
|
207
|
+
name="willr",
|
|
208
|
+
required_params=["period"],
|
|
209
|
+
optional_params={},
|
|
210
|
+
data_inputs=["high", "low", "close"],
|
|
211
|
+
outputs=["willr"],
|
|
212
|
+
warmup_bars=14,
|
|
213
|
+
category="Momentum",
|
|
214
|
+
),
|
|
215
|
+
"obv": IndicatorMeta(
|
|
216
|
+
name="obv",
|
|
217
|
+
required_params=[],
|
|
218
|
+
optional_params={},
|
|
219
|
+
data_inputs=["close", "volume"],
|
|
220
|
+
outputs=["obv"],
|
|
221
|
+
warmup_bars=1,
|
|
222
|
+
category="Volume",
|
|
223
|
+
),
|
|
224
|
+
}
|
|
225
|
+
|
|
226
|
+
|
|
227
|
+
def metadata(name: str) -> Optional[IndicatorMeta]:
|
|
228
|
+
"""
|
|
229
|
+
Return rich metadata for an indicator.
|
|
230
|
+
|
|
231
|
+
Returns None if the indicator is unknown.
|
|
232
|
+
This is the foundation for better tooling, docs, and UIs.
|
|
233
|
+
"""
|
|
234
|
+
key = name.lower()
|
|
235
|
+
return _METADATA.get(key)
|
|
236
|
+
|
|
237
|
+
|
|
238
|
+
def list_metadata() -> List[IndicatorMeta]:
|
|
239
|
+
"""Return metadata for all known indicators."""
|
|
240
|
+
return list(_METADATA.values())
|
|
241
|
+
|
|
242
|
+
|
|
243
|
+
def warmup_bars(name: str, params: dict = None) -> int:
|
|
244
|
+
"""
|
|
245
|
+
Return the approximate number of bars required before this indicator
|
|
246
|
+
produces reliable (non-warmup) output.
|
|
247
|
+
|
|
248
|
+
This is extremely useful for backtesting and rolling window calculations.
|
|
249
|
+
"""
|
|
250
|
+
meta = metadata(name)
|
|
251
|
+
if not meta:
|
|
252
|
+
return 0
|
|
253
|
+
|
|
254
|
+
if meta.warmup_bars is not None:
|
|
255
|
+
return meta.warmup_bars
|
|
256
|
+
|
|
257
|
+
# Dynamic calculation based on params
|
|
258
|
+
p = params or {}
|
|
259
|
+
max_period = 0
|
|
260
|
+
for key in ["period", "fast", "slow", "signal", "length", "fastk", "slowk", "slowd"]:
|
|
261
|
+
if key in p:
|
|
262
|
+
try:
|
|
263
|
+
max_period = max(max_period, int(p[key]))
|
|
264
|
+
except (ValueError, TypeError):
|
|
265
|
+
pass
|
|
266
|
+
|
|
267
|
+
if max_period > 0:
|
|
268
|
+
return max_period + 5 # small safety margin
|
|
269
|
+
|
|
270
|
+
return 20 # reasonable default for most indicators
|
|
271
|
+
|
|
272
|
+
|
|
273
|
+
# =============================================================================
|
|
274
|
+
# Streaming Class Lookup (quantwave-p3z9)
|
|
275
|
+
# =============================================================================
|
|
276
|
+
|
|
277
|
+
def streaming_class(name: str):
|
|
278
|
+
"""
|
|
279
|
+
Return the streaming (Next<T>) class for a given batch indicator name.
|
|
280
|
+
|
|
281
|
+
Example:
|
|
282
|
+
cls = quantwave.streaming_class("supertrend")
|
|
283
|
+
st = cls(period=10, multiplier=3.0)
|
|
284
|
+
"""
|
|
285
|
+
if not name:
|
|
286
|
+
return None
|
|
287
|
+
|
|
288
|
+
key = name.lower()
|
|
289
|
+
|
|
290
|
+
# Try direct attribute first (common case)
|
|
291
|
+
if hasattr(ta, key):
|
|
292
|
+
candidate = getattr(ta, key)
|
|
293
|
+
if isinstance(candidate, type):
|
|
294
|
+
return candidate
|
|
295
|
+
|
|
296
|
+
# Fallback: try common PascalCase conversions
|
|
297
|
+
pascal = "".join(word.capitalize() for word in key.split("_"))
|
|
298
|
+
if hasattr(ta, pascal) and isinstance(getattr(ta, pascal), type):
|
|
299
|
+
return getattr(ta, pascal)
|
|
300
|
+
|
|
301
|
+
# Last resort: search for anything that looks like a streaming class
|
|
302
|
+
for attr_name in dir(ta):
|
|
303
|
+
if attr_name.lower() == key or attr_name.lower().replace("_", "") == key.replace("_", ""):
|
|
304
|
+
obj = getattr(ta, attr_name)
|
|
305
|
+
if isinstance(obj, type):
|
|
306
|
+
return obj
|
|
307
|
+
|
|
308
|
+
return None
|
|
309
|
+
|
|
310
|
+
|
|
311
|
+
# =============================================================================
|
|
312
|
+
# Parity Testing Helper (quantwave-p3z9 - Critical)
|
|
313
|
+
# =============================================================================
|
|
314
|
+
|
|
315
|
+
def assert_parity(
|
|
316
|
+
indicator_name: str,
|
|
317
|
+
params: Dict[str, Any],
|
|
318
|
+
data: List[float],
|
|
319
|
+
tolerance: float = 1e-10,
|
|
320
|
+
**kwargs,
|
|
321
|
+
) -> bool:
|
|
322
|
+
"""
|
|
323
|
+
Run both batch and streaming versions of an indicator and assert
|
|
324
|
+
they produce (nearly) identical results.
|
|
325
|
+
|
|
326
|
+
Returns True if they match within tolerance.
|
|
327
|
+
Raises AssertionError with details on mismatch.
|
|
328
|
+
|
|
329
|
+
This is the first-class way for users and CI to verify the
|
|
330
|
+
"bit-identical" guarantee.
|
|
331
|
+
"""
|
|
332
|
+
batch_fn = getattr(ta, indicator_name, None)
|
|
333
|
+
if batch_fn is None:
|
|
334
|
+
raise ValueError(f"Unknown indicator: {indicator_name}")
|
|
335
|
+
|
|
336
|
+
streaming_cls = streaming_class(indicator_name)
|
|
337
|
+
if streaming_cls is None:
|
|
338
|
+
raise ValueError(f"No streaming class found for: {indicator_name}")
|
|
339
|
+
|
|
340
|
+
# Run batch
|
|
341
|
+
try:
|
|
342
|
+
batch_result = batch_fn(data, **params, **kwargs)
|
|
343
|
+
except Exception as e:
|
|
344
|
+
raise RuntimeError(f"Batch mode failed: {e}") from e
|
|
345
|
+
|
|
346
|
+
# Run streaming
|
|
347
|
+
try:
|
|
348
|
+
streamer = streaming_cls(**params, **kwargs)
|
|
349
|
+
stream_result = [streamer.next(v) for v in data]
|
|
350
|
+
except Exception as e:
|
|
351
|
+
raise RuntimeError(f"Streaming mode failed: {e}") from e
|
|
352
|
+
|
|
353
|
+
# Normalize for comparison (handle single vs multi output)
|
|
354
|
+
def _normalize(x):
|
|
355
|
+
if isinstance(x, (list, tuple)):
|
|
356
|
+
return x
|
|
357
|
+
return [x]
|
|
358
|
+
|
|
359
|
+
b = _normalize(batch_result)
|
|
360
|
+
s = _normalize(stream_result)
|
|
361
|
+
|
|
362
|
+
if len(b) != len(s):
|
|
363
|
+
raise AssertionError(f"Length mismatch: batch={len(b)}, stream={len(s)}")
|
|
364
|
+
|
|
365
|
+
for i, (bv, sv) in enumerate(zip(b, s)):
|
|
366
|
+
if isinstance(bv, (int, float)) and isinstance(sv, (int, float)):
|
|
367
|
+
if abs(bv - sv) > tolerance:
|
|
368
|
+
raise AssertionError(
|
|
369
|
+
f"Mismatch at index {i}: batch={bv}, stream={sv}, diff={abs(bv-sv)}"
|
|
370
|
+
)
|
|
371
|
+
else:
|
|
372
|
+
# For complex results (dataclasses), do a simple repr comparison for now
|
|
373
|
+
if repr(bv) != repr(sv):
|
|
374
|
+
raise AssertionError(f"Result mismatch at index {i}")
|
|
375
|
+
|
|
376
|
+
return True
|
|
377
|
+
|
|
378
|
+
# Nice namespace
|
|
379
|
+
class ta:
|
|
380
|
+
sma = sma
|
|
381
|
+
ema = ema
|
|
382
|
+
rsi = rsi
|
|
383
|
+
supertrend = SuperTrend
|
|
384
|
+
macd = Macd
|
|
385
|
+
atr = atr
|
|
386
|
+
adx = adx
|
|
387
|
+
cci = cci
|
|
388
|
+
stoch = stoch
|
|
389
|
+
aroon = Aroon
|
|
390
|
+
mama = Mama
|
|
391
|
+
kama = kama
|
|
392
|
+
t3 = T3
|
|
393
|
+
sar = sar
|
|
394
|
+
mom = mom
|
|
395
|
+
roc = roc
|
|
396
|
+
willr = willr
|
|
397
|
+
dema = dema
|
|
398
|
+
tema = tema
|
|
399
|
+
ichimoku = ichimoku
|
|
400
|
+
cg = cg
|
|
401
|
+
cybercycle = cybercycle
|
|
402
|
+
fisher = fisher
|
|
403
|
+
inverse_fisher = inversefisher
|
|
404
|
+
supersmoother = supersmoother
|
|
405
|
+
bandpass = bandpass
|
|
406
|
+
roofing_filter = roofingfilter
|
|
407
|
+
zerolag = zerolag
|
|
408
|
+
choppiness_index = choppinessindex
|
|
409
|
+
classic_laguerre = classiclaguerre
|
|
410
|
+
alligator = Alligator
|
|
411
|
+
alma = alma
|
|
412
|
+
atr_ts = AtrTs
|
|
413
|
+
butterworth2 = butterworth2
|
|
414
|
+
butterworth3 = butterworth3
|
|
415
|
+
channel_cycle = channelcycle
|
|
416
|
+
continuation_index = continuationindex
|
|
417
|
+
correlation_cycle = correlationcycle
|
|
418
|
+
correlation_trend = correlationtrend
|
|
419
|
+
cybernetic_oscillator = cyberneticoscillator
|
|
420
|
+
dmh = dmh
|
|
421
|
+
donchian = donchian
|
|
422
|
+
dsma = dsma
|
|
423
|
+
emd = emd
|
|
424
|
+
frama = frama
|
|
425
|
+
am_detector = amdetector
|
|
426
|
+
fm_demodulator = fmdemodulator
|
|
427
|
+
ehlers_autocorrelation = ehlersautocorrelation
|
|
428
|
+
ehlers_filter = ehlersfilter
|
|
429
|
+
ehlers_loops = ehlersloops
|
|
430
|
+
ehlers_stochastic = ehlersstochastic
|
|
431
|
+
ehlers_ultimate_oscillator = ehlersultimateoscillator
|
|
432
|
+
fisher_high_pass = fisherhighpass
|
|
433
|
+
fourier_series = fourierseries
|
|
434
|
+
fourier_dominant_cycle = fourierdominantcycle
|
|
435
|
+
fractals = fractals
|
|
436
|
+
gaussian = gaussian
|
|
437
|
+
generalized_laguerre = generalizedlaguerre
|
|
438
|
+
griffiths_dominant_cycle = griffithsdominantcycle
|
|
439
|
+
griffiths_predictor = griffithspredictor
|
|
440
|
+
griffiths_spectrum = griffithsspectrum
|
|
441
|
+
hamming = hamming
|
|
442
|
+
hann = hann
|
|
443
|
+
heikin_ashi = heikin_ashi
|
|
444
|
+
high_pass = highpass
|
|
445
|
+
hma = hma
|
|
446
|
+
ehlers_wma4 = ehlerswma4
|
|
447
|
+
instantaneous_trendline = instantaneoustrendline
|
|
448
|
+
undersampled_double_ma = undersampleddoublema
|
|
449
|
+
keltner = keltner
|
|
450
|
+
laguerre_filter = laguerrefilter
|
|
451
|
+
laguerre_oscillator = laguerreoscillator
|
|
452
|
+
laguerre_rsi = laguerrersi
|
|
453
|
+
noise_elimination = noiseelimination
|
|
454
|
+
pairs_rotation = pairsrotation
|
|
455
|
+
phasor = phasor
|
|
456
|
+
oc_price_rsi = ocpricersi
|
|
457
|
+
pivot_points = pivot_points
|
|
458
|
+
one_euro_filter = oneeurofilter
|
|
459
|
+
projected_moving_average = projectedmovingaverage
|
|
460
|
+
precision_trend = precisiontrend
|
|
461
|
+
reversion_index = reversionindex
|
|
462
|
+
sine_wave = sinewave
|
|
463
|
+
swiss_army_knife = swiss_army_knife
|
|
464
|
+
system_evaluator = systemevaluator
|
|
465
|
+
ttm_squeeze = ttmsqueeze
|
|
466
|
+
ultimate_bands = ultimate_bands
|
|
467
|
+
ultimate_channel = ultimate_channel
|
|
468
|
+
ultimate_smoother = ultimatesmoother
|
|
469
|
+
usi = usi
|
|
470
|
+
ad = ad
|
|
471
|
+
adosc = adosc
|
|
472
|
+
obv = obv
|
|
473
|
+
vortex = vortex
|
|
474
|
+
anchored_vwap = anchored_vwap
|
|
475
|
+
wavetrend = wavetrend
|
|
476
|
+
simple_predictor = simplepredictor
|
|
477
|
+
mad = mad
|
|
478
|
+
mesa_stochastic = mesastochastic
|
|
479
|
+
rsih = rsih
|
|
480
|
+
voss_predictor = vosspredictor
|
|
481
|
+
synthetic_oscillator = syntheticoscillator
|
|
482
|
+
cycle_trend_analytics = cycletrendanalytics
|
|
483
|
+
madh = madh
|
|
484
|
+
stc = stc
|
|
485
|
+
homodyne_discriminator = homodynediscriminator
|
|
486
|
+
universal_oscillator = universaloscillator
|
|
487
|
+
triangle_filter = trianglefilter
|
|
488
|
+
ht_dc_period = htdcperiod
|
|
489
|
+
ht_phasor = htphasor
|
|
490
|
+
ht_dc_phase = htdcphase
|
|
491
|
+
ht_sine = htsine
|
|
492
|
+
ht_trend_mode = httrendmode
|
|
493
|
+
hurst_exponent = hurstexponent
|
|
494
|
+
kalman_filter = kalmanfilter
|
|
495
|
+
market_state = marketstate
|
|
496
|
+
recursive_median = recursivemedian
|
|
497
|
+
recursive_median_oscillator = recursivemedianoscillator
|
|
498
|
+
reflex = reflex
|
|
499
|
+
rocket_rsi = rocketrsi
|
|
500
|
+
trendflex = trendflex
|
|
501
|
+
truncated_bandpass = truncatedbandpass
|
|
502
|
+
# ML features (gw7s notebook + harness + 4ps/gwx cross-epic deliverable)
|
|
503
|
+
cyber_cycle_feature_extractor = CyberCycleFeatureExtractor
|
|
504
|
+
hurst_feature_extractor = HurstFeatureExtractor
|
|
505
|
+
instantaneous_trendline_feature_extractor = InstantaneousTrendlineFeatureExtractor
|
|
506
|
+
trendflex_feature_extractor = TrendflexFeatureExtractor
|
|
507
|
+
regime_to_features = regime_to_features
|
|
508
|
+
# Newly wired for the E2E notebook (trivial parallel to above; completes the locked .ta.features.* surface in Python)
|
|
509
|
+
griffiths_dominant_cycle_feature_extractor = GriffithsDominantCycleFeatureExtractor
|
|
510
|
+
bull_bear_hmm = BullBearHMM
|
|
511
|
+
griffiths_dominant_cycle_features = griffiths_dominant_cycle_features # batch helper
|
|
512
|
+
volume_profile = volumeprofile
|
|
513
|
+
|
|
514
|
+
class options_india:
|
|
515
|
+
bs_call_price = bs_call_price
|
|
516
|
+
bs_put_price = bs_put_price
|
|
517
|
+
bs_delta = bs_delta
|
|
518
|
+
bs_gamma = bs_gamma
|
|
519
|
+
bs_theta = bs_theta
|
|
520
|
+
bs_vega = bs_vega
|
|
521
|
+
bs_rho = bs_rho
|
|
522
|
+
implied_vol = implied_vol
|
|
523
|
+
max_pain = max_pain
|
|
524
|
+
strike_pcr = strike_pcr
|
|
525
|
+
chain_pcr = chain_pcr
|
|
526
|
+
oi_zones = oi_zones
|
|
527
|
+
gex_per_strike = gex_per_strike
|
|
528
|
+
gex_flip_strike = gex_flip_strike
|
|
529
|
+
atm_straddle = atm_straddle
|
|
530
|
+
synthetic_futures = synthetic_futures
|
|
531
|
+
moneyness = moneyness
|
|
532
|
+
nse_lot_size = nse_lot_size
|
|
533
|
+
nse_risk_free_rate = nse_risk_free_rate
|
|
534
|
+
|
|
535
|
+
__all__ = [
|
|
536
|
+
"ta", "options_india", "Sma", "Ema", "Rsi", "SuperTrend", "Macd", "Atr", "Adx", "Cci", "Stoch",
|
|
537
|
+
"Aroon", "Mama", "Kama", "T3", "Sar", "Mom", "Roc", "Willr", "Dema", "Tema",
|
|
538
|
+
"Ichimoku", "Cg", "CyberCycle", "Fisher", "InverseFisher", "SuperSmoother",
|
|
539
|
+
"Bandpass", "RoofingFilter", "ZeroLag", "ChoppinessIndex", "ClassicLaguerre",
|
|
540
|
+
"Alligator", "AtrTs", "Aroon", "Donchian", "Emd", "ChannelCycle", "CorrelationCycle",
|
|
541
|
+
"EhlersAutocorrelation", "EhlersFilter", "EhlersLoops", "EhlersStochastic",
|
|
542
|
+
"EhlersUltimateOscillator", "FisherHighPass", "FourierSeries", "FourierDominantCycle",
|
|
543
|
+
"Fractals", "Gaussian", "GeneralizedLaguerre", "GriffithsDominantCycle",
|
|
544
|
+
"GriffithsPredictor", "GriffithsSpectrum", "Hamming", "Hann", "HeikinAshi",
|
|
545
|
+
"HighPass", "Hma", "EhlersWma4", "InstantaneousTrendline", "UndersampledDoubleMa",
|
|
546
|
+
"Keltner", "LaguerreFilter", "LaguerreOscillator", "LaguerreRsi", "NoiseElimination",
|
|
547
|
+
"PairsRotation", "Phasor", "OcPriceRsi", "PivotPoints", "OneEuroFilter",
|
|
548
|
+
"ProjectedMovingAverage", "PrecisionTrend", "ReversionIndex", "SineWave",
|
|
549
|
+
"SwissArmyKnife", "SystemEvaluator", "RobustnessEvaluator", "TtmSqueeze",
|
|
550
|
+
"UltimateBands", "UltimateChannel", "UltimateSmoother", "Usi", "Ad", "Adosc", "Obv",
|
|
551
|
+
"Vortex", "AnchoredVwap", "WaveTrend", "SimplePredictor", "Mad", "MesaStochastic",
|
|
552
|
+
"Rsih", "VossPredictor", "SyntheticOscillator", "CycleTrendAnalytics", "Madh", "Stc",
|
|
553
|
+
"HomodyneDiscriminator", "UniversalOscillator", "TriangleFilter",
|
|
554
|
+
"HtDcPeriod", "HtPhasor", "HtDcPhase", "HtSine", "HtTrendMode",
|
|
555
|
+
"HurstExponent", "KalmanFilter", "MarketState", "RecursiveMedian",
|
|
556
|
+
"RecursiveMedianOscillator", "Reflex", "RocketRsi", "Trendflex",
|
|
557
|
+
"TruncatedBandpass", "VolumeProfile",
|
|
558
|
+
# ML feature toolkit (quantwave-gw7s)
|
|
559
|
+
"CyberCycleFeatureExtractor", "HurstFeatureExtractor",
|
|
560
|
+
"InstantaneousTrendlineFeatureExtractor", "TrendflexFeatureExtractor",
|
|
561
|
+
"regime_to_features"
|
|
562
|
+
]
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
from .quantwave_python import * # NOQA
|
|
Binary file
|