quantvn 0.1.0__py3-none-any.whl

quantvn/__init__.py

@@ -0,0 +1,2 @@
+from quantvn import *
+from .vn.data.utils import client

quantvn/crypto/__init__.py

@@ -0,0 +1 @@
+from quantvn.crypto import data

quantvn/crypto/data/__init__.py

@@ -0,0 +1,31 @@
+
+from __future__ import annotations
+
+# Public constants/helpers
+from .const import *  # noqa: F401,F403
+
+# Core helpers (chỉ giữ TA & request)
+from .core import (
+    add_all_ta_features,
+    send_request,
+)
+
+# Crypto (đọc S3)
+from .utils import get_crypto
+
+# Backward-compatibility: giữ get_hist của stocks nếu tồn tại (optional)
+try:
+    from .stocks import get_hist as get_stock_hist  # type: ignore
+    get_hist = get_stock_hist  # alias mặc định
+except Exception:
+    # Không có module stocks trong gói này — bỏ qua
+    pass
+
+__all__ = [
+    # helpers
+    "send_request",
+    # TA features
+    "add_all_ta_features",
+    # crypto
+    "get_crypto",
+]

quantvn/crypto/data/const.py

@@ -0,0 +1,26 @@
+
+TRADING_URL = "https://trading.vietcap.com.vn/api/"
+GRAPHQL_URL = "https://trading.vietcap.com.vn/data-mt/graphql"
+CHART_URL = "chart/OHLCChart/gap-chart"
+INTRADAY_URL = "market-watch"
+
+INTERVAL_MAP = {
+    '1m':'ONE_MINUTE','5m':'ONE_MINUTE','15m':'ONE_MINUTE','30m':'ONE_MINUTE',
+    '1H':'ONE_HOUR','1D':'ONE_DAY','1W':'ONE_DAY','1M':'ONE_DAY'
+}
+
+OHLC_COLUMNS = ["t","o","h","l","c","v"]
+OHLC_RENAME = {"t":"time","o":"open","h":"high","l":"low","c":"close","v":"volume"}
+
+INTRADAY_MAP = {'truncTime':'time','matchPrice':'price','matchVol':'volume','matchType':'match_type','id':'id'}
+
+PRICE_DEPTH_URL = f"{TRADING_URL}{INTRADAY_URL}/AccumulatedPriceStepVol/getSymbolData"
+
+PRICE_INFO_MAP = {
+    'ev':'ev','ticker':'symbol',
+    'open_price':'open','ceiling_price':'ceiling','floor_price':'floor','reference_price':'ref_price',
+    'highest_price':'high','lowest_price':'low',
+    'price_change':'price_change','percent_price_change':'price_change_pct',
+    'foreign_total_volume':'foreign_volume','foreign_total_room':'foreign_room','foreign_holding_room':'foreign_holding_room',
+    'average_match_volume2_week':'avg_match_volume_2w',
+}

quantvn/crypto/data/core.py

