5 bài viết được gắn thẻ "python"

from dataclasses import dataclass
from decimal import Decimal


@dataclass
class CauHinhRuiRo:
    """Toàn bộ tham số rủi ro ở một chỗ — dễ kiểm tra, dễ thay đổi."""

    rui_ro_moi_lenh_pct: float = 1.0      # tối đa 1% số dư mỗi lệnh
    so_lenh_toi_da_moi_ngay: int = 3
    drawdown_dung_bot_pct: float = 10.0   # lỗ 10% thì tự dừng
    he_so_atr_sl: float = 2.0
    he_so_atr_tp: float = 4.0              # R:R = 1:2


class QuanTriRuiRo:
    def __init__(self, cau_hinh: CauHinhRuiRo):
        self.ch = cau_hinh
        self.so_du_ban_dau: Decimal | None = None
        self.so_lenh_hom_nay = 0
        self.dang_dung = False

    def ghi_nhan_so_du_ban_dau(self, so_du: Decimal) -> None:
        if self.so_du_ban_dau is None:
            self.so_du_ban_dau = so_du

    def kiem_tra_drawdown(self, so_du_hien_tai: Decimal) -> bool:
        """Trả True nếu ĐƯỢC phép giao dịch tiếp."""
        if self.so_du_ban_dau is None:
            return True
        drawdown = (1 - so_du_hien_tai / self.so_du_ban_dau) * 100
        if drawdown >= self.ch.drawdown_dung_bot_pct:
            self.dang_dung = True
            return False
        return True

    def co_the_vao_lenh(self) -> tuple[bool, str]:
        if self.dang_dung:
            return False, "Bot đang tạm dừng do vượt ngưỡng drawdown"
        if self.so_lenh_hom_nay >= self.ch.so_lenh_toi_da_moi_ngay:
            return False, f"Đã đạt giới hạn {self.ch.so_lenh_toi_da_moi_ngay} lệnh/ngày"
        return True, ""

    def tinh_khoi_luong(self, so_du: Decimal, gia: float, atr: float) -> Decimal:
        """Khối lượng sao cho khi chạm SL chỉ mất đúng rui_ro_moi_lenh_pct."""
        so_tien_rui_ro = so_du * Decimal(str(self.ch.rui_ro_moi_lenh_pct / 100))
        khoang_cach_sl = atr * self.ch.he_so_atr_sl
        if khoang_cach_sl <= 0:
            raise ValueError("ATR không hợp lệ — không tính được khối lượng")
        khoi_luong = so_tien_rui_ro / Decimal(str(gia)) / Decimal(str(khoang_cach_sl / gia))
        return round(khoi_luong, 6)

import csv
import logging
from datetime import datetime
from pathlib import Path

logger = logging.getLogger(__name__)

COT_NHAT_KY = [
    "thoi_diem", "su_kien", "symbol", "huong", "khoi_luong",
    "gia", "sl", "tp", "so_du", "ly_do",
]


class NhatKyGiaoDich:
    def __init__(self, duong_dan: str = "nhat-ky-giao-dich.csv"):
        self.path = Path(duong_dan)
        if not self.path.exists():
            with self.path.open("w", newline="", encoding="utf-8-sig") as f:
                csv.writer(f).writerow(COT_NHAT_KY)

    def ghi(self, su_kien: str, **thong_tin) -> None:
        dong = {"thoi_diem": datetime.now().isoformat(timespec="seconds"),
                "su_kien": su_kien}
        dong.update({k: thong_tin.get(k, "") for k in COT_NHAT_KY if k not in dong})

        with self.path.open("a", newline="", encoding="utf-8-sig") as f:
            csv.DictWriter(f, fieldnames=COT_NHAT_KY).writerow(dong)

        logger.info("[%s] %s", su_kien, {k: v for k, v in dong.items() if v != ""})

import numpy as np
import pandas as pd


