nextrade-engine 0.7.0__tar.gz → 0.8.0__tar.gz

{nextrade_engine-0.7.0/nextrade/nextrade_engine.egg-info → nextrade_engine-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrade-engine
-Version: 0.7.0
+Version: 0.8.0
 Summary: AI Trading Engine — Ringan, Multi-Market, Bisa di HP
 Author-email: NexTrade <wafiqrazy035@gmail.com>
 License-Expression: MIT
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: yfinance
 Requires-Dist: scikit-learn
+Requires-Dist: nexarray
 Dynamic: license-file
 
 # NexTrade 🧠

{nextrade_engine-0.7.0 → nextrade_engine-0.8.0}/nextrade/nextrade/core/regime.py

@@ -29,7 +29,7 @@ def detect_regime(close: np.ndarray, period: int = 20) -> dict:
     trend_strength = abs(slope) / (np.std(window) + 1e-9)
 
     # 2. Volatility — ATR proxy pakai std returns
-    returns = np.diff(window) / (window[:-1] + 1e-9)
+    window_arr = np.array(window); returns = np.diff(window_arr) / (window_arr[:-1] + 1e-9)
     volatility = np.std(returns) * 100  # dalam persen
 
     # 3. Range ratio — seberapa besar range vs body rata-rata
@@ -60,4 +60,4 @@ def detect_regime_series(close: np.ndarray, period: int = 20) -> np.ndarray:
     for i in range(period, len(close)):
         r = detect_regime(close[max(0, i-period):i+1], period)
         regimes[i] = r["regime"]
-    return regimes
+    return regimes

nextrade_engine-0.8.0/nextrade/nextrade/indicators/adaptive.py

@@ -0,0 +1,99 @@
+"""
+NexTrade v0.8.0 — Adaptive Indicators
+Menggunakan NexArray bukan NumPy!
+"""
+import sys
+sys.path.insert(0, '/home/claude/nexarray')
+
+try:
+    import nexarray as nx
+    HAS_NX = True
+except ImportError:
+    HAS_NX = False
+
+from nextrade.core.regime import detect_regime, MarketRegime
+
+def _to_list(data) -> list:
+    if HAS_NX and hasattr(data, '_data'):
+        return list(data._data)
+    try:
+        return list(data)
+    except:
+        return data
+
+def adaptive_period(close, base: int = 14,
+                    min_p: int = 5, max_p: int = 30) -> int:
+    close_list = _to_list(close)
+    r   = detect_regime(close_list)
+    vol = r["volatility"]
+    if vol > 2.0:   return min_p
+    elif vol < 0.5: return max_p
+    ratio = (vol - 0.5) / (2.0 - 0.5)
+    return int(max_p - ratio * (max_p - min_p))
+
+def adaptive_rsi(close) -> float:
+    close_list = _to_list(close)
+    period = adaptive_period(close_list)
+    if len(close_list) < period + 1:
+        return 50.0
+
+    if HAS_NX:
+        # Pakai NexArray!
+        arr    = nx.array(close_list[-period-1:])
+        delta  = nx.diff(arr)
+        gain   = nx.where(delta > 0, delta, nx.array([0.0]*delta.size))
+        loss   = nx.where(delta < 0, delta * -1, nx.array([0.0]*delta.size))
+        avg_g  = gain.mean() + 1e-9
+        avg_l  = loss.mean() + 1e-9
+        rs     = avg_g / avg_l
+        return round(float(100 - 100 / (1 + rs)), 2)
+    else:
+        seg   = close_list[-period-1:]
+        delta = [seg[i]-seg[i-1] for i in range(1, len(seg))]
+        gain  = [max(d, 0) for d in delta]
+        loss  = [max(-d, 0) for d in delta]
+        avg_g = sum(gain)/len(gain) + 1e-9
+        avg_l = sum(loss)/len(loss) + 1e-9
+        return round(100 - 100/(1 + avg_g/avg_l), 2)
+
+def adaptive_ema(close) -> float:
+    close_list = _to_list(close)
+    period = adaptive_period(close_list)
+    if len(close_list) < period:
+        return float(close_list[-1])
+    k   = 2 / (period + 1)
+    ema = float(close_list[-period])
+    for price in close_list[-period+1:]:
+        ema = price * k + ema * (1 - k)
+    return round(ema, 6)
+
+def momentum_score(close) -> float:
+    close_list = _to_list(close)
+
+    if HAS_NX:
+        arr    = nx.array(close_list)
+        rsi    = adaptive_rsi(close_list)
+        ema    = adaptive_ema(close_list)
+        price  = close_list[-1]
+        pct    = (price - ema) / (ema + 1e-9) * 100
+        ema_sc = min(max(50 + pct * 10, 0), 100)
+        period = max(5, len(close_list) // 10)
+        if len(close_list) > period:
+            roc    = (price - close_list[-period]) / (close_list[-period]+1e-9)*100
+            roc_sc = min(max(50 + roc * 5, 0), 100)
+        else:
+            roc_sc = 50.0
+        score = rsi*0.4 + ema_sc*0.3 + roc_sc*0.3
+        return round(float(score), 2)
+    else:
+        rsi   = adaptive_rsi(close_list)
+        ema   = adaptive_ema(close_list)
+        price = close_list[-1]
+        pct   = (price - ema) / (ema + 1e-9) * 100
+        ema_sc = min(max(50 + pct*10, 0), 100)
+        period = max(5, len(close_list)//10)
+        roc_sc = 50.0
+        if len(close_list) > period:
+            roc    = (price-close_list[-period])/(close_list[-period]+1e-9)*100
+            roc_sc = min(max(50+roc*5, 0), 100)
+        return round(rsi*0.4 + ema_sc*0.3 + roc_sc*0.3, 2)

nextrade_engine-0.8.0/nextrade/nextrade/indicators/confluence.py

@@ -0,0 +1,91 @@
+"""
+NexTrade v0.8.0 — Confluence Score
+Gabungkan semua indikator — NexArray powered!
+"""
+import sys
+sys.path.insert(0, '/home/claude/nexarray')
+
+try:
+    import nexarray as nx
+    HAS_NX = True
+except ImportError:
+    HAS_NX = False
+
+from nextrade.core.regime import detect_regime, MarketRegime
+from nextrade.indicators.adaptive import adaptive_rsi, momentum_score
+from nextrade.indicators.pattern import pattern_score
+
+def _to_list(data) -> list:
+    if hasattr(data, '_data'): return list(data._data)
+    try: return list(data)
+    except: return data
+
+def confluence_score(opens, highs, lows, closes) -> dict:
+    cl = _to_list(closes)
+
+    # Regime detection
+    regime_data = detect_regime(cl)
+    regime      = regime_data["regime"]
+
+    # Momentum & RSI
+    mom = momentum_score(cl)
+    rsi = adaptive_rsi(cl)
+
+    # NexArray trading indicators
+    if HAS_NX:
+        nx_c   = nx.array(cl)
+        grav   = nx.gravity(nx_c, 20)
+        snap   = nx.snap(nx_c, 5)
+        wave   = nx.momentum_wave(nx_c, 5, 20)
+        grav_v = float(grav._data[-1])
+        snap_v = float(snap._data[-1])
+        wave_v = float(wave._data[-1])
+    else:
+        grav_v = snap_v = wave_v = 0.0
+
+    # Pattern
+    pat = pattern_score(opens, highs, lows, closes)
+
+    # Bobot berdasarkan regime
+    if regime == MarketRegime.TRENDING:
+        w_mom, w_pat, w_rsi, w_nx = 0.4, 0.25, 0.15, 0.20
+    elif regime == MarketRegime.RANGING:
+        w_mom, w_pat, w_rsi, w_nx = 0.15, 0.45, 0.25, 0.15
+    else:
+        w_mom, w_pat, w_rsi, w_nx = 0.25, 0.35, 0.25, 0.15
+
+    # NexArray score
+    nx_score = 50.0
+    if HAS_NX:
+        nx_score  = 50.0
+        nx_score -= grav_v * 10      # gravity — jauh dari mean = reversal
+        nx_score += wave_v * 0.5     # momentum wave
+        nx_score += snap_v * 5       # snap detection
+        nx_score  = min(max(nx_score, 0), 100)
+
+    raw = (mom * w_mom + pat["total"] * w_pat +
+           rsi * w_rsi + nx_score * w_nx)
+    confidence = round(float(min(max(raw, 0), 100)), 2)
+
+    if confidence >= 62 and pat["direction"] != "bear":
+        signal = "BUY"
+    elif confidence <= 38 or pat["direction"] == "bear":
+        signal = "SELL"
+    else:
+        signal = "HOLD"
+
+    return {
+        "signal"    : signal,
+        "confidence": confidence,
+        "regime"    : regime,
+        "details"   : {
+            "momentum"  : round(mom, 2),
+            "rsi"       : round(rsi, 2),
+            "pattern"   : pat,
+            "regime"    : regime_data,
+            "nx_gravity": round(grav_v, 4),
+            "nx_snap"   : snap_v,
+            "nx_wave"   : round(wave_v, 4),
+            "nx_score"  : round(nx_score, 2),
+        }
+    }

nextrade_engine-0.8.0/nextrade/nextrade/indicators/pattern.py

@@ -0,0 +1,82 @@
+"""
+NexTrade v0.8.0 — Pattern Scorer
+Menggunakan NexArray bukan NumPy!
+"""
+import sys
+sys.path.insert(0, '/home/claude/nexarray')
+
+try:
+    import nexarray as nx
+    HAS_NX = True
+except ImportError:
+    HAS_NX = False
+
+def _f(x) -> float:
+    return float(x._data[-1] if hasattr(x,'_data') else x)
+
+def hammer_score(open_: float, high: float,
+                 low: float, close: float) -> float:
+    body  = abs(close - open_)
+    rng   = high - low + 1e-9
+    lower = min(open_, close) - low
+    upper = high - max(open_, close)
+    score = 0.0
+    score += min((lower/rng)/0.6, 1.0) * 50
+    score += max(1 - (body/rng)/0.3, 0) * 30
+    score += max(1 - upper/(rng*0.1+1e-9), 0) * 20
+    return round(min(score, 100.0), 2)
+
+def engulfing_score(prev_o, prev_c, curr_o, curr_c) -> tuple:
+    pb = abs(float(prev_c)-float(prev_o))
+    cb = abs(float(curr_c)-float(curr_o))
+    if pb == 0: return 0.0, "none"
+    ratio  = cb / (pb + 1e-9)
+    is_bull = prev_c < prev_o and curr_c > curr_o and curr_o < prev_c and curr_c > prev_o
+    is_bear = prev_c > prev_o and curr_c < curr_o and curr_o > prev_c and curr_c < prev_o
+    if not (is_bull or is_bear): return 0.0, "none"
+    score = min(ratio * 60, 80) + 20
+    return round(min(score, 100.0), 2), "bull" if is_bull else "bear"
+
+def pattern_score(opens, highs, lows, closes) -> dict:
+    def _get(arr, idx):
+        if hasattr(arr, '_data'): return float(arr._data[idx])
+        return float(arr[idx])
+
+    n = len(closes) if not hasattr(closes,'_data') else closes.size
+    if n < 2:
+        return {"total":50.0,"hammer":0.0,"engulfing":0.0,"direction":"neutral"}
+
+    o  = _get(opens,  -1)
+    h  = _get(highs,  -1)
+    l  = _get(lows,   -1)
+    c  = _get(closes, -1)
+    po = _get(opens,  -2)
+    pc = _get(closes, -2)
+
+    if HAS_NX:
+        # Pakai NexArray peak/valley untuk context
+        c_arr = nx.array(list(closes._data) if hasattr(closes,'_data') else list(closes))
+        peaks  = nx.peak(c_arr, order=2)
+        valleys= nx.valley(c_arr, order=2)
+        at_peak   = float(peaks._data[-3]) == 1.0
+        at_valley = float(valleys._data[-3]) == 1.0
+    else:
+        at_peak = at_valley = False
+
+    h_score = hammer_score(o, h, l, c)
+    e_score, e_dir = engulfing_score(po, pc, o, c)
+
+    if e_dir == "bull" or (h_score > 50 and c > o):
+        direction = "bull"
+    elif e_dir == "bear" or (h_score > 50 and c < o):
+        direction = "bear"
+    else:
+        direction = "neutral"
+
+    # Boost score kalau di peak/valley
+    total = max(h_score, e_score)
+    if at_valley and direction == "bull": total = min(total * 1.2, 100)
+    if at_peak   and direction == "bear": total = min(total * 1.2, 100)
+
+    return {"total": total, "hammer": h_score,
+            "engulfing": e_score, "direction": direction}

{nextrade_engine-0.7.0 → nextrade_engine-0.8.0/nextrade/nextrade_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextrade-engine
-Version: 0.7.0
+Version: 0.8.0
 Summary: AI Trading Engine — Ringan, Multi-Market, Bisa di HP
 Author-email: NexTrade <wafiqrazy035@gmail.com>
 License-Expression: MIT
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: yfinance
 Requires-Dist: scikit-learn
+Requires-Dist: nexarray
 Dynamic: license-file
 
 # NexTrade 🧠

{nextrade_engine-0.7.0 → nextrade_engine-0.8.0}/nextrade/nextrade_engine.egg-info/requires.txt

@@ -1,3 +1,4 @@
 numpy
 yfinance
 scikit-learn
+nexarray

{nextrade_engine-0.7.0 → nextrade_engine-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nextrade-engine"
-version = "0.7.0"
+version = "0.8.0"
 description = "AI Trading Engine — Ringan, Multi-Market, Bisa di HP"
 readme = "README.md"
 license = "MIT"
@@ -20,8 +20,9 @@ classifiers = [
 requires-python = ">=3.8"
 dependencies = [
     "numpy",
-    "yfinance",
+    "yfinance", 
     "scikit-learn",
+    "nexarray",
 ]
 
 [tool.setuptools]

nextrade_engine-0.7.0/nextrade/nextrade/indicators/adaptive.py

@@ -1,73 +0,0 @@
-"""
-NexTrade — Adaptive Indicators
-Indikator khas AI yang menyesuaikan diri dengan kondisi pasar.
-"""
-import numpy as np
-from nextrade.core.regime import detect_regime, MarketRegime
-
-def adaptive_period(close: np.ndarray, base: int = 14, 
-                    min_p: int = 5, max_p: int = 30) -> int:
-    """Hitung periode optimal berdasarkan volatilitas pasar saat ini."""
-    r = detect_regime(close)
-    vol = r["volatility"]
-    # Volatile → periode pendek (lebih responsif)
-    # Tenang   → periode panjang (lebih halus)
-    if vol > 2.0:
-        return min_p
-    elif vol < 0.5:
-        return max_p
-    else:
-        # Interpolasi linear
-        ratio = (vol - 0.5) / (2.0 - 0.5)
-        return int(max_p - ratio * (max_p - min_p))
-
-def adaptive_rsi(close: np.ndarray) -> float:
-    """RSI dengan periode adaptif berdasarkan volatilitas."""
-    period = adaptive_period(close)
-    if len(close) < period + 1:
-        return 50.0
-    delta = np.diff(close[-period-1:])
-    gain = np.where(delta > 0, delta, 0.0)
-    loss = np.where(delta < 0, -delta, 0.0)
-    avg_gain = np.mean(gain) + 1e-9
-    avg_loss = np.mean(loss) + 1e-9
-    rs = avg_gain / avg_loss
-    return round(float(100 - 100 / (1 + rs)), 2)
-
-def adaptive_ema(close: np.ndarray) -> float:
-    """EMA dengan periode adaptif."""
-    period = adaptive_period(close)
-    if len(close) < period:
-        return float(close[-1])
-    k = 2 / (period + 1)
-    ema = float(close[-period])
-    for price in close[-period+1:]:
-        ema = price * k + ema * (1 - k)
-    return round(ema, 6)
-
-def momentum_score(close: np.ndarray) -> float:
-    """
-    Skor momentum 0-100 berdasarkan:
-    - Adaptive RSI
-    - Posisi harga vs EMA
-    - Kecepatan pergerakan (Rate of Change)
-    """
-    rsi = adaptive_rsi(close)
-    ema = adaptive_ema(close)
-    price = float(close[-1])
-
-    # Price vs EMA score (0-100)
-    pct_from_ema = (price - ema) / (ema + 1e-9) * 100
-    ema_score = min(max(50 + pct_from_ema * 10, 0), 100)
-
-    # Rate of Change score
-    period = max(5, len(close) // 10)
-    if len(close) > period:
-        roc = (price - float(close[-period])) / (float(close[-period]) + 1e-9) * 100
-        roc_score = min(max(50 + roc * 5, 0), 100)
-    else:
-        roc_score = 50.0
-
-    # Gabungkan: RSI 40% + EMA 30% + ROC 30%
-    score = rsi * 0.4 + ema_score * 0.3 + roc_score * 0.3
-    return round(float(score), 2)

nextrade_engine-0.7.0/nextrade/nextrade/indicators/confluence.py

@@ -1,61 +0,0 @@
-"""
-NexTrade — Confluence Score
-Gabungkan semua indikator AI menjadi 1 skor sinyal final.
-"""
-import numpy as np
-from nextrade.core.regime import detect_regime, MarketRegime
-from nextrade.indicators.adaptive import adaptive_rsi, momentum_score
-from nextrade.indicators.pattern import pattern_score
-
-def confluence_score(opens: np.ndarray, highs: np.ndarray,
-                     lows: np.ndarray, closes: np.ndarray) -> dict:
-    """
-    Hitung confluence score dari semua indikator AI.
-    Returns: { signal, confidence, regime, details }
-    """
-    close = closes
-
-    # Layer 1: Regime
-    regime_data = detect_regime(close)
-    regime = regime_data["regime"]
-
-    # Layer 2: Momentum
-    mom = momentum_score(close)
-    rsi = adaptive_rsi(close)
-
-    # Layer 3: Pattern
-    pat = pattern_score(opens, highs, lows, closes)
-
-    # Bobot berdasarkan regime
-    if regime == MarketRegime.TRENDING:
-        w_mom, w_pat, w_rsi = 0.5, 0.3, 0.2
-    elif regime == MarketRegime.RANGING:
-        w_mom, w_pat, w_rsi = 0.2, 0.5, 0.3
-    else:  # VOLATILE
-        w_mom, w_pat, w_rsi = 0.3, 0.4, 0.3
-
-    # Normalisasi RSI ke 0-100 bull/bear
-    rsi_score = rsi  # sudah 0-100, > 50 = bullish
-
-    raw = mom * w_mom + pat["total"] * w_pat + rsi_score * w_rsi
-    confidence = round(float(min(max(raw, 0), 100)), 2)
-
-    # Tentukan sinyal
-    if confidence >= 62 and pat["direction"] != "bear":
-        signal = "BUY"
-    elif confidence <= 38 or pat["direction"] == "bear":
-        signal = "SELL"
-    else:
-        signal = "HOLD"
-
-    return {
-        "signal"    : signal,
-        "confidence": confidence,
-        "regime"    : regime,
-        "details"   : {
-            "momentum" : round(mom, 2),
-            "rsi"      : round(rsi, 2),
-            "pattern"  : pat,
-            "regime"   : regime_data,
-        }
-    }

nextrade_engine-0.7.0/nextrade/nextrade/indicators/pattern.py

@@ -1,76 +0,0 @@
-"""
-NexTrade — Pattern Scorer
-Beri skor kekuatan pola candlestick, bukan hanya deteksi ya/tidak.
-"""
-import numpy as np
-
-def _body(o, c): return abs(c - o)
-def _upper(o, c, h): return h - max(o, c)
-def _lower(o, c, l): return min(o, c) - l
-def _range(h, l): return h - l + 1e-9
-
-def hammer_score(open_: float, high: float, low: float, close: float) -> float:
-    """Skor pola hammer / pin bar bawah (0-100)."""
-    body = _body(open_, close)
-    lower = _lower(open_, close, low)
-    upper = _upper(open_, close, high)
-    rng = _range(high, low)
-    if rng == 0: return 0.0
-    lower_ratio = lower / rng
-    body_ratio  = body / rng
-    # Hammer ideal: lower > 60% range, body < 30%, upper < 10%
-    score = 0.0
-    score += min(lower_ratio / 0.6, 1.0) * 50   # lower shadow besar
-    score += max(1 - body_ratio / 0.3, 0) * 30  # body kecil
-    score += max(1 - upper / (rng * 0.1 + 1e-9), 0) * 20  # upper shadow kecil
-    return round(min(score, 100.0), 2)
-
-def engulfing_score(prev_o: float, prev_c: float,
-                    curr_o: float, curr_c: float) -> tuple:
-    """
-    Skor pola engulfing bullish / bearish.
-    Returns (score, direction) — direction: 'bull' atau 'bear'
-    """
-    prev_body = _body(prev_o, prev_c)
-    curr_body = _body(curr_o, curr_c)
-    if prev_body == 0: return 0.0, "none"
-
-    ratio = curr_body / (prev_body + 1e-9)
-    is_bull = prev_c < prev_o and curr_c > curr_o and curr_o < prev_c and curr_c > prev_o
-    is_bear = prev_c > prev_o and curr_c < curr_o and curr_o > prev_c and curr_c < prev_o
-
-    if not (is_bull or is_bear): return 0.0, "none"
-    score = min(ratio * 60, 80) + 20  # minimum 20 kalau valid
-    direction = "bull" if is_bull else "bear"
-    return round(min(score, 100.0), 2), direction
-
-def pattern_score(opens: np.ndarray, highs: np.ndarray,
-                  lows: np.ndarray, closes: np.ndarray) -> dict:
-    """
-    Gabungan skor semua pola pada candle terbaru.
-    Returns dict dengan skor tiap pola dan skor total.
-    """
-    if len(closes) < 2:
-        return {"total": 50.0, "hammer": 0.0, "engulfing": 0.0, "direction": "neutral"}
-
-    o, h, l, c = opens[-1], highs[-1], lows[-1], closes[-1]
-    po, pc = opens[-2], closes[-2]
-
-    h_score = hammer_score(o, h, l, c)
-    e_score, e_dir = engulfing_score(po, pc, o, c)
-
-    # Tentukan arah dominan
-    if e_dir == "bull" or (h_score > 50 and c > o):
-        direction = "bull"
-    elif e_dir == "bear" or (h_score > 50 and c < o):
-        direction = "bear"
-    else:
-        direction = "neutral"
-
-    total = max(h_score, e_score)
-    return {
-        "total"     : total,
-        "hammer"    : h_score,
-        "engulfing" : e_score,
-        "direction" : direction,
-    }