@@ -0,0 +1,82 @@
+
+import time, random, requests
+import pandas as pd
+
+DEFAULT_TIMEOUT = 25
+
+def _ua(source="vietmarket"):
+    return {
+        "User-Agent": f"{source}/1.0 (+https://example.local)",
+        "Accept": "application/json, text/plain, */*",
+        "Origin": "https://example.local",
+        "Referer": "https://example.local/",
+    }
+
+def send_request(url, method="GET", headers=None, params=None, payload=None,
+                 retries=2, backoff=(0.6, 1.2), timeout=DEFAULT_TIMEOUT):
+    h = _ua()
+    if headers:
+        h.update(headers)
+    for attempt in range(retries + 1):
+        try:
+            if method.upper() == "GET":
+                r = requests.get(url, headers=h, params=params, timeout=timeout)
+            else:
+                r = requests.post(url, headers=h, params=params, json=payload, timeout=timeout)
+            r.raise_for_status()
+            if "application/json" in r.headers.get("Content-Type", ""):
+                return r.json()
+            return r.text
+        except Exception:
+            if attempt >= retries:
+                raise
+            time.sleep(random.uniform(*backoff))
+
+def add_all_ta_features(
+    df,
+    open: str = "Open",
+    high: str = "High",
+    low: str = "Low",
+    close: str = "Close",
+    volume: str = "Volume",
+    fillna: bool = True,
+):
+    """
+    Thêm toàn bộ technical indicators từ thư viện `ta` vào DataFrame.
+    Giữ nguyên signature giống `ta.add_all_ta_features` để sử dụng y hệt.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        DataFrame phải có các cột giá/khối lượng tương ứng.
+    open,high,low,close,volume : str
+        Tên cột trong df.
+    fillna : bool
+        Nếu True, sẽ điền các giá trị NaN theo mặc định của thư viện `ta`.
+
+    Returns
+    -------
+    pandas.DataFrame
+        DataFrame đầu vào + các cột TA features.
+    """
+    try:
+        from ta import add_all_ta_features as _ta_add_all_ta_features
+        from ta.utils import dropna as _ta_dropna
+    except Exception as e:
+        raise ImportError(
+            "Thiếu thư viện 'ta'. Hãy cài: pip install ta"
+        ) from e
+
+    # Làm sạch NaN theo chuẩn của 'ta'
+    _df = _ta_dropna(df.copy())
+
+    # Gọi trực tiếp hàm gốc
+    return _ta_add_all_ta_features(
+        _df,
+        open=open,
+        high=high,
+        low=low,
+        close=close,
+        volume=volume,
+        fillna=fillna,
+    )

quantvn/crypto/data/derivatives.py

@@ -0,0 +1,22 @@
+
+"""
+ĐÃ THAY THẾ: Module derivatives nay đã được thay bằng hàm `get_crypto` (đọc dữ liệu crypto từ S3).
+Vui lòng chuyển sang: from .crypto import get_crypto
+"""
+from __future__ import annotations
+
+from .utils import get_crypto as _get_crypto
+
+__all__ = ["get_hist"]
+
+def get_hist(symbol: str, frequency: str = "1D", *, days: int | None = None, **kwargs):
+    """
+    [Deprecated] Giả lập API cũ:
+    - Bỏ qua tham số `frequency` của phái sinh; dùng `days` nếu truyền vào.
+    - Gọi sang crypto.get_crypto(...).
+    """
+    if days is None:
+        # Mặc định map frequency sang days đơn giản
+        freq_map = {"1D": 365, "1H": 30, "5M": 7}
+        days = freq_map.get(str(frequency).upper(), None)
+    return _get_crypto(symbol, days=days, **kwargs)

quantvn/crypto/data/utils.py