def kiem_dinh_on_dinh(ket_qua_lenh: pd.Series, so_phan: int = 4) -> pd.DataFrame:
    """Chia chuỗi lệnh thành nhiều giai đoạn — phát hiện overfit."""
    doan = np.array_split(ket_qua_lenh.values, so_phan)

    ban_ghi = []
    for i, d in enumerate(doan, 1):
        thang = (d > 0).sum()
        ban_ghi.append({
            "giai_doan": f"{i}/{so_phan}",
            "so_lenh": len(d),
            "ty_le_thang": round(thang / len(d) * 100, 1) if len(d) else 0,
            "loi_nhuan": round(float(np.sum(d)), 4),
            "dat": np.sum(d) > 0,
        })
    return pd.DataFrame(ban_ghi)


# Ví dụ minh hoạ: 400 lệnh mô phỏng
rng = np.random.default_rng(42)
lenh_mo_phong = pd.Series(rng.normal(0.004, 0.02, 400))    # kỳ vọng dương nhẹ
print(kiem_dinh_on_dinh(lenh_mo_phong))

import pandas as pd
import numpy as np


def phat_hien_phan_phoi(df: pd.DataFrame, nhiem_ky: int = 20) -> pd.Series:
    """Đánh dấu nến có dấu hiệu phân phối.

    Điều kiện: giá ở gần đỉnh 20 nến, biên độ nến lớn,
    nhưng giá đóng cửa yếu (đóng ở nửa dưới của nến).
    """
    dinh = df["high"].rolling(nhiem_ky).max()
    bien_do = df["high"] - df["low"]
    bien_do_tb = bien_do.rolling(nhiem_ky).mean()

    gan_dinh = df["high"] >= dinh * 0.995
    nen_rong = bien_do > bien_do_tb * 1.5
    dong_yeu = (df["close"] - df["low"]) / bien_do.replace(0, np.nan) < 0.4

    return gan_dinh & nen_rong & dong_yeu


# Ví dụ minh hoạ
df = pd.DataFrame({
    "high":  [100, 101, 105, 104, 103, 102],
    "low":   [98,  99,  100, 99,  98,  97],
    "close": [99,  100, 101, 100, 99,  98],
})
print(phat_hien_phan_phoi(df, nhiem_ky=4))

import pandas as pd


def tim_dinh_day(df: pd.DataFrame, trai: int = 2, phai: int = 2) -> pd.DataFrame:
    """Phát hiện pivot high/low theo quy tắc đối xứng.

    Một đỉnh là nến cao hơn `trai` nến trước và `phai` nến sau.
    """
    df = df.copy()
    df["la_dinh"] = True
    df["la_day"] = True

    for i in range(1, trai + 1):
        df["la_dinh"] &= df["high"] > df["high"].shift(i)
        df["la_dinh"] &= df["high"] > df["high"].shift(-i)
        df["la_day"] &= df["low"] < df["low"].shift(i)
        df["la_day"] &= df["low"] < df["low"].shift(-i)

    # Bỏ `phai` nến cuối vì chưa xác nhận được
    df.loc[df.index[-phai:], ["la_dinh", "la_day"]] = False
    return df


def danh_gia_cau_truc(df: pd.DataFrame) -> str:
    """Đánh giá cấu trúc xu hướng dựa trên đỉnh/đáy gần nhất."""
    co_dinh = df[df["la_dinh"]]
    co_day = df[df["la_day"]]

    if len(co_dinh) < 2 or len(co_day) < 2:
        return "Chưa đủ dữ liệu để kết luận"

    dinh_tang = co_dinh["high"].iloc[-1] > co_dinh["high"].iloc[-2]
    day_tang = co_day["low"].iloc[-1] > co_day["low"].iloc[-2]

    if dinh_tang and day_tang:
        return "📈 Xu hướng TĂNG (đỉnh và đáy đều cao dần)"
    if not dinh_tang and not day_tang:
        return "📉 Xu hướng GIẢM (đỉnh và đáy đều thấp dần)"
    return "➡️ Đi ngang (cấu trúc mâu thuẫn — tín hiệu không rõ)"

