quantvn 0.1.0__py3-none-any.whl

quantvn/vn/data/utils.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Optional
+
+
+class APIKeyNotSetError(ValueError):
+    """Raised when API key has not been set."""
+
+
+class Config:
+    """
+    Configuration class for managing the API key and providing the API endpoint.
+
+    Attributes:
+        _api_key (str | None): The stored API key. Defaults to None.
+    """
+
+    _api_key: Optional[str] = None
+
+    @classmethod
+    def set_api_key(cls, apikey: str):
+        """
+        Set the API key without validation.
+
+        Raises:
+            ValueError: Empty key.
+        """
+        if not isinstance(apikey, str) or not apikey.strip():
+            raise ValueError("API key must be a non-empty string.")
+        cls._api_key = apikey.strip()
+
+    @classmethod
+    def get_api_key(cls) -> str:
+        """
+        Retrieve the currently set API key.
+
+        Raises:
+            APIKeyNotSetError: If the API key has not been set.
+        """
+        if cls._api_key is None:
+            raise APIKeyNotSetError(
+                "API key is not set. Use client(apikey=...) to set it."
+            )
+        return cls._api_key
+
+    @classmethod
+    def get_link(cls) -> str:
+        """Return the API base URL."""
+        return "https://d207hp2u5nyjgn.cloudfront.net"
+
+
+def client(apikey: str):
+    """
+    Convenience function to set the API key.
+    """
+    Config.set_api_key(apikey)

quantvn/vn/metrics/__init__.py

@@ -0,0 +1,4 @@
+from quantvn.vn.metrics.metrics import Metrics
+from quantvn.vn.metrics.backtest import Backtest_Derivates, Backtest_Stock
+
+__all__ = ["Metrics", "Backtest_Derivates", "Backtest_Stock"]

quantvn/vn/metrics/backtest.py

