tradepose-client 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

tradepose_client/models.py

@@ -9,79 +9,86 @@ Pydantic 模型用於策略配置 (V2 - 自動轉換版本)
 import json
 from enum import Enum
 from io import StringIO
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Annotated, Any, Dict, List, Optional, Union
 
 import polars as pl
-from pydantic import BaseModel, Field, field_serializer, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_serializer, field_validator
+
+# Import enums from enums.py
+from .enums import Freq, OrderStrategy, Weekday, TradeDirection, TrendType
+
+# Import Indicator models
+from .indicator_models import (
+    SMAIndicator,
+    EMAIndicator,
+    SMMAIndicator,
+    WMAIndicator,
+    ATRIndicator,
+    ATRQuantileIndicator,
+    SuperTrendIndicator,
+    MACDIndicator,
+    ADXIndicator,
+    RSIIndicator,
+    CCIIndicator,
+    StochasticIndicator,
+    BollingerBandsIndicator,
+    MarketProfileIndicator,
+    RawOhlcvIndicator,
+)
 
 
-class Freq(str, Enum):
-    """時間頻率枚舉（與 Rust Freq enum 一致）
-
-    對應 Rust 的 Freq enum
-    """
-
-    MIN_1 = "1min"
-    MIN_5 = "5min"
-    MIN_15 = "15min"
-    MIN_30 = "30min"
-    HOUR_1 = "1h"
-    HOUR_4 = "4h"
-    DAY_1 = "1D"
-    WEEK_1 = "1W"
-    MONTH_1 = "1M"
-
-
-class OrderStrategy(str, Enum):
-    """訂單策略枚舉（與 Rust OrderStrategy enum 一致）
-
-    對應 Rust 的 OrderStrategy enum，使用字符串值以便 JSON 序列化
-
-    Rust 對應關係:
-    - Rust: OrderStrategy::ImmediateEntry      → Python: OrderStrategy.IMMEDIATE_ENTRY      (u32: 0)
-    - Rust: OrderStrategy::FavorableDelayEntry → Python: OrderStrategy.FAVORABLE_DELAY_ENTRY (u32: 1)
-    - Rust: OrderStrategy::AdverseDelayEntry   → Python: OrderStrategy.ADVERSE_DELAY_ENTRY   (u32: 2)
-    - Rust: OrderStrategy::ImmediateExit       → Python: OrderStrategy.IMMEDIATE_EXIT        (u32: 3)
-    - Rust: OrderStrategy::StopLoss            → Python: OrderStrategy.STOP_LOSS             (u32: 4)
-    - Rust: OrderStrategy::TakeProfit          → Python: OrderStrategy.TAKE_PROFIT           (u32: 5)
-    - Rust: OrderStrategy::TrailingStop        → Python: OrderStrategy.TRAILING_STOP         (u32: 6)
-    - Rust: OrderStrategy::Breakeven           → Python: OrderStrategy.BREAKEVEN             (u32: 7)
-    - Rust: OrderStrategy::TimeoutExit         → Python: OrderStrategy.TIMEOUT_EXIT          (u32: 8)
-    """
-
-    IMMEDIATE_ENTRY = "ImmediateEntry"
-    FAVORABLE_DELAY_ENTRY = "FavorableDelayEntry"
-    ADVERSE_DELAY_ENTRY = "AdverseDelayEntry"
-    IMMEDIATE_EXIT = "ImmediateExit"
-    STOP_LOSS = "StopLoss"
-    TAKE_PROFIT = "TakeProfit"
-    TRAILING_STOP = "TrailingStop"
-    BREAKEVEN = "Breakeven"
-    TIMEOUT_EXIT = "TimeoutExit"
-
-
-class Weekday(str, Enum):
-    """星期列舉（與 Rust Weekday enum 一致）
-
-    用於 Market Profile 的 WeeklyTime 配置
-
-    對應關係：
-    - 0 (週一) → "Mon"
-    - 1 (週二) → "Tue"
-    - 2 (週三) → "Wed"
-    - 3 (週四) → "Thu"
-    - 4 (週五) → "Fri"
-    - 5 (週六) → "Sat"
-    - 6 (週日) → "Sun"
-    """
+# ============================================================================
+# Indicator Discriminated Union (强类型 Indicator 配置)
+# ============================================================================
 
