Algorithmic Trading Rules Analysis

from enum import Enum
from dataclasses import dataclass
 
class AlgoType(Enum):
    BENCHMARK_TIME = 'benchmark time'
    BENCHMARK_VOLUME = 'benchmark volume'
    BENCHMARK_CLOSE = 'benchmark close'
    BENCHMARK_CLOSE_ONLY = 'benchmark close - close only'
    LIQUIDITY_SEEK_PASSIVE = 'liquidity seek - passive'
    LIQUIDITY_SEEK_AGGRESSIVE = 'liquidity seek - aggressive'
 
class TradingPhase(Enum):
    CONTINUOUS = 'Continuous'
    CLOSE = 'Close'
 
class ClientID(Enum):
    ABC = 'abc'
    DEF = 'def'
    # ... more clients
    XYZ = 'xyz'
 
def is_trading_phase_eligible_for_algo_type(
    algo_type: AlgoType,
    trading_phase: TradingPhase
) -> bool:
    """Check if a trading phase is eligible for an algo type."""
    eligibility_table = {
        AlgoType.BENCHMARK_TIME: {
            TradingPhase.CONTINUOUS: True,
            TradingPhase.CLOSE: True
        },
        AlgoType.BENCHMARK_CLOSE_ONLY: {
            TradingPhase.CONTINUOUS: False,  # Only CLOSE allowed!
            TradingPhase.CLOSE: True
        },
        # ... other algo types
    }
    return eligibility_table[algo_type][trading_phase]

def is_trading_phase_eligible_for_client_and_algo(
    client_id: ClientID,
    algo_type: AlgoType,
    trading_phase: TradingPhase
) -> bool:
    """Check eligibility for specific client and algo combination."""
 
    # ⚠️ Special rule for client XYZ
    if client_id == ClientID.XYZ and algo_type == AlgoType.BENCHMARK_CLOSE_ONLY:
        # Client XYZ can only trade in CLOSE phase with Benchmark Close Only
        return trading_phase == TradingPhase.CLOSE
 
    # For all other cases, use the general rule
    return is_trading_phase_eligible_for_algo_type(algo_type, trading_phase)

def verify_xyz_rule_is_redundant(
    client_id: ClientID,
    algo_type: AlgoType,
    trading_phase: TradingPhase
) -> bool:
    """Verify the special case produces identical results to the general rule."""
    if client_id == ClientID.XYZ and algo_type == AlgoType.BENCHMARK_CLOSE_ONLY:
        special_case_result = (trading_phase == TradingPhase.CLOSE)
        general_rule_result = is_trading_phase_eligible_for_algo_type(
            algo_type,
            trading_phase
        )
        return special_case_result == general_rule_result
    return True

type algo_type =
  | Benchmark_time
  | Benchmark_volume
  | Benchmark_close
  | Benchmark_close_only
  | Liquidity_seek_passive
  | Liquidity_seek_aggressive
 
type trading_phase = Continuous | Close
type client_id = ABC | DEF | GHI | JLK | LMN | OPQ | RST | UVW | XYZ
 
let verify_xyz_rule_is_redundant
    (client_id : client_id)
    (algo_type : algo_type)
    (trading_phase : trading_phase) : bool =
  if client_id = XYZ && algo_type = Benchmark_close_only then
    let special_case_result = (trading_phase = Close) in
    let general_rule_result =
      is_trading_phase_eligible_for_algo_type algo_type trading_phase
    in
    special_case_result = general_rule_result
  else
    true