Update app.py

app.py

@@ -18,21 +18,20 @@ from xgboost import XGBClassifier
 
 from ta.trend import ADXIndicator
 
-# ============================================================
 
+# ============================================================
 # CONFIG
-
 # ============================================================
 
 SYMBOLS = [
-"BTC-USD",
-"ETH-USD",
-"SOL-USD",
-"BNB-USD",
-"XRP-USD",
-"DOGE-USD",
-"AVAX-USD",
-"LINK-USD"
+    "BTC-USD",
+    "ETH-USD",
+    "SOL-USD",
+    "BNB-USD",
+    "XRP-USD",
+    "DOGE-USD",
+    "AVAX-USD",
+    "LINK-USD",
 ]
 
 WINDOW = 20
@@ -48,25 +47,22 @@ os.makedirs(LOG_DIR, exist_ok=True)
 BOT_TOKEN = "YOUR_BOT_TOKEN"
 CHAT_ID = "YOUR_CHAT_ID"
 
-# ============================================================
 
+# ============================================================
 # LOGGING
-
 # ============================================================
 
 logging.basicConfig(level=logging.INFO)
 
 logger = logging.getLogger("crypto_ai")
 
-# ============================================================
 
+# ============================================================
 # PATHS
-
 # ============================================================
 
 def model_path(symbol):
 