-    MON = "Mon"
-    TUE = "Tue"
-    WED = "Wed"
-    THU = "Thu"
-    FRI = "Fri"
-    SAT = "Sat"
-    SUN = "Sun"
+IndicatorConfig = Annotated[
+    Union[
+        # 移动平均类
+        SMAIndicator,
+        EMAIndicator,
+        SMMAIndicator,
+        WMAIndicator,
+        # 波动率类
+        ATRIndicator,
+        ATRQuantileIndicator,
+        # 趋势类
+        SuperTrendIndicator,
+        MACDIndicator,
+        ADXIndicator,
+        # 动量类
+        RSIIndicator,
+        CCIIndicator,
+        StochasticIndicator,
+        # 其他
+        BollingerBandsIndicator,
+        MarketProfileIndicator,
+        RawOhlcvIndicator,
+    ],
+    Field(discriminator='type')
+]
+"""
+强类型 Indicator 配置
+
+使用 Pydantic discriminated union，根据 'type' 字段自动选择正确的模型：
+- type="SMA" → SMAIndicator
+- type="ATR" → ATRIndicator
+- type="SuperTrend" → SuperTrendIndicator
+- ... etc
+
+优点：
+- 编译时类型检查
+- IDE 自动补全
+- 参数验证
+- 自动 JSON 序列化/反序列化
+
+Example:
+    >>> # 方式 1: 直接创建强类型模型
+    >>> atr = ATRIndicator(period=21)
+    >>>
+    >>> # 方式 2: 从 Dict 自动转换（API 兼容）
+    >>> indicator: IndicatorConfig = {"type": "ATR", "period": 21}
+    >>> # Pydantic 自动识别为 ATRIndicator
+"""
 
 
 class PolarsExprField:
@@ -231,8 +238,8 @@ class Indicator:
     """
 
     @staticmethod
-    def sma(period: int, column: str = "close") -> Dict[str, Any]:
-        """創建 SMA 指標配置
+    def sma(period: int, column: str = "close") -> SMAIndicator:
+        """創建 SMA 指標配置（强类型）
 
         對應 Rust: Indicator::SMA { period, column }
 
@@ -241,72 +248,42 @@ class Indicator:
             column: 計算欄位（預設 "close"）
 
         Returns:
-            SMA 指標配置 dict
+            SMAIndicator 強類型模型
 
         Example:
-            >>> Indicator.sma(period=20)
-            >>> Indicator.sma(period=20, column="high")
+            >>> atr = Indicator.sma(period=20)
+            >>> assert isinstance(atr, SMAIndicator)
+            >>> atr_high = Indicator.sma(period=20, column="high")
         """
-        return {"type": "SMA", "period": period, "column": column}
+        return SMAIndicator(period=period, column=column)
 
     @staticmethod
-    def ema(period: int, column: str = "close") -> Dict[str, Any]:
-        """創建 EMA 指標配置
+    def ema(period: int, column: str = "close") -> EMAIndicator:
+        """創建 EMA 指標配置（强类型）
 
         對應 Rust: Indicator::EMA { period, column }
-
-        Args:
-            period: 週期
-            column: 計算欄位（預設 "close"）
-
-        Returns:
-            EMA 指標配置 dict
-
-        Example:
-            >>> Indicator.ema(period=12)
-            >>> Indicator.ema(period=12, column="low")
         """
-        return {"type": "EMA", "period": period, "column": column}
+        return EMAIndicator(period=period, column=column)
 
     @staticmethod
-    def smma(period: int, column: str = "close") -> Dict[str, Any]:
-        """創建 SMMA 指標配置
+    def smma(period: int, column: str = "close") -> SMMAIndicator:
+        """創建 SMMA 指標配置（强类型）
 
         對應 Rust: Indicator::SMMA { period, column }
-
-        Args:
-            period: 週期
-            column: 計算欄位（預設 "close"）
-
-        Returns:
-            SMMA 指標配置 dict
-
-        Example:
-            >>> Indicator.smma(period=14)
         """
-        return {"type": "SMMA", "period": period, "column": column}
+        return SMMAIndicator(period=period, column=column)
 
     @staticmethod
-    def wma(period: int, column: str = "close") -> Dict[str, Any]:
-        """創建 WMA 指標配置
+    def wma(period: int, column: str = "close") -> WMAIndicator:
+        """創建 WMA 指標配置（强类型）
 
         對應 Rust: Indicator::WMA { period, column }