import numpy as np
import pandas as pd


def volume_profile(df: pd.DataFrame, so_muc: int = 30) -> pd.DataFrame:
    """Xây dựng hồ sơ khối lượng theo mức giá (volume profile)."""
    muc_gia, bien = np.linspace(
        df["low"].min(), df["high"].max(), so_muc, retstep=True
    )
    chi_so = (df["close"] - muc_gia[0]) / bien
    chi_so = chi_so.astype(int).clip(0, so_muc - 1)

    khoi_luong_theo_muc = df.groupby(chi_so)["volume"].sum()
    khoi_luong_theo_muc.index = muc_gia[khoi_luong_theo_muc.index]
    khoi_luong_theo_muc.index.name = "muc_gia"

    return khoi_luong_theo_muc.sort_index(ascending=False).to_frame("khoi_luong")


def vung_gia_tri(ho_so: pd.DataFrame, ty_le: float = 0.7) -> tuple[float, float]:
    """Tìm vùng giá chứa `ty_le` khối lượng — vùng giá trị thật."""
    sap_xep = ho_so.sort_values("khoi_luong", ascending=False)
    tich_luy = sap_xep["khoi_luong"].cumsum() / sap_xep["khoi_luong"].sum()
    vung = sap_xep[tich_luy <= ty_le]
    return float(vung.index.min()), float(vung.index.max())

import os
from dotenv import load_dotenv
import MetaTrader5 as mt5

load_dotenv()


def ket_noi_mt5() -> bool:
    """Kết nối tới MT5 terminal. Trả False nếu thất bại."""
    if not mt5.initialize(
        path=os.getenv("MT5_PATH"),                 # đường dẫn terminal64.exe
        login=int(os.getenv("MT5_LOGIN", "0")),
        password=os.getenv("MT5_PASSWORD"),
        server=os.getenv("MT5_SERVER"),
        timeout=10_000,
        portable=False,
    ):
        ma_loi, mo_ta = mt5.last_error()
        print(f"❌ Khởi tạo thất bại: [{ma_loi}] {mo_ta}")
        return False

    thong_tin = mt5.terminal_info()
    tai_khoan = mt5.account_info()

    print(f"✅ MT5 {thong_tin.build} — kết nối: {thong_tin.connected}")
    print(f"   Tài khoản: {tai_khoan.login} | "
          f"{tai_khoan.server} | "
          f"{'DEMO' if tai_khoan.trade_mode == mt5.ACCOUNT_TRADE_MODE_DEMO else '⚠️ THẬT'}")
    print(f"   Số dư: {tai_khoan.balance:.2f} {tai_khoan.currency}")

    return True


def ngat_ket_noi():
    mt5.shutdown()


if __name__ == "__main__":
    if ket_noi_mt5():
        ngat_ket_noi()

import pandas as pd
import MetaTrader5 as mt5


KHUNG_THOI_GIAN = {
    "M1": mt5.TIMEFRAME_M1,
    "M5": mt5.TIMEFRAME_M5,
    "M15": mt5.TIMEFRAME_M15,
    "H1": mt5.TIMEFRAME_H1,
    "H4": mt5.TIMEFRAME_H4,
    "D1": mt5.TIMEFRAME_D1,
}


def lay_nen(symbol: str, khung: str = "H1", so_nen: int = 500) -> pd.DataFrame:
    """Lấy nến từ MT5 và trả về DataFrame đã chuẩn hoá."""
    tf = KHUNG_THOI_GIAN.get(khung)
    if tf is None:
        raise ValueError(f"Khung không hợp lệ: {khung}. Dùng: {list(KHUNG_THOI_GIAN)}")

    # Đảm bảo symbol đã được chọn trong Market Watch
    if not mt5.symbol_select(symbol, True):
        raise RuntimeError(f"Không chọn được symbol {symbol}")

    rates = mt5.copy_rates_from_pos(symbol, tf, 0, so_nen)
    if rates is None or len(rates) == 0:
        raise RuntimeError(f"Không lấy được dữ liệu {symbol} {khung}: {mt5.last_error()}")

    df = pd.DataFrame(rates)
    df["time"] = pd.to_datetime(df["time"], unit="s")
    df = df.set_index("time")
    df = df.rename(columns={
        "open": "open", "high": "high", "low": "low",
        "close": "close", "tick_volume": "volume",
    })
    return df[["open", "high", "low", "close", "volume"]]