-
     return os.path.join(
         MODEL_DIR,
         f"{symbol}_model.pkl"
@@ -75,7 +71,6 @@ def model_path(symbol):
 
 def scaler_path(symbol):
 
-
     return os.path.join(
         MODEL_DIR,
         f"{symbol}_scaler.pkl"
@@ -84,7 +79,6 @@ def scaler_path(symbol):
 
 def data_path(symbol):
 
-
     return os.path.join(
         DATA_DIR,
         f"{symbol}.csv"
@@ -92,611 +86,566 @@ def data_path(symbol):
 
 
 # ============================================================
-
 # TELEGRAM
-
 # ============================================================
 
 def send_telegram(message):
 
+    try:
 
-try:
-
-    if "YOUR_BOT_TOKEN" in BOT_TOKEN:
-        return
+        if "YOUR_BOT_TOKEN" in BOT_TOKEN:
+            return
 
-    url = (
-        f"https://api.telegram.org/"
-        f"bot{BOT_TOKEN}/sendMessage"
-    )
+        url = (
+            f"https://api.telegram.org/"
+            f"bot{BOT_TOKEN}/sendMessage"
+        )
 
-    requests.post(
-        url,
-        data={
-            "chat_id": CHAT_ID,
-            "text": message
-        },
-        timeout=10
-    )
+        requests.post(
+            url,
+            data={
+                "chat_id": CHAT_ID,
+                "text": message
+            },
+            timeout=10
+        )
 
-except Exception as e:
+    except Exception as e:
 
-    logger.warning(e)
+        logger.warning(e)
 
 
 # ============================================================
-
-# DOWNLOAD
-
+# CLEAN COLUMNS
 # ============================================================
 
 def clean_columns(df):
 
+    if isinstance(df.columns, pd.MultiIndex):
 
-if isinstance(df.columns, pd.MultiIndex):
+        df.columns = (
+            df.columns.get_level_values(0)
+        )
 
-    df.columns = (
-        df.columns.get_level_values(0)
-    )
+    df.columns = [
+        str(c).lower()
+        for c in df.columns
+    ]
 
-df.columns = [
-    str(c).lower()
-    for c in df.columns
-]
+    return df
 
-return df
 
+# ============================================================
+# DOWNLOAD DATA
+# ============================================================
 
 def safe_download(symbol):
 
+    try:
 
-try:
-
-    df = yf.download(
-        symbol,
-        period="90d",
-        interval="1h",
-        progress=False,
-        auto_adjust=True,
-        threads=False
-    )
+        df = yf.download(
+            symbol,
+            period="90d",
+            interval="1h",
+            progress=False,
+            auto_adjust=True,
+            threads=False
+        )
 
-    if df is not None and not df.empty:
+        if df is not None and not df.empty:
 
-        df = clean_columns(df)
+            df = clean_columns(df)
 
-        df.to_csv(data_path(symbol))
+            df.to_csv(data_path(symbol))
 
-        return df, True
+            return df, True
 
-except Exception as e:
+    except Exception as e:
 
-    logger.warning(e)
+        logger.warning(e)
 
-return None, False
+    return None, False
 
 
 # ============================================================
-
 # FEATURE ENGINEERING
-
 # ============================================================
 
 def fetch_and_prepare(symbol):
 
+    df, is_real = safe_download(symbol)
 
-df, is_real = safe_download(symbol)
+    if df is None:
 
-if df is None:
+        return None, None, None, None
 
-    return None, None, None, None
+    df.index = pd.to_datetime(df.index)
 
-df.index = pd.to_datetime(df.index)
+    df = df.resample("4h").agg({
+        "open": "first",
+        "high": "max",
+        "low": "min",
+        "close": "last",
+        "volume": "sum"
+    }).dropna()
 
-df = df.resample("4h").agg({
-    "open": "first",
-    "high": "max",
-    "low": "min",
-    "close": "last",
-    "volume": "sum"
-}).dropna()
+    # RSI
 
-# RSI
+    delta = df["close"].diff()
 
-delta = df["close"].diff()
+    gain = delta.where(
+        delta > 0,
+        0
+    ).rolling(14).mean()
 
-gain = delta.where(
-    delta > 0,
-    0
-).rolling(14).mean()
+    loss = (-delta.where(
+        delta < 0,
+        0
+    )).rolling(14).mean()
 
-loss = (-delta.where(
-    delta < 0,
-    0
-)).rolling(14).mean()
+    rs = gain / loss.replace(0, np.nan)
 
-rs = gain / loss.replace(0, np.nan)
+    df["rsi"] = (
+        100 - (100 / (1 + rs))
+    ).fillna(50)
 
-df["rsi"] = (
-    100 - (100 / (1 + rs))
-).fillna(50)
+    # MACD
 
-# MACD
+    ema12 = (
+        df["close"]
+        .ewm(span=12)
+        .mean()
+    )
 
-ema12 = (
-    df["close"]
-    .ewm(span=12)
-    .mean()
-)
+    ema26 = (
+        df["close"]
+        .ewm(span=26)
+        .mean()
+    )
 
-ema26 = (
-    df["close"]
-    .ewm(span=26)
-    .mean()
-)
+    df["macd"] = ema12 - ema26
 
-df["macd"] = ema12 - ema26
+    df["macd_signal"] = (
+        df["macd"]
+        .ewm(span=9)
+        .mean()
+    )
 
-df["macd_signal"] = (
-    df["macd"]
-    .ewm(span=9)
-    .mean()
-)
+    # EMA
 
-# EMA
+    df["ema9"] = (
+        df["close"]
+        .ewm(span=9)
+        .mean()
+    )
 
-df["ema9"] = (
-    df["close"]
-    .ewm(span=9)
-    .mean()
-)
+    df["ema21"] = (
+        df["close"]
+        .ewm(span=21)
+        .mean()
+    )
 
-df["ema21"] = (
-    df["close"]
-    .ewm(span=21)
-    .mean()
-)
+    df["ema50"] = (
+        df["close"]
+        .ewm(span=50)
+        .mean()
+    )
 
-df["ema50"] = (
-    df["close"]
-    .ewm(span=50)
-    .mean()
-)
+    df["ema200"] = (
+        df["close"]
+        .ewm(span=200)
+        .mean()
+    )
 
-df["ema200"] = (
-    df["close"]
-    .ewm(span=200)
-    .mean()
-)
+    # BOLLINGER
 
-# BOLLINGER
+    sma20 = (
+        df["close"]
+        .rolling(20)
+        .mean()
+    )
 
-sma20 = (
-    df["close"]
-    .rolling(20)
-    .mean()
-)
+    std20 = (
+        df["close"]
+        .rolling(20)
+        .std()
+    )
 
-std20 = (
-    df["close"]
-    .rolling(20)
-    .std()
-)
+    df["bb_upper"] = sma20 + (2 * std20)
 
-df["bb_upper"] = sma20 + (2 * std20)
-df["bb_lower"] = sma20 - (2 * std20)
+    df["bb_lower"] = sma20 - (2 * std20)
 
-# ATR
+    # ATR
 
-df["atr"] = (
-    (df["high"] - df["low"])
-    .rolling(14)
-    .mean()
-)
-
-# VOLUME
-
-df["vol_sma"] = (
-    df["volume"]
-    .rolling(20)
-    .mean()
-)
-
-df["volume_spike"] = (
-    df["volume"]
-    >
-    df["vol_sma"] * 2
-)
-
-# ADX
-
-adx = ADXIndicator(
-    high=df["high"],
-    low=df["low"],
-    close=df["close"]
-)
-
-df["adx"] = adx.adx()
-
-# VOLATILITY
-
-df["volatility"] = (
-    df["close"]
-    .pct_change()
-    .rolling(20)
-    .std()
-)
-
-# REGIME
-
-def detect_regime(row):
-
-    if row["volatility"] < 0.01:
-
-        return "SIDEWAYS"
-
-    if row["ema50"] > row["ema200"]:
-
-        return "BULL"
-
-    return "BEAR"
-
-df["regime"] = df.apply(
-    detect_regime,
-    axis=1
-)
-
-# RETURNS
-
-df["return1"] = (
-    df["close"]
-    .pct_change()
-)
-
-df["return4"] = (
-    df["close"]
-    .pct_change(4)
-)
-
-# LABEL
-
-df["next_close"] = (
-    df["close"]
-    .shift(-1)
-)
-
-df["label"] = (
-    df["next_close"]
-    >
-    df["close"]
-).astype(int)
-
-df = df.replace(
-    [np.inf, -np.inf],
-    np.nan
-)
-
-df = df.dropna()
-
-feat_cols = [
-    "open",
-    "high",
-    "low",
-    "close",
-    "volume",
-    "rsi",
-    "macd",
-    "macd_signal",
-    "ema9",
-    "ema21",
-    "ema50",
-    "ema200",
-    "bb_upper",
-    "bb_lower",
-    "atr",
-    "adx",
-    "return1",
-    "return4"
-]
+    df["atr"] = (
+        (df["high"] - df["low"])
+        .rolling(14)
+        .mean()
+    )
+
+    # VOLUME
+
+    df["vol_sma"] = (
+        df["volume"]
+        .rolling(20)
+        .mean()
+    )
+
+    # ADX
+
+    adx = ADXIndicator(
+        high=df["high"],
+        low=df["low"],
+        close=df["close"]
+    )
+
+    df["adx"] = adx.adx()
+
+    # VOLATILITY
+
+    df["volatility"] = (
+        df["close"]
+        .pct_change()
+        .rolling(20)
+        .std()
+    )
 
-X_list = []
-y_list = []
+    # REGIME
 
-for i in range(WINDOW, len(df)):
+    def detect_regime(row):
 
-    window = df.iloc[
-        i-WINDOW:i
-    ][feat_cols].values
+        if row["volatility"] < 0.01:
+            return "SIDEWAYS"
 
-    if np.isnan(window).any():
+        if row["ema50"] > row["ema200"]:
+            return "BULL"
 
-        continue
+        return "BEAR"
 
-    X_list.append(
-        window.flatten()
+    df["regime"] = df.apply(
+        detect_regime,
+        axis=1
     )
 
-    y_list.append(
-        df.iloc[i]["label"]
+    # RETURNS
+
+    df["return1"] = (
+        df["close"]
+        .pct_change()
     )
 
-X = np.array(X_list)
-y = np.array(y_list)
+    df["return4"] = (
+        df["close"]
+        .pct_change(4)
+    )
 
-return X, y, df, feat_cols
+    # LABEL
 
+    df["next_close"] = (
+        df["close"]
+        .shift(-1)
+    )
 
-# ============================================================
+    df["label"] = (
+        df["next_close"]
+        >
+        df["close"]
+    ).astype(int)
+
+    df = df.replace(
+        [np.inf, -np.inf],
+        np.nan
+    )
+
+    df = df.dropna()
+
+    feat_cols = [
+        "open",
+        "high",
+        "low",
+        "close",
+        "volume",
+        "rsi",
+        "macd",
+        "macd_signal",
+        "ema9",
+        "ema21",
+        "ema50",
+        "ema200",
+        "bb_upper",
+        "bb_lower",
+        "atr",
+        "adx",
+        "return1",
+        "return4"
+    ]
+
+    X_list = []
+    y_list = []
+
+    for i in range(WINDOW, len(df)):
+
+        window = df.iloc[
+            i-WINDOW:i
+        ][feat_cols].values
+
+        if np.isnan(window).any():
+            continue
+
+        X_list.append(
+            window.flatten()
+        )
+
+        y_list.append(
+            df.iloc[i]["label"]
+        )
+
+    X = np.array(X_list)
+
+    y = np.array(y_list)
+
+    return X, y, df, feat_cols
 
-# TRAIN
 
+# ============================================================
+# TRAIN
 # ============================================================
 
 def run_train(symbol):
 
+    X, y, df, feat_cols = (
+        fetch_and_prepare(symbol)
+    )
 
-X, y, df, feat_cols = (
-    fetch_and_prepare(symbol)
-)
+    if X is None:
+        return
 
-if X is None:
+    scaler = MinMaxScaler()
 
-    return
+    X_scaled = scaler.fit_transform(X)
 
-scaler = MinMaxScaler()
+    model = XGBClassifier(
+        n_estimators=300,
+        max_depth=6,
+        learning_rate=0.03,
+        subsample=0.8,
+        colsample_bytree=0.8,
+        eval_metric="logloss",
+        random_state=42
+    )
 
-X_scaled = scaler.fit_transform(X)
+    tscv = TimeSeriesSplit(
+        n_splits=5
+    )
 
-model = XGBClassifier(
-    n_estimators=300,
-    max_depth=6,
-    learning_rate=0.03,
-    subsample=0.8,
-    colsample_bytree=0.8,
-    eval_metric="logloss",
-    random_state=42
-)
+    for train_idx, test_idx in tscv.split(X_scaled):
 
-tscv = TimeSeriesSplit(
-    n_splits=5
-)
+        X_train = X_scaled[train_idx]
 
-for train_idx, test_idx in tscv.split(X_scaled):
+        y_train = y[train_idx]
 
-    X_train = X_scaled[train_idx]
-    y_train = y[train_idx]
+        model.fit(
+            X_train,
+            y_train
+        )
 
-    model.fit(
-        X_train,
-        y_train
+    joblib.dump(
+        model,
+        model_path(symbol)
     )
 
-joblib.dump(
-    model,
-    model_path(symbol)
-)
-
-joblib.dump(
-    scaler,
-    scaler_path(symbol)
-)
+    joblib.dump(
+        scaler,
+        scaler_path(symbol)
+    )
 
-logger.info(
-    f"TRAINED: {symbol}"
-)
+    logger.info(
+        f"TRAINED: {symbol}"
+    )
 
 
 # ============================================================
-
 # TRAIN ALL
-
 # ============================================================
 
 def train_all():
 
+    for symbol in SYMBOLS:
 
-for symbol in SYMBOLS:
+        try:
 
-    try:
+            run_train(symbol)
 
-        run_train(symbol)
+        except Exception as e:
 
-    except Exception as e:
-
-        logger.error(e)
+            logger.error(e)
 
 
 # ============================================================
-
 # TRADE LEVELS
-
 # ============================================================
 
 def trade_levels(df, signal):
 
+    last = df.iloc[-1]
 
-last = df.iloc[-1]
+    close_price = float(
+        last["close"]
+    )
 
-close_price = float(
-    last["close"]
-)
+    atr = float(
+        last["atr"]
+    )
 
-atr = float(
-    last["atr"]
-)
+    if signal == "BUY":
 
-if signal == "BUY":
+        tp1 = close_price + atr
+        tp2 = close_price + atr * 2
+        tp3 = close_price + atr * 3
 
-    tp1 = close_price + atr
-    tp2 = close_price + atr * 2
-    tp3 = close_price + atr * 3
+        sl = close_price - atr * 1.5
 
-    sl = close_price - atr * 1.5
+    elif signal == "SELL":
 
-elif signal == "SELL":
+        tp1 = close_price - atr
+        tp2 = close_price - atr * 2
+        tp3 = close_price - atr * 3
 
-    tp1 = close_price - atr
-    tp2 = close_price - atr * 2
-    tp3 = close_price - atr * 3
+        sl = close_price + atr * 1.5
 
-    sl = close_price + atr * 1.5
+    else:
 
-else:
+        tp1 = close_price
+        tp2 = close_price
+        tp3 = close_price
 
-    tp1 = close_price
-    tp2 = close_price
-    tp3 = close_price
-    sl = close_price
+        sl = close_price
 
-return {
-    "entry": close_price,
-    "tp1": tp1,
-    "tp2": tp2,
-    "tp3": tp3,
-    "sl": sl
-}
+    return {
+        "entry": close_price,
+        "tp1": tp1,
+        "tp2": tp2,
+        "tp3": tp3,
+        "sl": sl
+    }
 
 
 # ============================================================
-
 # PREDICT
-
 # ============================================================
 
 LAST_SIGNALS = {}
 
 def run_predict(symbol):
 
+    if not os.path.exists(
+        model_path(symbol)
+    ):
 
-if not os.path.exists(
-    model_path(symbol)
-):
-
-    run_train(symbol)
-
-X, y, df, feat_cols = (
-    fetch_and_prepare(symbol)
-)
-
-scaler = joblib.load(
-    scaler_path(symbol)
-)
+        run_train(symbol)
 
-model = joblib.load(
-    model_path(symbol)
-)
+    X, y, df, feat_cols = (
+        fetch_and_prepare(symbol)
+    )
 
-latest = (
-    df.iloc[-WINDOW:][feat_cols]
-    .values
-    .flatten()
-    .reshape(1, -1)
-)
+    scaler = joblib.load(
+        scaler_path(symbol)
+    )
 
-latest_scaled = scaler.transform(
-    latest
-)
+    model = joblib.load(
+        model_path(symbol)
+    )
 
-pred = model.predict(
-    latest_scaled
-)[0]
+    latest = (
+        df.iloc[-WINDOW:][feat_cols]
+        .values
+        .flatten()
+        .reshape(1, -1)
+    )
 
-proba = model.predict_proba(
-    latest_scaled
-)[0]
+    latest_scaled = scaler.transform(
+        latest
+    )
 
-confidence = (
-    float(np.max(proba))
-    * 100
-)
+    pred = model.predict(
+        latest_scaled
+    )[0]
 
-last = df.iloc[-1]
+    proba = model.predict_proba(
+        latest_scaled
+    )[0]
 
-bull_trend = (
-    last["ema50"]
-    >
-    last["ema200"]
-)
+    confidence = (
+        float(np.max(proba))
+        * 100
+    )
 
-strong_volume = (
-    last["volume"]
-    >
-    last["vol_sma"]
-)
+    last = df.iloc[-1]
 
-strong_adx = (
-    last["adx"] > 25
-)
+    bull_trend = (
+        last["ema50"]
+        >
+        last["ema200"]
+    )
 
-regime = last["regime"]
+    strong_volume = (
+        last["volume"]
+        >
+        last["vol_sma"]
+    )
 
-score = 0
+    strong_adx = (
+        last["adx"] > 25
+    )
 
-if bull_trend:
-    score += 20
+    regime = last["regime"]
 
-if strong_volume:
-    score += 20
+    score = 0
 
-if strong_adx:
-    score += 20
+    if bull_trend:
+        score += 20
 
-if last["rsi"] > 55:
-    score += 20
+    if strong_volume:
+        score += 20
 
-if last["macd"] > last["macd_signal"]:
-    score += 20
+    if strong_adx:
+        score += 20
 
-signal = "NO TRADE"
+    if last["rsi"] > 55:
+        score += 20
 
-if regime == "SIDEWAYS":
+    if last["macd"] > last["macd_signal"]:
+        score += 20
 
     signal = "NO TRADE"
 
-else:
+    if regime == "SIDEWAYS":
 
-    if pred == 1 and score >= 60:
+        signal = "NO TRADE"
 
-        signal = "BUY"
+    else:
 
-    elif pred == 0 and score >= 60:
+        if pred == 1 and score >= 60:
 
-        signal = "SELL"
+            signal = "BUY"
 
-levels = trade_levels(
-    df,
-    signal
-)
+        elif pred == 0 and score >= 60:
 
-# LOG
+            signal = "SELL"
 
-with open(
-    os.path.join(
-        LOG_DIR,
-        "signals.log"
-    ),
-    "a"
-) as f:
-
-    f.write(
-        f"{datetime.utcnow()} | "
-        f"{symbol} | "
-        f"{signal} | "
-        f"{confidence:.2f}\n"
+    levels = trade_levels(
+        df,
+        signal
     )
 
-# TELEGRAM
+    previous = LAST_SIGNALS.get(symbol)
 
-previous = LAST_SIGNALS.get(symbol)
-
-if previous != signal:
-
-    LAST_SIGNALS[symbol] = signal
-
-    send_telegram(
-        f"""
+    if previous != signal:
 
+        LAST_SIGNALS[symbol] = signal
 
+        send_telegram(
+            f"""
 🚨 NEW SIGNAL
 
 PAIR: {symbol}
@@ -705,122 +654,109 @@ SIGNAL: {signal}
 
 CONFIDENCE: {confidence:.2f}%
 """
-)
-
+        )
 
-return {
-    "Pair": symbol,
-    "Signal": signal,
-    "Confidence": round(confidence, 2),
-    "Score": score,
-    "Entry": round(levels["entry"], 2),
-    "TP1": round(levels["tp1"], 2),
-    "TP2": round(levels["tp2"], 2),
-    "TP3": round(levels["tp3"], 2),
-    "SL": round(levels["sl"], 2),
-    "RSI": round(last["rsi"], 2),
-    "ADX": round(last["adx"], 2),
-    "Regime": regime
-}
+    return {
+        "Pair": symbol,
+        "Signal": signal,
+        "Confidence": round(confidence, 2),
+        "Score": score,
+        "Entry": round(levels["entry"], 2),
+        "TP1": round(levels["tp1"], 2),
+        "TP2": round(levels["tp2"], 2),
+        "TP3": round(levels["tp3"], 2),
+        "SL": round(levels["sl"], 2),
+        "RSI": round(last["rsi"], 2),
+        "ADX": round(last["adx"], 2),
+        "Regime": regime
+    }
 
 
 # ============================================================
-
 # REALTIME SCAN
-
 # ============================================================
 
 LAST_RETRAIN = 0
 
 def realtime_scan():
 
+    global LAST_RETRAIN
 
-global LAST_RETRAIN
-
-now = time.time()
+    now = time.time()
 
-# AUTO RETRAIN 6 JAM
+    if now - LAST_RETRAIN > 21600:
 
-if now - LAST_RETRAIN > 21600:
-
-    logger.info(
-        "AUTO RETRAIN..."
-    )
+        logger.info(
+            "AUTO RETRAIN..."
+        )
 
-    train_all()
+        train_all()
 
-    LAST_RETRAIN = now
+        LAST_RETRAIN = now
 
-rows = []
+    rows = []
 
-for symbol in SYMBOLS:
+    for symbol in SYMBOLS:
 
-    try:
+        try:
 
-        result = run_predict(symbol)
+            result = run_predict(symbol)
 
-        rows.append(result)
+            rows.append(result)
 
-    except Exception as e:
+        except Exception:
 
-        logger.error(
-            traceback.format_exc()
-        )
+            logger.error(
+                traceback.format_exc()
+            )
 
-df = pd.DataFrame(rows)
+    df = pd.DataFrame(rows)
 
-if len(df) > 0:
+    if len(df) > 0:
 
-    df = df.sort_values(
-        by="Score",
-        ascending=False
-    )
+        df = df.sort_values(
+            by="Score",
+            ascending=False
+        )
 
-return df
+    return df
 
 
 # ============================================================
-
 # UI
-
 # ============================================================
 
 with gr.Blocks(
-title="Crypto AI Scanner"
+    title="Crypto AI Scanner"
 ) as demo:
 
+    gr.Markdown(
+        "# 🤖 Crypto AI Scanner PRO"
+    )
 
-gr.Markdown(
-    "# 🤖 Crypto AI Scanner PRO"
-)
-
-table = gr.Dataframe(
-    interactive=False
-)
+    table = gr.Dataframe(
+        interactive=False
+    )
 
-timer = gr.Timer(20)
+    timer = gr.Timer(20)
 
-timer.tick(
-    fn=realtime_scan,
-    outputs=table
-)
+    timer.tick(
+        fn=realtime_scan,
+        outputs=table
+    )
 
 
 # ============================================================
-
 # START
-
 # ============================================================
 
-if name == "main":
-
+if __name__ == "__main__":
 
-train_all()
-
-demo.queue()
+    train_all()
 
-demo.launch(
-    server_name="0.0.0.0",
-    server_port=7860
-)
+    demo.queue()
 
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860
+    )