-
-        Args:
-            period: 週期
-            column: 計算欄位（預設 "close"）
-
-        Returns:
-            WMA 指標配置 dict
-
-        Example:
-            >>> Indicator.wma(period=10)
         """
-        return {"type": "WMA", "period": period, "column": column}
+        return WMAIndicator(period=period, column=column)
 
     @staticmethod
-    def atr(period: int) -> Dict[str, Any]:
-        """創建 ATR 指標配置
+    def atr(period: int) -> ATRIndicator:
+        """創建 ATR 指標配置（强类型）
 
         對應 Rust: Indicator::ATR { period }
 
@@ -336,15 +313,15 @@ class Indicator:
             ...     (pl.col("close") - 2 * pl.col("ATR|14")).alias("stop_loss")
             ... ])
         """
-        return {"type": "ATR", "period": period}
+        return ATRIndicator(period=period)
 
     @staticmethod
     def atr_quantile(
         atr_column: str,
         window: int,
         quantile: float,
-    ) -> Dict[str, Any]:
-        """創建 AtrQuantile 指標配置
+    ) -> ATRQuantileIndicator:
+        """創建 AtrQuantile 指標配置（强类型）
 
         對應 Rust: Indicator::AtrQuantile { atr_column, window, quantile }
 
@@ -416,12 +393,11 @@ class Indicator:
             ...     order_strategy="ImmediateEntry"
             ... )
         """
-        return {
-            "type": "AtrQuantile",
-            "atr_column": atr_column,
-            "window": window,
-            "quantile": quantile,
-        }
+        return ATRQuantileIndicator(
+            atr_column=atr_column,
+            window=window,
+            quantile=quantile,
+        )
 
     @staticmethod
     def supertrend(
@@ -431,8 +407,8 @@ class Indicator:
         low: str = "low",
         close: str = "close",
         fields: Optional[List[str]] = None,
-    ) -> Dict[str, Any]:
-        """創建 SuperTrend 指標配置
+    ) -> SuperTrendIndicator:
+        """創建 SuperTrend 指標配置（强类型）
 
         對應 Rust: Indicator::SuperTrend { multiplier, volatility_column, high, low, close, fields }
 
@@ -474,17 +450,14 @@ class Indicator:
             ...     fields=["direction", "supertrend"]
             ... )
         """
-        config = {
-            "type": "SuperTrend",
-            "multiplier": float(multiplier),
-            "volatility_column": volatility_column,
-            "high": high,
-            "low": low,
-            "close": close,
-        }
-        if fields is not None:
-            config["fields"] = fields
-        return config
+        return SuperTrendIndicator(
+            multiplier=float(multiplier),
+            volatility_column=volatility_column,
+            high=high,
+            low=low,
+            close=close,
+            fields=fields,
+        )
 
     @staticmethod
     def market_profile(
@@ -493,8 +466,8 @@ class Indicator:
         value_area_pct: float = 0.7,
         fields: Optional[List[str]] = None,
         shape_config: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """創建 Market Profile 指標配置
+    ) -> MarketProfileIndicator:
+        """創建 Market Profile 指標配置（强类型）
 
         對應 Rust: Indicator::MarketProfile { anchor_config, tick_size, ... }
 
@@ -552,21 +525,17 @@ class Indicator:
             ...     shape_config=shape_cfg.model_dump()
             ... )
         """
-        config = {
-            "type": "MarketProfile",
-            "anchor_config": anchor_config,
-            "tick_size": tick_size,
-            "value_area_pct": value_area_pct,
-        }
-        if fields is not None:
-            config["fields"] = fields
-        if shape_config is not None:
-            config["shape_config"] = shape_config
-        return config
+        return MarketProfileIndicator(
+            anchor_config=anchor_config,
+            tick_size=tick_size,
+            value_area_pct=value_area_pct,
+            fields=fields,
+            shape_config=shape_config,
+        )
 
     @staticmethod
-    def cci(period: int = 20) -> Dict[str, Any]:
-        """創建 CCI 指標配置
+    def cci(period: int = 20) -> CCIIndicator:
+        """創建 CCI 指標配置（强类型）
 
         對應 Rust: Indicator::CCI { period }
 
@@ -601,11 +570,11 @@ class Indicator:
             >>> overbought = pl.col("1h_CCI|14") > 100
             >>> oversold = pl.col("1h_CCI|14") < -100
         """