@@ -0,0 +1,93 @@
+# quantvn/crypto/data/utils.py
+from __future__ import annotations
+from typing import Optional, Literal
+import io
+import pandas as pd
+import boto3, requests
+from botocore.exceptions import ClientError, NoCredentialsError
+from botocore.config import Config
+from botocore import UNSIGNED
+
+__all__ = ["get_crypto"]
+
+def get_crypto(
+    symbol: str,
+    days: Optional[int] = None,
+    *,
+    bucket: str = "qco-market",
+    prefix: str = "data-csv",
+    session: Optional[boto3.Session] = None,
+    auth: Literal["auto", "signed", "unsigned"] = "auto",
+) -> pd.DataFrame:
+    """
+    Đọc s3://{bucket}/{prefix}/{symbol}.csv và (tuỳ chọn) lọc N ngày.
+    - auth="auto": thử signed; nếu không có credential → fallback unsigned → fallback HTTP.
+    - auth="signed": chỉ signed (bắt buộc user có credential).
+    - auth="unsigned": luôn truy cập ẩn danh (chỉ dùng khi object public).
+    """
+    key = f"{prefix.rstrip('/')}/{symbol}.csv" if prefix else f"{symbol}.csv"
+    session = session or boto3.Session()
+
+    def _post(df: pd.DataFrame) -> pd.DataFrame:
+        if "datetime" not in df.columns:
+            raise KeyError("CSV phải có cột 'datetime'.")
+        df["datetime"] = pd.to_datetime(df["datetime"], errors="coerce", utc=True)
+        if days is not None:
+            cutoff = pd.Timestamp.utcnow() - pd.Timedelta(days=days)
+            df = df[df["datetime"] >= cutoff].copy()
+        df.attrs["s3_key"] = key
+        return df
+
+    def _read_via_boto(client) -> pd.DataFrame:
+        obj = client.get_object(Bucket=bucket, Key=key)
+        return _post(pd.read_csv(obj["Body"]))
+
+    def _http_fallback(possible_region: Optional[str] = None) -> pd.DataFrame:
+        # S3 virtual-hosted–style URL; requests sẽ tự theo redirect nếu region khác. :contentReference[oaicite:1]{index=1}
+        urls = [
+            f"https://{bucket}.s3.amazonaws.com/{key}",
+        ]
+        if possible_region:
+            urls.insert(0, f"https://{bucket}.s3.{possible_region}.amazonaws.com/{key}")
+        for url in urls:
+            r = requests.get(url, timeout=30)
+            if r.ok:
+                return _post(pd.read_csv(io.BytesIO(r.content)))
+        raise PermissionError(
+            "AccessDenied khi dùng unsigned/HTTP. Hãy bật public-read cho prefix hoặc cung cấp credential/presigned URL."
+        )
+
+    # 1) Chế độ ép unsigned ngay từ đầu
+    if auth == "unsigned":
+        try:
+            s3u = session.client("s3", config=Config(signature_version=UNSIGNED))  # :contentReference[oaicite:2]{index=2}
+            return _read_via_boto(s3u)
+        except ClientError as e:
+            region = e.response.get("ResponseMetadata", {}).get("HTTPHeaders", {}).get("x-amz-bucket-region")
+            return _http_fallback(region)
+
+    # 2) signed hoặc auto (ưu tiên signed)
+    try:
+        s3 = session.client("s3")
+        return _read_via_boto(s3)
+    except NoCredentialsError:
+        if auth == "signed":
+            raise
+        # auto → fallback unsigned
+        try:
+            s3u = session.client("s3", config=Config(signature_version=UNSIGNED))  # :contentReference[oaicite:3]{index=3}
+            return _read_via_boto(s3u)
+        except ClientError as e:
+            region = e.response.get("ResponseMetadata", {}).get("HTTPHeaders", {}).get("x-amz-bucket-region")
+            return _http_fallback(region)
+    except ClientError as e:
+        # Trường hợp sai region → thử lại signed với region thật; nếu vẫn fail → HTTP
+        region = e.response.get("ResponseMetadata", {}).get("HTTPHeaders", {}).get("x-amz-bucket-region")
+        if region:
+            try:
+                s3r = session.client("s3", region_name=region)
+                return _read_via_boto(s3r)
+            except Exception:
+                pass
+        # Cuối cùng: HTTP
+        return _http_fallback(region)

quantvn/metrics/__init__.py

@@ -0,0 +1,3 @@
+from quantvn.metrics.single_asset import TradingBacktest
+from quantvn.metrics.st import StockAlgorithm
+__all__ = ["TradingBacktest", "StockAlgorithm"]

quantvn/metrics/single_asset.py