df = lay_nen("XAUUSD", "H1", 500)
print(df.tail())

import numpy as np
import pandas as pd


def wma(chuoi: pd.Series, chu_ky: int) -> pd.Series:
    """Weighted Moving Average — trọng số tuyến tính, mới nhất nặng nhất."""
    trong_so = np.arange(1, chu_ky + 1)
    return chuoi.rolling(chu_ky).apply(
        lambda x: np.dot(x, trong_so) / trong_so.sum(), raw=True
    )


def hma(chuoi: pd.Series, chu_ky: int) -> pd.Series:
    """Hull Moving Average — khớp với ta.hma() trong Pine Script."""
    nua = max(1, chu_ky // 2)
    can = max(1, int(np.sqrt(chu_ky)))
    return wma(2 * wma(chuoi, nua) - wma(chuoi, chu_ky), can)


def them_tin_hieu_hma(df: pd.DataFrame, n6=6, n10=10, n20=20) -> pd.DataFrame:
    df["hma6"] = hma(df["close"], n6)
    df["hma10"] = hma(df["close"], n10)
    df["hma20"] = hma(df["close"], n20)

    # Điều kiện "xu hướng" giống hệt Pine Script
    df["xu_huong_tang"] = (df["hma6"] > df["hma10"]) & (df["hma10"] > df["hma20"])
    df["xu_huong_giam"] = (df["hma6"] < df["hma10"]) & (df["hma10"] < df["hma20"])

    # Phát hiện lúc xu hướng ĐỔI (điểm vào lệnh tiềm năng)
    df["doi_sang_tang"] = df["xu_huong_tang"] & ~df["xu_huong_tang"].shift(1).fillna(False)
    df["doi_sang_giam"] = df["xu_huong_giam"] & ~df["xu_huong_giam"].shift(1).fillna(False)

    # Đo mức "chồng chéo" — khi ba đường bó sát, không nên giao dịch
    df["do_nen_chat"] = (df[["hma6", "hma10", "hma20"]].max(axis=1)
                         - df[["hma6", "hma10", "hma20"]].min(axis=1))

    # Ngưỡng chồng chéo: nhỏ hơn 0.15% giá là quá chặt
    df["chong_cheo"] = df["do_nen_chat"] < df["close"] * 0.0015

    return df


df = them_tin_hieu_hma(lay_nen("XAUUSD", "H1", 500))
print(df[["close", "hma6", "hma10", "hma20", "xu_huong_tang", "chong_cheo"]].tail(10))

import hmac
import hashlib
import os
import logging
from flask import Flask, request, jsonify

app = Flask(__name__)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

SECRET = os.environ["WEBHOOK_SECRET"]


def kiem_tra_secret(du_lieu: dict) -> bool:
    """So sánh secret theo cách chống timing attack."""
    nhan_duoc = str(du_lieu.get("secret", ""))
    return hmac.compare_digest(nhan_duoc, SECRET)     # KHÔNG dùng ==


@app.post("/webhook/tradingview")
def nhan_tin_hieu():
    du_lieu = request.get_json(silent=True)
    if not du_lieu:
        return jsonify({"loi": "Body không phải JSON hợp lệ"}), 400

    if not kiem_tra_secret(du_lieu):
        logger.warning("Có request với secret sai từ %s", request.remote_addr)
        return jsonify({"loi": "Xác thực thất bại"}), 401

    hanh_dong = du_lieu.get("hanh_dong")
    symbol = du_lieu.get("symbol")

    if hanh_dong not in ("MUA", "BAN"):
        return jsonify({"loi": f"hanh_dong không hợp lệ: {hanh_dong}"}), 422
    if not symbol:
        return jsonify({"loi": "Thiếu symbol"}), 422

    logger.info("📩 Tín hiệu: %s %s @ %s", hanh_dong, symbol, du_lieu.get("gia"))

    ket_qua = xu_ly_tin_hieu(hanh_dong, symbol, du_lieu)
    return jsonify(ket_qua), 200

import MetaTrader5 as mt5


def chuan_hoa_khoi_luong(symbol: str, khoi_luong: float) -> float:
    """Làm tròn khối lượng theo bước (volume step) và giới hạn của broker."""
    info = mt5.symbol_info(symbol)
    if info is None:
        raise RuntimeError(f"Không có thông tin symbol {symbol}")

    buoc = info.volume_step
    khoi_luong = round(khoi_luong / buoc) * buoc
    khoi_luong = max(info.volume_min, min(info.volume_max, khoi_luong))
    return round(khoi_luong, 8)


def chuan_hoa_gia(symbol: str, gia: float) -> float:
    """Làm tròn giá theo số chữ số thập phân mà broker yêu cầu."""
    info = mt5.symbol_info(symbol)
    return round(gia, info.digits)


def tinh_khoi_luong_theo_rui_ro(
    symbol: str, so_du: float, rui_ro_pct: float, khoang_cach_sl: float
) -> float:
    """Khối lượng để khi chạm SL chỉ mất đúng rui_ro_pct % số dư."""
    info = mt5.symbol_info(symbol)
    so_tien_rui_ro = so_du * rui_ro_pct / 100

    # Giá trị 1 điểm (point) cho 1 lot, quy đổi theo tick_value
    gia_tri_moi_point = info.trade_tick_value / info.trade_tick_size
    so_point_sl = khoang_cach_sl / info.point

    if so_point_sl <= 0 or gia_tri_moi_point <= 0:
        raise ValueError("Không tính được khối lượng — kiểm tra khoảng cách SL")

    khoi_luong = so_tien_rui_ro / (so_point_sl * gia_tri_moi_point)
    return chuan_hoa_khoi_luong(symbol, khoi_luong)


def mo_lenh(
    symbol: str,
    huong: str,                 # "MUA" hoặc "BAN"
    khoi_luong: float,
    sl: float | None = None,
    tp: float | None = None,
    magic: int = 20260101,
    ghi_chu: str = "Fin3B bot",
) -> dict | None:
    """Mở lệnh thị trường với đầy đủ kiểm tra."""
    info = mt5.symbol_info(symbol)
    if info is None:
        raise RuntimeError(f"Symbol không tồn tại: {symbol}")

    if not info.visible:
        mt5.symbol_select(symbol, True)

    tick = mt5.symbol_info_tick(symbol)
    if tick is None:
        raise RuntimeError(f"Không lấy được giá {symbol}")

    if huong == "MUA":
        loai_lenh, gia = mt5.ORDER_TYPE_BUY, tick.ask
    elif huong == "BAN":
        loai_lenh, gia = mt5.ORDER_TYPE_SELL, tick.bid
    else:
        raise ValueError(f"Huong không hợp lệ: {huong}")

    # Kiểm tra khoảng cách stop tối thiểu của broker
    khoang_cach_min = info.trade_stops_level * info.point
    if sl and abs(gia - sl) < khoang_cach_min:
        raise ValueError(f"SL quá gần giá ({abs(gia - sl):.5f} < {khoang_cach_min:.5f})")
    if tp and abs(gia - tp) < khoang_cach_min:
        raise ValueError(f"TP quá gần giá ({abs(gia - tp):.5f} < {khoang_cach_min:.5f})")

    request = {
        "action": mt5.TRADE_ACTION_DEAL,
        "symbol": symbol,
        "volume": chuan_hoa_khoi_luong(symbol, khoi_luong),
        "type": loai_lenh,
        "price": chuan_hoa_gia(symbol, gia),
        "sl": chuan_hoa_gia(symbol, sl) if sl else 0.0,
        "tp": chuan_hoa_gia(symbol, tp) if tp else 0.0,
        "deviation": 20,                    # trượt giá tối đa (point)
        "magic": magic,                     # định danh bot — rất quan trọng
        "comment": ghi_chu,
        "type_time": mt5.ORDER_TIME_GTC,
        "type_filling": mt5.ORDER_FILLING_IOC,
    }

    ket_qua = mt5.order_send(request)

    if ket_qua is None:
        raise RuntimeError(f"order_send trả None: {mt5.last_error()}")

    if ket_qua.retcode != mt5.TRADE_RETCODE_DONE:
        # Ví dụ: không đủ margin, thị trường đóng, giá lệch quá deviation
        raise RuntimeError(
            f"Lệnh thất bại [{ket_qua.retcode}] {ket_qua.comment}"
        )

    return {
        "order": ket_qua.order,
        "deal": ket_qua.deal,
        "gia_khop": ket_qua.price,
        "khoi_luong": ket_qua.volume,
        "retcode": ket_qua.retcode,
    }

import time
import logging
from datetime import datetime

import MetaTrader5 as mt5

logger = logging.getLogger(__name__)


def lay_vi_the_cua_bot(symbol: str, magic: int) -> list:
    """CHỈ lấy vị thế do bot này mở — lọc theo magic."""
    tat_ca = mt5.positions_get(symbol=symbol) or []
    return [p for p in tat_ca if p.magic == magic]


def quản_ly_trailing_stop(symbol: str, magic: int, he_so_atr: float = 2.0):
    """Dời SL theo ATR khi giá đi đúng hướng — khoá lợi nhuận dần."""
    df = lay_nen(symbol, "H1", 100)
    atr = (df["high"] - df["low"]).rolling(14).mean().iloc[-1]

    for vt in lay_vi_the_cua_bot(symbol, magic):
        tick = mt5.symbol_info_tick(symbol)
        info = mt5.symbol_info(symbol)

        if vt.type == mt5.POSITION_TYPE_BUY:
            gia_hien_tai = tick.bid
            sl_moi = gia_hien_tai - atr * he_so_atr

            # Chỉ dời LÊN, không bao giờ dời xuống
            if sl_moi <= vt.sl:
                continue
            if sl_moi <= vt.price_open:
                continue                      # chưa tới điểm hoà vốn
        else:
            gia_hien_tai = tick.ask
            sl_moi = gia_hien_tai + atr * he_so_atr

            if vt.sl != 0 and sl_moi >= vt.sl:
                continue
            if sl_moi >= vt.price_open:
                continue

        request = {
            "action": mt5.TRADE_ACTION_SLTP,
            "symbol": symbol,
            "position": vt.ticket,
            "sl": chuan_hoa_gia(symbol, sl_moi),
            "tp": vt.tp,
            "magic": magic,
        }
        ket_qua = mt5.order_send(request)

        if ket_qua and ket_qua.retcode == mt5.TRADE_RETCODE_DONE:
            logger.info("📈 Dời SL vé %s → %.5f", vt.ticket, sl_moi)
        else:
            logger.warning("Dời SL thất bại vé %s: %s", vt.ticket,
                           ket_qua.comment if ket_qua else mt5.last_error())


def vong_lap_bot(symbol: str, khung: str = "H1", magic: int = 20260101,
                 poll_giay: int = 30, khoi_luong: float = 0.01):
    """Vòng lặp bot hoàn chỉnh."""
    da_xu_ly_nen = None

    while True:
        try:
            df = them_tin_hieu_hma(lay_nen(symbol, khung, 300))
            nen_cuoi = df.index[-1]

            # Chỉ xử lý một lần cho mỗi nến đã đóng
            if nen_cuoi == da_xu_ly_nen:
                quản_ly_trailing_stop(symbol, magic)
                time.sleep(poll_giay)
                continue

            da_xu_ly_nen = nen_cuoi
            dong = df.iloc[-1]

            vi_the = lay_vi_the_cua_bot(symbol, magic)
            co_lenh_mua = any(p.type == mt5.POSITION_TYPE_BUY for p in vi_the)
            co_lenh_ban = any(p.type == mt5.POSITION_TYPE_SELL for p in vi_the)

            tick = mt5.symbol_info_tick(symbol)
            atr = (df["high"] - df["low"]).rolling(14).mean().iloc[-1]

            logger.info("Nến %s | giá %.2f | tăng=%s | giảm=%s | chồng chéo=%s | vị thế=%d",
                        nen_cuoi, dong["close"], dong["xu_huong_tang"],
                        dong["xu_huong_giam"], dong["chong_cheo"], len(vi_the))

            # Bộ lọc: không giao dịch khi HMA chồng chéo
            if dong["chong_cheo"]:
                logger.info("⏸ Bỏ qua — HMA chồng chéo")
                time.sleep(poll_giay)
                continue

            # Giới hạn: tối đa 1 vị thế mỗi hướng
            if dong["doi_sang_tang"] and not co_lenh_mua:
                if co_lenh_ban:
                    dong_tat_ca(symbol, magic)
                mo_lenh(symbol, "MUA", khoi_luong,
                        sl=tick.ask - atr * 2, tp=tick.ask + atr * 4,
                        magic=magic, ghi_chu="HMA tang")

            elif dong["doi_sang_giam"] and not co_lenh_ban:
                if co_lenh_mua:
                    dong_tat_ca(symbol, magic)
                mo_lenh(symbol, "BAN", khoi_luong,
                        sl=tick.bid + atr * 2, tp=tick.bid - atr * 4,
                        magic=magic, ghi_chu="HMA giam")

        except Exception:
            logger.exception("Lỗi trong vòng lặp bot — tiếp tục chạy")

        time.sleep(poll_giay)

import numpy as np
import pandas as pd


def backtest_hma(df: pd.DataFrame, phi_moi_lenh: float = 0.0002) -> dict:
    """Backtest đơn giản: vào lệnh khi xu hướng đổi, đóng khi đảo chiều."""
    vi_the = 0          # 0: không, 1: mua, -1: bán
    gia_vao = 0.0
    von = 1.0
    so_lenh = 0
    thang = 0
    duong_von = []

    for i in range(1, len(df)):
        dong = df.iloc[i]
        gia = dong["close"]

        if vi_the == 0:
            if dong["doi_sang_tang"] and not dong["chong_cheo"]:
                vi_the, gia_vao = 1, gia
                so_lenh += 1
            elif dong["doi_sang_giam"] and not dong["chong_cheo"]:
                vi_the, gia_vao = -1, gia
                so_lenh += 1
        else:
            doi_chieu = ((vi_the == 1 and dong["doi_sang_giam"]) or
                         (vi_the == -1 and dong["doi_sang_tang"]))

            if doi_chieu:
                loi_nhuan = (gia / gia_vao - 1) * vi_the - phi_moi_lenh
                von *= (1 + loi_nhuan)
                if loi_nhuan > 0:
                    thang += 1
                vi_the = 0

        duong_von.append(von)

    duong_von = pd.Series(duong_von)
    dinh = duong_von.cummax()
    drawdown = (duong_von / dinh - 1)

    return {
        "so_lenh": so_lenh,
        "ty_le_thang": round(thang / so_lenh * 100, 1) if so_lenh else 0,
        "loi_nhuan_tong_pct": round((von - 1) * 100, 2),
        "max_drawdown_pct": round(drawdown.min() * 100, 2),
        "he_so_profit_factor": round(von, 4),
    }


df = them_tin_hieu_hma(lay_nen("XAUUSD", "H1", 5000))
print(backtest_hma(df))