-        return {"type": "CCI", "period": period}
+        return CCIIndicator(period=period)
 
     @staticmethod
-    def rsi(period: int = 14, column: str = "close") -> Dict[str, Any]:
-        """創建 RSI 指標配置
+    def rsi(period: int = 14, column: str = "close") -> RSIIndicator:
+        """創建 RSI 指標配置（强类型）
 
         對應 Rust: Indicator::RSI { period, column }
 
@@ -645,7 +614,7 @@ class Indicator:
             >>> entry_long = pl.col("15min_RSI|14") < 30  # RSI < 30 做多
             >>> entry_short = pl.col("15min_RSI|14") > 70  # RSI > 70 做空
         """
-        return {"type": "RSI", "period": period, "column": column}
+        return RSIIndicator(period=period, column=column)
 
     @staticmethod
     def bollinger_bands(
@@ -653,8 +622,8 @@ class Indicator:
         num_std: float = 2.0,
         column: str = "close",
         fields: Optional[List[str]] = None,
-    ) -> Dict[str, Any]:
-        """創建 Bollinger Bands 指標配置
+    ) -> BollingerBandsIndicator:
+        """創建 Bollinger Bands 指標配置（强类型）
 
         對應 Rust: Indicator::BollingerBands { period, num_std, column, fields }
 
@@ -711,15 +680,12 @@ class Indicator:
             >>> breakout_up = pl.col("close") > upper
             >>> breakout_down = pl.col("close") < lower
         """
-        config = {
-            "type": "BollingerBands",
-            "period": period,
-            "num_std": float(num_std),
-            "column": column,
-        }
-        if fields is not None:
-            config["fields"] = fields
-        return config
+        return BollingerBandsIndicator(
+            period=period,
+            num_std=float(num_std),
+            column=column,
+            fields=fields,
+        )
 
     @staticmethod
     def macd(
@@ -728,8 +694,8 @@ class Indicator:
         signal_period: int = 9,
         column: str = "close",
         fields: Optional[List[str]] = None,
-    ) -> Dict[str, Any]:
-        """創建 MACD 指標配置
+    ) -> MACDIndicator:
+        """創建 MACD 指標配置（强类型）
 
         對應 Rust: Indicator::MACD { fast_period, slow_period, signal_period, column, fields }
 
@@ -786,24 +752,21 @@ class Indicator:
             >>> golden_cross = macd_line > signal_line  # 金叉（做多）
             >>> death_cross = macd_line < signal_line   # 死叉（做空）
         """
-        config = {
-            "type": "MACD",
-            "fast_period": fast_period,
-            "slow_period": slow_period,
-            "signal_period": signal_period,
-            "column": column,
-        }
-        if fields is not None:
-            config["fields"] = fields
-        return config
+        return MACDIndicator(
+            fast_period=fast_period,
+            slow_period=slow_period,
+            signal_period=signal_period,
+            column=column,
+            fields=fields,
+        )
 
     @staticmethod
     def stochastic(
         k_period: int = 14,
         d_period: int = 3,
         fields: Optional[List[str]] = None,
-    ) -> Dict[str, Any]:
-        """創建 Stochastic 指標配置
+    ) -> StochasticIndicator:
+        """創建 Stochastic 指標配置（强类型）
 
         對應 Rust: Indicator::Stochastic { k_period, d_period, fields }
 
@@ -856,18 +819,15 @@ class Indicator:
             >>> golden_cross = k_line > d_line  # 金叉（做多）
             >>> death_cross = k_line < d_line   # 死叉（做空）
         """
-        config = {
-            "type": "Stochastic",
-            "k_period": k_period,
-            "d_period": d_period,
-        }
-        if fields is not None:
-            config["fields"] = fields
-        return config
+        return StochasticIndicator(
+            k_period=k_period,
+            d_period=d_period,
+            fields=fields,
+        )
 
     @staticmethod
-    def adx(period: int = 14, fields: Optional[List[str]] = None) -> Dict[str, Any]:
-        """創建 ADX 指標配置
+    def adx(period: int = 14, fields: Optional[List[str]] = None) -> ADXIndicator:
+        """創建 ADX 指標配置（强类型）
 
         對應 Rust: Indicator::ADX { period, fields }
 