@@ -0,0 +1,419 @@
+import numpy as np
+import pandas as pd
+
+
+class TradingBacktest:
+    """
+    A class for backtesting derivatives trading strategies.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Dataframe containing historical data with columns ['date', 'time', 'close', 'position'].
+    pnl_type : str, optional
+        Type of PNL calculation ('raw' or 'after_fees'), by default 'raw'.
+
+    Raises    ------
+    ValueError
+        If pnl_type is not 'raw' or 'after_fees'.
+    NotImplementedError
+        If pnl_type is 'after_fees'
+    """
+
+    def __init__(self, df, pnl_type="raw"):
+        """
+        Initializes the BacktestDerivates class.
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            Data containing trade details.
+        pnl_type : str, optional
+            Type of PNL calculation ('raw' or 'after_fees'), by default "after_fees".
+        """
+        if pnl_type not in ["raw", "after_fees"]:
+            raise ValueError("Invalid pnl_type. Choose 'raw' or 'after_fees'.")
+
+        if pnl_type == "after_fees":
+            raise NotImplementedError
+
+        self.df = df.copy()
+        self.pnl_type = pnl_type
+
+        # Check if DataFrame already has DateTimeIndex
+        if not isinstance(df.index, pd.DatetimeIndex):
+            self.df.index = pd.to_datetime(self.df["date"] + " " + self.df["time"])
+
+        self.df = self.df.sort_index()
+
+        # Calculate PNL
+        self.df["pnl_raw"] = self.df["close"].diff().shift(-1) * self.df["position"]
+        self.df["pnl_raw"] = self.df["pnl_raw"].fillna(0)
+
+        self.daily_pnl = self.compute_daily_pnl()
+
+    def compute_cumulative_pnl(self):
+        """
+        Calculate cumulative PNL based on selected pnl_type.
+
+        Returns
+        -------
+        pandas.Series
+            Cumulative PNL.
+        """
+        return self.df[f"pnl_{self.pnl_type}"].cumsum()
+
+    def compute_daily_pnl(self):
+        """
+        Calculate daily PNL based on selected pnl_type.
+
+        Returns
+        -------
+        pandas.Series
+            Daily PNL.
+        """
+        return self.df.groupby(self.df["date"])[f"pnl_{self.pnl_type}"].sum()
+
+    def estimate_minimum_capital(self):
+        """
+        Estimate the minimum capital required to run the strategy.
+
+        Returns
+        -------
+        float
+            Minimum capital required.
+        """
+        self.df["cumulative_pnl"] = self.compute_cumulative_pnl()
+        self.df["capital_required"] = (self.df["position"].abs() * self.df["close"]) - self.df["cumulative_pnl"]
+
+        return max(self.df["capital_required"].max(), 0)
+
+    def compute_pnl_percentage(self):
+        """
+        Calculate PNL percentage relative to minimum required capital.
+
+        Returns
+        -------
+        float
+            PNL percentage.
+        """
+        min_capital = self.estimate_minimum_capital()
+        return self.daily_pnl / min_capital if min_capital != 0 else np.nan  # avoid division by 0
+
+    def avg_loss(self):
+        """
+        Compute the average loss from daily PNL.
+
+        Returns
+        -------
+        float
+            Average loss.
+        """
+        losses = self.daily_pnl[self.daily_pnl < 0]
+        return losses.mean()
+
+    def avg_return(self):
+        """
+        Compute the average return from daily PNL.
+
+        Returns
+        -------
+        float
+            Average return.
+        """
+        return self.daily_pnl.mean()
+
+    def avg_win(self):
+        """
+        Compute the average win from daily PNL.
+
+        Returns
+        -------
+        float
+            Average win.
+        """
+        wins = self.daily_pnl[self.daily_pnl > 0]
+        return wins.mean()
+
+    def avg_loss_pct(self, initial_capital=1):
+        """
+        Compute the average loss (percentage) from daily PNL.
+
+        Returns
+        -------
+        float
+            Average loss.
+        """
+        losses = self.daily_pnl[self.daily_pnl < 0]
+        return losses.mean() / initial_capital
+
+    def avg_return_pct(self, initial_capital=1):
+        """
+        Compute the average return (percentage) from daily PNL.
+
+        Returns
+        -------
+        float
+            Average return.
+        """
+        return self.daily_pnl.mean() / initial_capital
+
+    def avg_win_pct(self, initial_capital=1):
+        """
+        Compute the average win (percentage) from daily PNL.
+
+        Returns
+        -------
+        float
+            Average win.
+        """
+        wins = self.daily_pnl[self.daily_pnl > 0]
+        return wins.mean() / initial_capital
+
+    def max_drawdown(self):
+        """
+        Compute the maximum drawdown.
+
+        Returns
+        -------
+        float
+            Maximum drawdown as a percentage of minimum capital.
+        """
+        cumulative_daily_pnl = self.daily_pnl.cumsum()
+        peak = cumulative_daily_pnl.cummax()
+        drawdown = cumulative_daily_pnl - peak
+        return drawdown.min() / self.estimate_minimum_capital()
+
+    def win_rate(self):
+        """
+        Compute the win rate.
+
+        Returns
+        -------
+        float
+            Win rate.
+        """
+        wins = (self.daily_pnl > 0).sum()
+        total = len(self.daily_pnl)
+        return wins / total if total > 0 else 0
+
+    def volatility(self):
+        """
+        Compute the standard deviation of daily PNL.
+
+        Returns
+        -------
+        float
+            Volatility.
+        """
+        return self.daily_pnl.std()
+
+    def sharpe(self):
+        """
+        Compute the Sharpe ratio.
+
+        Returns
+        -------
+        float
+            Sharpe ratio.
+        """
+        return self.avg_return() / self.volatility() * np.sqrt(252)
+
+    def sortino(self):
+        """
+        Compute the Sortino ratio.
+
+        Returns
+        -------
+        float
+            Sortino ratio.
+        """
+        downside_std = self.daily_pnl[self.daily_pnl < 0].std()
+        return self.avg_return() / downside_std * np.sqrt(252) if downside_std > 0 else np.nan
+
+    def calmar(self):
+        """
+        Compute the Calmar ratio.
+
+        Returns
+        -------
+        float
+            Calmar ratio.
+        """
+        return self.avg_return() / abs(self.max_drawdown()) * np.sqrt(252) if self.max_drawdown() != 0 else np.nan
+
+    def profit_factor(self):
+        """
+        Compute the profit factor.
+
+        Returns
+        -------
+        float
+            Profit factor.
+        """
+        total_gain = self.daily_pnl[self.daily_pnl > 0].sum()
+        total_loss = abs(self.daily_pnl[self.daily_pnl < 0].sum())
+        return total_gain / total_loss if total_loss != 0 else np.nan  # avoid division by 0
+
+    def risk_of_ruin(self, initial_capital=1):
+        """
+        Compute risk of ruin.
+
+        Returns
+        -------
+        float
+            Risk of ruin.
+        """
+        win_rate = self.win_rate()
+        loss_rate = 1 - win_rate
+        avg_loss_pct = self.avg_loss_pct(initial_capital)
+        return (loss_rate / win_rate) ** (1 / avg_loss_pct) if avg_loss_pct != 0 else np.nan
+
+    def value_at_risk(self, confidence_level=0.05):
+        """
+        Compute Value at Risk (VaR).
+
+        Parameters
+        ----------
+        confidence_level : float, optional
+            Confidence level for VaR, by default 0.05.
+
+        Returns
+        -------
+        float
+            Value at Risk (VaR).
+        """
+        return self.daily_pnl.quantile(confidence_level)
+
+    def apply_tp_sl(self, df, tp_percentage, sl_percentage):
+        if not isinstance(df.index, pd.DatetimeIndex):
+            raise ValueError("The DataFrame index must be a DatetimeIndex")
+
+        prices = df["close"]
+        positions = df["position"]
+        new_positions = positions.copy()
+
+        assert set(positions.unique()) == {-1, 0, 1}, "Positions must be -1 (Short), 0 (Neutral), 1 (Long) only"
+
+        # Tracking for each holding window
+        entry_price = None
+        entry_position = 0
+        profit_flag = False
+
+        for i in range(0, len(prices)):
+            position = positions.iloc[i]
+
+            # Neutral resets position
+            if position == 0:
+                entry_position = 0
+                profit_flag = False
+                continue
+
+            # New position
+            if position != entry_position:
+                entry_price = prices.iloc[i]
+                entry_position = position
+                profit_flag = False
+            # Hold position
+            else:
+                current_price = prices.iloc[i]
+
+                # PnL % of Long (1) and Short (-1)
+                if position == 1:
+                    pnl_percentage = (current_price - entry_price) / entry_price * 100
+                else:
+                    pnl_percentage = (entry_price - current_price) / entry_price * 100
+
+                # Reach profit threshold
+                if pnl_percentage >= tp_percentage:
+                    if not profit_flag:
+                        profit_flag = True  # hold for 1 more timestep
+                    else:
+                        new_positions.iloc[i] = 0
+                        entry_position = 0
+                        profit_flag = False
+
+                # Reach loss threshold
+                if pnl_percentage <= -sl_percentage:
+                    new_positions.iloc[i] = 0
+                    entry_position = 0
+
+        return new_positions
+
+    def apply_tp_sl_trailing(self, df, tp_percentage, sl_percentage):
+        if not isinstance(df.index, pd.DatetimeIndex):
+            raise ValueError("The DataFrame index must be a DatetimeIndex")
+
+        prices = df["close"]
+        positions = df["position"]
+        new_positions = positions.copy()
+
+        assert set(positions.unique()) == {-1, 0, 1}, "Positions must be -1 (Short), 0 (Neutral), 1 (Long) only"
+
+        # Tracking for trailing stop loss
+        max_price = None
+        min_price = None
+        trailing_sl = None
+
+        # Tracking for each holding window
+        entry_price = None
+        entry_position = 0
+        profit_flag = False
+
+        for i in range(0, len(prices)):
+            position = positions.iloc[i]
+
+            # Neutral resets position
+            if position == 0:
+                entry_position = 0
+                continue
+
+            # New position
+            if position != entry_position:
+                entry_price = prices.iloc[i]
+                entry_position = position
+                profit_flag = False
+
+                max_price = entry_price
+                min_price = entry_price
+
+                if position == 1:
+                    trailing_sl = entry_price * (1 - sl_percentage / 100)
+                else:
+                    trailing_sl = entry_price * (1 + sl_percentage / 100)
+            # Hold position
+            else:
+                current_price = prices.iloc[i]
+
+                # PnL % of Long (1) and Short (-1)
+                if position == 1:
+                    pnl_percentage = (current_price - entry_price) / entry_price * 100
+                else:
+                    pnl_percentage = (entry_price - current_price) / entry_price * 100
+
+                # Take profit threshold
+                if pnl_percentage >= tp_percentage:
+                    if not profit_flag:
+                        profit_flag = True  # hold for 1 more timestep
+                    else:
+                        new_positions.iloc[i] = 0
+                        entry_position = 0
+                        profit_flag = False
+
+                # Reach / update trailing stop loss for Long (1) and Short (-1)
+                if position == 1:
+                    if current_price <= trailing_sl:
+                        new_positions.iloc[i] = 0
+                        entry_position = 0
+                    elif current_price > max_price:
+                        max_price = current_price
+                        trailing_sl = max_price * (1 - sl_percentage / 100)
+                else:
+                    if current_price >= trailing_sl:
+                        new_positions.iloc[i] = 0
+                        entry_position = 0
+                    elif current_price < min_price:
+                        min_price = current_price
+                        trailing_sl = min_price * (1 + sl_percentage / 100)
+
+        return new_positions