@@ -0,0 +1,323 @@
+# ===== Backtest_Stock & helpers (migrated from your “second block”) =====
+import logging
+from abc import abstractmethod
+from typing import TypedDict, List, Dict, Union
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+class Backtest_Derivates:
+    """
+    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 'after_fees'.
+
+    Raises
+    ------
+    ValueError
+        If pnl_type is not 'raw' or 'after_fees'.
+    """
+
+    def __init__(self, df, pnl_type="after_fees"):
+        """
+        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'.")
+
+        self.df = df.copy()
+        self.pnl_type = pnl_type
+        self.df["datetime"] = pd.to_datetime(self.df["Date"] + " " + self.df["time"])
+        self.df.set_index("datetime", inplace=True)
+        self.df.sort_index(inplace=True)
+
+        # Calculate raw PNL
+        self.df["pnl_raw"] = self.df["Close"].diff().shift(-1) * self.df["position"]
+        self.df["pnl_raw"].fillna(0, inplace=True)
+
+        # Calculate PNL after fees
+        transaction_fee = 2700 / 100000  # VND per contract
+        overnight_fee = 2550 / 100000  # VND per contract per day if held overnight
+
+        self.df["transaction_fee"] = self.df["position"].diff().abs() * transaction_fee
+
+        # Identify overnight holdings
+        self.df["date"] = self.df.index.date
+        self.df["overnight"] = (self.df["position"] > 0) & (
+            self.df["date"] != self.df["date"].shift()
+        )
+        self.df["overnight_fee"] = self.df["overnight"] * overnight_fee
+
+        self.df["total_fee"] = self.df["transaction_fee"].fillna(0) + self.df[
+            "overnight_fee"
+        ].fillna(0)
+        self.df["pnl_after_fees"] = self.df["pnl_raw"] - self.df["total_fee"]
+
+    def 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 daily_PNL(self):
+        """
+        Calculate daily PNL based on selected pnl_type.
+
+        Returns
+        -------
+        pandas.Series
+            Daily cumulative PNL.
+        """
+        daily_pnl = (
+            self.df.groupby(self.df.index.date)[f"pnl_{self.pnl_type}"].sum().cumsum()
+        )
+        return daily_pnl
+
+    def estimate_minimum_capital(self):
+        """
+        Estimate the minimum capital required to run the strategy.
+
+        Returns
+        -------
+        float
+            Minimum capital required.
+        """
+        self.df["cumulative_pnl"] = (
+            self.df[f"pnl_{self.pnl_type}"].cumsum().shift().fillna(0)
+        )
+        self.df["capital_required"] = (
+            self.df["position"].abs() * self.df["Close"]
+        ) - self.df["cumulative_pnl"]
+
+        return max(self.df["capital_required"].max(), 0)
+
+    def PNL_percentage(self):
+        """
+        Calculate PNL percentage relative to minimum required capital.
+
+        Returns
+        -------
+        float
+            PNL percentage.
+        """
+        min_capital = self.estimate_minimum_capital()
+        if min_capital == 0:
+            return np.nan  # Avoid division by zero
+        return self.daily_PNL() / min_capital
+
+    def avg_pos(self):
+        """
+        Calculate average daily pos enter
+
+        Returns
+        -------
+        float
+            Average pos enter per day
+        """
+        return abs(self.df['position'].diff().dropna()).sum()/len(self.daily_PNL())
+
+
+class Backtest_Stock:
+    """
+    Backtest cổ phiếu (long-only):
+    - Phí giao dịch 0.1% trên giá trị khớp (mua + bán)
+    - Ép giữ tối thiểu 'min_hold_days' phiên (T+2.5 ~ 3 phiên)
+    Kỳ vọng input df có cột: ['Date','time','Close','position'].
+    'position' = số lượng cổ phiếu mong muốn (âm sẽ bị cắt về 0).
+    """
+
+    def __init__(self, df: pd.DataFrame, pnl_type: str = "after_fees", min_hold_days: int = 3):
+        if pnl_type not in ["raw", "after_fees"]:
+            raise ValueError("Invalid pnl_type. Choose 'raw' or 'after_fees'.")
+
+        self.pnl_type = pnl_type
+        self.min_hold_days = int(min_hold_days)
+
+        # Chuẩn hóa thời gian & index
+        self.df = df.copy()
+        self.df["datetime"] = pd.to_datetime(self.df["Date"].astype(str) + " " + self.df["time"].astype(str), errors="coerce")
+        self.df = self.df.dropna(subset=["datetime"])
+        self.df.set_index("datetime", inplace=True)
+        self.df.sort_index(inplace=True)
+
+        # Long-only ý định
+        self.df["Close"] = pd.to_numeric(self.df["Close"], errors="coerce")
+        self.df = self.df.dropna(subset=["Close"])
+        self.df["position_intent"] = pd.to_numeric(self.df["position"], errors="coerce").fillna(0).clip(lower=0).astype(float)
+
+        # Xây effective position tôn trọng min_hold theo SỐ PHIÊN
+        eff_pos, trade_qty = self._build_effective_position_with_min_hold(
+            index=self.df.index,
+            desired_positions=self.df["position_intent"].to_numpy(dtype=float),
+            min_hold_days=self.min_hold_days,
+        )
+        # Trả về numpy → gán theo vị trí, tránh lệch index
+        self.df["effective_position"] = eff_pos
+        self.df["trade_qty"] = trade_qty
+
+        # PnL: giữ vị thế từ bar t -> t+1
+        self.df["pnl_raw"] = self.df["Close"].diff().shift(-1).fillna(0) * self.df["effective_position"]
+
+        # Phí giao dịch: 0.1% notional mỗi lần khớp
+        fee_rate = 0.001
+        notional_traded = np.abs(self.df["trade_qty"].to_numpy()) * self.df["Close"].to_numpy()
+        self.df["transaction_fee"] = notional_traded * fee_rate
+
+        self.df["pnl_after_fees"] = self.df["pnl_raw"] - self.df["transaction_fee"]
+
+    @staticmethod
+    def _build_effective_position_with_min_hold(
+        index: pd.DatetimeIndex,
+        desired_positions: np.ndarray,
+        min_hold_days: int = 3,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Tạo chuỗi vị thế thực sự (long-only) với ràng buộc giữ tối thiểu N phiên.
+        Dùng FIFO lots: mỗi lot có (qty_remaining, day_id_entry).
+
+        - index: DatetimeIndex (để nhóm ngày/phiên)
+        - desired_positions: mảng số lượng mong muốn theo bar (>=0)
+        - min_hold_days: số phiên tối thiểu cần giữ mới được bán
+        """
+        n = len(desired_positions)
+        if len(index) != n:
+            raise ValueError("index and desired_positions must have the same length")
+
+        # Ánh xạ mỗi timestamp sang mã phiên tăng dần (0,1,2,...) theo NGÀY (calendar day)
+        # Nếu cần đúng 'trading days' theo lịch nghỉ lễ, hãy thay bằng lịch giao dịch VN.
+        dates = pd.Index(index.date)
+        day_change = np.r_[True, dates[1:] != dates[:-1]]
+        day_id = np.cumsum(day_change) - 1  # 0-based day id
+
+        effective_pos = np.zeros(n, dtype=float)
+        trade_qty = np.zeros(n, dtype=float)
+
+        # FIFO lots: list of [qty_remaining, entry_day_id]
+        lots: list[list[float | int]] = []
+        prev_effective = 0.0
+
+        for i in range(n):
+            desired = float(max(0.0, desired_positions[i]))
+
+            if i == 0:
+                # Mua vào nếu cần ở bar đầu
+                buy_qty = max(0.0, desired - prev_effective)
+                if buy_qty > 0:
+                    lots.append([buy_qty, int(day_id[i])])
+                    trade_qty[i] = buy_qty
+                    prev_effective += buy_qty
+                # Luôn chốt effective_pos cho bar này
+                effective_pos[i] = prev_effective
+                continue
+
+            if desired > prev_effective:
+                # Cần mua thêm
+                buy_qty = desired - prev_effective
+                if buy_qty > 1e-12:
+                    lots.append([buy_qty, int(day_id[i])])
+                    trade_qty[i] = buy_qty
+                    prev_effective += buy_qty
+
+            elif desired < prev_effective:
+                # Cần bán bớt, nhưng chỉ bán các lot đã đủ số phiên
+                to_sell = prev_effective - desired
+                if to_sell > 1e-12:
+                    # Bán theo FIFO, chỉ những lot đủ điều kiện
+                    sell_now_total = 0.0
+                    for lot in lots:
+                        if to_sell <= 1e-12:
+                            break
+                        qty_rem, d_entry = lot
+                        if qty_rem <= 1e-12:
+                            continue
+                        # Đủ điều kiện nếu số PHIÊN đã qua >= min_hold_days
+                        if (int(day_id[i]) - int(d_entry)) >= min_hold_days:
+                            sell_amt = min(qty_rem, to_sell)
+                            lot[0] = qty_rem - sell_amt
+                            to_sell -= sell_amt
+                            sell_now_total += sell_amt
+                    # Dọn các lot trống
+                    lots = [lot for lot in lots if lot[0] > 1e-12]
+                    if sell_now_total > 1e-12:
+                        trade_qty[i] = -sell_now_total
+                        prev_effective -= sell_now_total
+
+            # Luôn set effective_pos ở CUỐI vòng lặp
+            effective_pos[i] = prev_effective
+
+        return effective_pos, trade_qty
+
+    # ======= Các API kết quả =======
+    def PNL(self) -> pd.Series:
+        return self.df[f"pnl_{self.pnl_type}"].cumsum()
+
+    def daily_PNL(self) -> pd.Series:
+        ser = self.df.groupby(self.df.index.date)[f"pnl_{self.pnl_type}"].sum()
+        return ser.cumsum()
+
+    def estimate_minimum_capital(self) -> float:
+        # Ước lượng nhu cầu vốn tối thiểu thô: notional giữ - lũy kế PnL tại mỗi thời điểm
+        cum_pnl = self.df[f"pnl_{self.pnl_type}"].cumsum().shift().fillna(0.0)
+        capital_required = (self.df["effective_position"].abs() * self.df["Close"]) - cum_pnl
+        return float(max(capital_required.max(), 0.0))
+
+    def PNL_percentage(self) -> pd.Series:
+        min_capital = self.estimate_minimum_capital()
+        if min_capital == 0:
+            return pd.Series(dtype=float)
+        return self.daily_PNL() / min_capital
+
+    def avg_pos(self) -> float:
+        # Trung bình thay đổi vị thế theo ngày (từ effective_position)
+        d = self.df["effective_position"].diff().abs().dropna().sum()
+        days = max(len(self.daily_PNL()), 1)
+        return float(d / days)
+
+    # ======= Plot giống backtest_derivative (giá + vị thế + equity + volume giao dịch) =======
+    def plot_PNL(self, daily: bool = False, title: str = "Backtest Stock"):
+        """
+        Vẽ duy nhất 1 đường equity sau phí.
+        - daily=False: tích lũy theo từng bar
+        - daily=True : gộp theo ngày rồi mới tích lũy
+        """
+        if "pnl_after_fees" not in self.df.columns:
+            raise ValueError("Chưa có cột 'pnl_after_fees' trong self.df")
+
+        if daily:
+            eq = self.df.groupby(self.df.index.date)["pnl_after_fees"].sum().cumsum()
+            x = pd.to_datetime(eq.index)
+            y = eq.values
+            x_label = "Date"
+        else:
+            eq = self.df["pnl_after_fees"].cumsum()
+            x = eq.index
+            y = eq.values
+            x_label = "Time"
+
+        plt.figure(figsize=(10, 4))
+        plt.plot(x, y, linewidth=1.4)
+        plt.title(title)
+        plt.xlabel(x_label)
+        plt.ylabel("Cumulative PnL (after fees)")
+        plt.grid(True, alpha=0.3)
+        plt.tight_layout()
+        plt.show()
+
+

quantvn/vn/metrics/metrics.py

@@ -0,0 +1,185 @@
+import numpy as np
+
+
+class Metrics:
+    """
+    A class for calculating performance metrics from backtest results.
+
+    Parameters
+    ----------
+    backtest : BacktestDerivatives
+        An instance of BacktestDerivatives containing PNL data.
+    """
+
+    def __init__(self, backtest):
+        """
+        Initializes the Metrics class.
+
+        Parameters
+        ----------
+        backtest : BacktestDerivates
+            Instance of backtest results.
+        """
+        self.backtest = backtest
+        self.daily_pnl = backtest.daily_PNL().diff().dropna()
+
+    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 max_drawdown(self):
+        """
+        Compute the maximum drawdown.
+
+        Returns
+        -------
+        float
+            Maximum drawdown as a percentage of minimum capital.
+        """
+        cumulative = self.daily_pnl.cumsum()
+        peak = cumulative.cummax()
+        drawdown = cumulative - peak
+        return drawdown.min() / self.backtest.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, risk_free_rate=0.0):
+        """
+        Compute the Sharpe ratio.
+
+        Returns
+        -------
+        float
+            Sharpe ratio.
+        """
+        return (self.avg_return() - risk_free_rate) / 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 (
+            np.sqrt(252) * self.avg_return() / downside_std
+            if downside_std > 0
+            else np.nan
+        )
+
+    def calmar(self):
+        """
+        Compute the Calmar ratio.
+
+        Returns
+        -------
+        float
+            Calmar ratio.
+        """
+        return (
+            np.sqrt(252) * self.avg_return() / abs(self.max_drawdown())
+            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
+
+    def risk_of_ruin(self):
+        """
+        Compute risk of ruin.
+
+        Returns
+        -------
+        float
+            Risk of ruin.
+        """
+        win_rate = self.win_rate()
+        loss_rate = 1 - win_rate
+        return (
+            (loss_rate / win_rate) ** (1 / self.avg_loss())
+            if self.avg_loss() != 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)

quantvn-0.1.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: quantvn
+Version: 0.1.0
+Summary: QuantVN API Library for Financial Data Analysis
+Author: quantvn
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

quantvn-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+quantvn/__init__.py,sha256=9YPnywBFZuYcjgMWWMsnRavq1PnxmDylns5KMWjxuBo,56
+quantvn/crypto/__init__.py,sha256=90HTV3rYM6sJ6l6VXXFdffOT0ZTHXnE-UeXJzX1KBGk,32
+quantvn/crypto/data/__init__.py,sha256=7i4ylyHDdyt9XDO9SXre67_nuUCUhQxbHqBq2Cniz8g,685
+quantvn/crypto/data/const.py,sha256=qLTAycWZHRwtj-mSOT2RB9YFbGFPiFUFnNtuknbbUGE,1143
+quantvn/crypto/data/core.py,sha256=ajcV3xRG3CrkfB71-QZjwqsJ5HfMrLwVXciDxO0onYM,2465
+quantvn/crypto/data/derivatives.py,sha256=HsaOScXpRx91w8hDdSueTNyLt0VcdCeSSPgnALMYHgY,806
+quantvn/crypto/data/utils.py,sha256=x2qAmr_00yZ4LpEqN1WJzKvuhfd-NFZCY9aWS8Z5Ieo,3911
+quantvn/metrics/__init__.py,sha256=RkItghoyBNiZ9m7ZUqydlGEnr0z8G80se4yQZnyxX_4,151
+quantvn/metrics/portfolio.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quantvn/metrics/single_asset.py,sha256=tVrg3Hw8H-lkpUlklvn9LLcE_RrsCOf9csEiGS_nZx8,12265
+quantvn/metrics/st.py,sha256=VTAZXrrnhwdSpwPlufvYWjizLMsnFaGrPQe7GZayekI,22004
+quantvn/paper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quantvn/paper/portfolio.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quantvn/paper/single_asset.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quantvn/vn/__init__.py,sha256=TUU3zltaExQdwUukUPxwGX5XOLQ1kTssdilZkTAiYkM,37
+quantvn/vn/data/__init__.py,sha256=4l2RwFBOjSzn-H1tUNFTWd8QMcxBv9s6BuoA9N3uRvQ,3467
+quantvn/vn/data/const.py,sha256=4owcC4Ik8Fw8kBhXrLEd9Ux9_MPriSh52OOZQWI795E,1144
+quantvn/vn/data/core.py,sha256=zzuBLBBOuplD-cBDIFEICLbRPXy1_sLHhL4vCTS6M78,35631
+quantvn/vn/data/derivatives.py,sha256=h_PeYj8r7pPgS4Z1AJmtZgXiQWiadQL15yKHE0wXx3Q,1698
+quantvn/vn/data/stocks.py,sha256=cTOERdmCEaLx-mG2tXGxV9b1Hmm7u6EPnVV4d36BiCQ,41772
+quantvn/vn/data/utils.py,sha256=mI0gN_zi21WLDXTGkZCv6V57HwS-LDGadMXBHvR_CLo,1376
+quantvn/vn/metrics/__init__.py,sha256=QGxaESHiAnI24yWPjLCYti1O1twU5pU31yKA5L9QPgk,185
+quantvn/vn/metrics/backtest.py,sha256=w9nG1opPcs8J6g_zfbKrkrd3xrCXeqlW0P7_-eOR_FE,12257
+quantvn/vn/metrics/metrics.py,sha256=9NTiucx7PNI2PhGSJ8Jju_R0LOA7fl9i0776OoaM6rg,4216
+quantvn-0.1.0.dist-info/licenses/LICENSE,sha256=JHlulH_fR5VN3pNTj_4p4w-I-HjxDGNjX2i6qAzNEJw,1064
+quantvn-0.1.0.dist-info/METADATA,sha256=L2f56qCncqD0dZAq3fgYe9jRGGE3k0iVlL_Tm7k_LVg,780
+quantvn-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quantvn-0.1.0.dist-info/top_level.txt,sha256=04ce9JXFm3R7Lpv3jcyrEa8UYAgWpJNDvn2SJzfhkMs,8
+quantvn-0.1.0.dist-info/RECORD,,

quantvn-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quantvn-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 XNO API
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

quantvn-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+quantvn