@@ -930,17 +890,14 @@ class Indicator:
             >>> uptrend = (plus_di > minus_di) & (adx_value > 25)  # 上升趨勢 + 強度足夠
             >>> downtrend = (plus_di < minus_di) & (adx_value > 25)  # 下降趨勢 + 強度足夠
         """
-        config = {
-            "type": "ADX",
-            "period": period,
-        }
-        if fields is not None:
-            config["fields"] = fields
-        return config
+        return ADXIndicator(
+            period=period,
+            fields=fields,
+        )
 
     @staticmethod
-    def raw_ohlcv(column: str) -> Dict[str, Any]:
-        """創建 RawOhlcv 指標配置
+    def raw_ohlcv(column: str) -> RawOhlcvIndicator:
+        """創建 RawOhlcv 指標配置（强类型）
 
         對應 Rust: Indicator::RawOhlcv { column }
 
@@ -979,7 +936,7 @@ class Indicator:
             >>> # 輸出列名: "TXF_M1_SHIOAJI_FUTURE_open_1D"
             >>> # 策略條件: if price > daily_open.col(): ...
         """
-        return {"type": "RawOhlcv", "column": column}
+        return RawOhlcvIndicator(column=column)
 
 
 # ============================================================================
@@ -1141,17 +1098,47 @@ def create_profile_shape_config(
 
 
 class IndicatorSpec(BaseModel):
-    """指標規範"""
+    """指標規範（强类型版本）"""
 
     instrument_id: Optional[str] = Field(
         None, description="交易標的 ID（可選，用於多商品場景）"
     )
-    freq: Union[Freq, str] = Field(..., description="頻率 (使用 Freq enum 或自訂字串)")
+    freq: Freq = Field(..., description="頻率 (Freq enum)")
     shift: int = Field(1, description="位移（預設 1）")
-    indicator: Dict[str, Any] = Field(
-        ..., description="指標配置 (使用 indicator 工廠函數建立)"
+    indicator: IndicatorConfig = Field(
+        ..., description="指標配置（强类型 Pydantic 模型）"
     )
 
+    @field_validator("freq", mode="before")
+    @classmethod
+    def convert_freq(cls, v: Any) -> Freq:
+        """自動轉換字串為 Freq enum（保持 API 兼容性）"""
+        if isinstance(v, str):
+            try:
+                return Freq(v)
+            except ValueError:
+                valid_values = [e.value for e in Freq]
+                raise ValueError(
+                    f"Invalid freq: '{v}'. "
+                    f"Valid values: {', '.join(valid_values)}"
+                )
+        return v
+
+    @field_validator("indicator", mode="before")
+    @classmethod
+    def convert_indicator(cls, v: Any) -> IndicatorConfig:
+        """自動轉換 Dict 為強類型 Indicator 模型（保持 API 兼容性）
+
+        接受：
+        - Dict[str, Any]: 從 API 返回或舊代碼（自動轉換）
+        - IndicatorConfig: 新代碼使用強類型模型
+
+        Pydantic 會根據 'type' 字段自動選擇正確的模型。
+        """
+        # Dict 會被 Pydantic 自動轉換為對應的 Indicator 模型
+        # 強類型模型直接返回
+        return v
+
     def short_name(self) -> str:
         """生成指標簡短名稱（與 Rust 的 short_name 一致）
 
@@ -1167,53 +1154,39 @@ class IndicatorSpec(BaseModel):
         Raises:
             ValueError: 未知的指標類型
         """
-        indicator_type = self.indicator.get("type")
+        indicator_type = self.indicator.type
 
         if indicator_type == "SMA":
-            period = self.indicator.get("period")
-            column = self.indicator.get("column", "close")
-            return f"SMA|{period}.{column}"
+            return f"SMA|{self.indicator.period}.{self.indicator.column}"
 
         elif indicator_type == "EMA":
-            period = self.indicator.get("period")
-            column = self.indicator.get("column", "close")
-            return f"EMA|{period}.{column}"
+            return f"EMA|{self.indicator.period}.{self.indicator.column}"
 
         elif indicator_type == "SMMA":
-            period = self.indicator.get("period")
-            column = self.indicator.get("column", "close")
-            return f"SMMA|{period}.{column}"
+            return f"SMMA|{self.indicator.period}.{self.indicator.column}"
 
         elif indicator_type == "WMA":
-            period = self.indicator.get("period")
-            column = self.indicator.get("column", "close")
-            return f"WMA|{period}.{column}"
+            return f"WMA|{self.indicator.period}.{self.indicator.column}"
 
         elif indicator_type == "ATR":
-            period = self.indicator.get("period")
             # ATR 始終返回單一數值欄位，無 quantile
-            return f"ATR|{period}"
+            return f"ATR|{self.indicator.period}"
 
         elif indicator_type == "AtrQuantile":
-            atr_column = self.indicator.get("atr_column")
-            window = self.indicator.get("window")
-            quantile = self.indicator.get("quantile")
             # 將 quantile 轉為百分比（例如 0.5 -> 50）
-            quantile_pct = int(quantile * 100)
+            quantile_pct = int(self.indicator.quantile * 100)
             # 格式：ATRQ|{atr_column}_Q{quantile%}_{window}
-            return f"ATRQ|{atr_column}_Q{quantile_pct}_{window}"
+            return f"ATRQ|{self.indicator.atr_column}_Q{quantile_pct}_{self.indicator.window}"
 
         elif indicator_type == "SuperTrend":
-            multiplier = self.indicator.get("multiplier")
-            volatility_column = self.indicator.get("volatility_column")
-            return f"ST|{multiplier}x_{volatility_column}"
+            return f"ST|{self.indicator.multiplier}x_{self.indicator.volatility_column}"
 
         elif indicator_type == "MarketProfile":
             # 提取 anchor_config 資訊
-            anchor_config = self.indicator.get("anchor_config", {})
+            anchor_config = self.indicator.anchor_config
             end_rule = anchor_config.get("end_rule", {})
             lookback_days = anchor_config.get("lookback_days", 1)
-            tick_size = self.indicator.get("tick_size")
+            tick_size = self.indicator.tick_size
 
             # 格式化時間字串（支持新舊兩種格式）
             rule_type = end_rule.get("type")
@@ -1278,37 +1251,26 @@ class IndicatorSpec(BaseModel):
             return f"MP|{time_str}_{lookback_days}_{tick_size}"
 
         elif indicator_type == "CCI":
-            period = self.indicator.get("period")
-            return f"CCI|{period}"
+            return f"CCI|{self.indicator.period}"
 
         elif indicator_type == "RSI":
-            period = self.indicator.get("period")
-            return f"RSI|{period}"
+            return f"RSI|{self.indicator.period}"
 
         elif indicator_type == "BollingerBands":
-            period = self.indicator.get("period")
-            num_std = self.indicator.get("num_std")
-            return f"BB|{period}_{num_std}"
+            return f"BB|{self.indicator.period}_{self.indicator.num_std}"
 
         elif indicator_type == "MACD":
-            fast_period = self.indicator.get("fast_period")
-            slow_period = self.indicator.get("slow_period")
-            signal_period = self.indicator.get("signal_period")
-            return f"MACD|{fast_period}_{slow_period}_{signal_period}"
+            return f"MACD|{self.indicator.fast_period}_{self.indicator.slow_period}_{self.indicator.signal_period}"
 
         elif indicator_type == "Stochastic":
-            k_period = self.indicator.get("k_period")
-            d_period = self.indicator.get("d_period")
-            return f"STOCH|{k_period}_{d_period}"
+            return f"STOCH|{self.indicator.k_period}_{self.indicator.d_period}"
 
         elif indicator_type == "ADX":
-            period = self.indicator.get("period")
-            return f"ADX|{period}"
+            return f"ADX|{self.indicator.period}"
 
         elif indicator_type == "RawOhlcv":
             # RawOhlcv 只返回 column 名稱
-            column = self.indicator.get("column")
-            return column
+            return self.indicator.column
 
         else:
             raise ValueError(f"未知的指標類型: {indicator_type}")
@@ -1378,8 +1340,8 @@ class Trigger(BaseModel):
     """
 
     name: str = Field(..., description="觸發器名稱")
-    order_strategy: Union[OrderStrategy, str] = Field(
-        ..., description="訂單策略（OrderStrategy enum 或字串）"
+    order_strategy: OrderStrategy = Field(
+        ..., description="訂單策略（OrderStrategy enum）"
     )
     priority: int = Field(..., description="優先級")
     note: Optional[str] = Field(None, description="備註")
@@ -1388,6 +1350,21 @@ class Trigger(BaseModel):
     conditions: List[pl.Expr] = Field(..., description="條件列表（Polars Expr）")
     price_expr: pl.Expr = Field(..., description="價格表達式（Polars Expr）")
 
+    @field_validator("order_strategy", mode="before")
+    @classmethod
+    def convert_order_strategy(cls, v: Any) -> OrderStrategy:
+        """自動轉換字串為 OrderStrategy enum（保持 API 兼容性）"""
+        if isinstance(v, str):
+            try:
+                return OrderStrategy(v)
+            except ValueError:
+                valid_values = [e.value for e in OrderStrategy]
+                raise ValueError(
+                    f"Invalid order_strategy: '{v}'. "
+                    f"Valid values: {', '.join(valid_values)}"
+                )
+        return v
+
     @field_validator("conditions", mode="before")
     @classmethod
     def validate_conditions(cls, v: Any) -> List[pl.Expr]:
@@ -1416,25 +1393,53 @@ class Trigger(BaseModel):
         """序列化 price_expr 為 dict（與服務器格式一致）"""
         return PolarsExprField.serialize(price_expr)
 
-    class Config:
-        # 允許 pl.Expr 這種自定義類型
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True  # 允許 pl.Expr 這種自定義類型
+    )
 
 
 class Blueprint(BaseModel):
     """策略藍圖"""
 
     name: str = Field(..., description="藍圖名稱")
-    direction: Literal["Long", "Short", "Both"] = Field(..., description="方向")
-    trend_type: Literal["Trend", "Range", "Reversal"] = Field(
-        ..., description="趨勢類型"
-    )
+    direction: TradeDirection = Field(..., description="方向")
+    trend_type: TrendType = Field(..., description="趨勢類型")
     entry_first: bool = Field(..., description="是否優先進場")
     note: str = Field(..., description="備註")
 
     entry_triggers: List[Trigger] = Field(..., description="進場觸發器列表")
     exit_triggers: List[Trigger] = Field(..., description="出場觸發器列表")
 
+    @field_validator("direction", mode="before")
+    @classmethod
+    def convert_direction(cls, v: Any) -> TradeDirection:
+        """自動轉換字串為 TradeDirection enum（保持 API 兼容性）"""
+        if isinstance(v, str):
+            try:
+                return TradeDirection(v)
+            except ValueError:
+                valid_values = [e.value for e in TradeDirection]
+                raise ValueError(
+                    f"Invalid direction: '{v}'. "
+                    f"Valid values: {', '.join(valid_values)}"
+                )
+        return v
+
+    @field_validator("trend_type", mode="before")
+    @classmethod
+    def convert_trend_type(cls, v: Any) -> TrendType:
+        """自動轉換字串為 TrendType enum（保持 API 兼容性）"""
+        if isinstance(v, str):
+            try:
+                return TrendType(v)
+            except ValueError:
+                valid_values = [e.value for e in TrendType]
+                raise ValueError(
+                    f"Invalid trend_type: '{v}'. "
+                    f"Valid values: {', '.join(valid_values)}"
+                )
+        return v
+
 
 class StrategyConfig(BaseModel):
     """完整策略配置"""
@@ -1602,7 +1607,7 @@ def create_trigger(
     name: str,
     conditions: List[pl.Expr],
     price_expr: pl.Expr,
-    order_strategy: Union[OrderStrategy, str] = OrderStrategy.IMMEDIATE_ENTRY,
+    order_strategy: OrderStrategy = OrderStrategy.IMMEDIATE_ENTRY,
     priority: int = 1,
     note: Optional[str] = None,
 ) -> Trigger:
@@ -1654,10 +1659,10 @@ def create_trigger(
 
 def create_blueprint(
     name: str,
-    direction: Literal["Long", "Short", "Both"],
+    direction: TradeDirection,
     entry_triggers: List[Trigger],
     exit_triggers: List[Trigger],
-    trend_type: Literal["Trend", "Range", "Reversal"] = "Trend",
+    trend_type: TrendType = TrendType.TREND,
     entry_first: bool = True,
     note: str = "",
 ) -> Blueprint: