UUID - 生成唯一标识符

unique_id = UUID()

# 生成 UUID
id1 = UUID()
Log(f"UUID: {id1}")
# 输出示例: a1b2c3d4e5f6789012345678901234ab

# 每次调用都会生成不同的 UUID
id2 = UUID()
Log(f"UUID: {id2}")
# 输出示例: 9f8e7d6c5b4a321098765432101fedcb

Log(f"两个 UUID 相同: {id1 == id2}")  # False

def place_order_with_tracking(price, amount):
    """下单并生成跟踪ID"""
    # 生成唯一跟踪ID
    tracking_id = UUID()
    
    # 下单
    order_id = exchange.Buy(price, amount)
    
    if order_id:
        # 保存跟踪ID与订单ID的映射
        _G(f"tracking_{tracking_id}", {
            "order_id": order_id,
            "price": price,
            "amount": amount,
            "timestamp": Unix(),
            "time_str": _D()
        })
        
        Log(f"✅ 订单已下: {order_id}")
        Log(f"📋 跟踪ID: {tracking_id}")
        return tracking_id
    else:
        Log("❌ 下单失败")
        return None

# 使用示例
tracking_id = place_order_with_tracking(50000, 0.1)
if tracking_id:
    # 稍后可以通过跟踪ID查询订单信息
    order_info = _G(f"tracking_{tracking_id}")
    Log(f"订单信息: {order_info}")

class RequestDeduplicator:
    """请求去重器"""
    def __init__(self):
        self.processed = set()
    
    def is_duplicate(self, request_data):
        """检查是否重复请求"""
        import json
        
        # 使用数据的 MD5 作为标识
        request_hash = MD5(json.dumps(request_data, sort_keys=True))
        
        if request_hash in self.processed:
            return True
        
        self.processed.add(request_hash)
        return False
    
    def generate_request_id(self):
        """生成请求ID"""
        return UUID()

# 使用示例
deduplicator = RequestDeduplicator()

def process_request(data):
    if deduplicator.is_duplicate(data):
        Log("重复请求，忽略")
        return None
    
    request_id = deduplicator.generate_request_id()
    Log(f"处理请求: {request_id}")
    # 处理逻辑...
    return request_id

class TradingSession:
    """交易会话"""
    def __init__(self):
        self.session_id = UUID()
        self.start_time = Unix()
        self.trades = []
        
        Log(f"🚀 新交易会话: {self.session_id}")
        Log(f"开始时间: {_D(self.start_time)}")
    
    def add_trade(self, trade_type, price, amount):
        """添加交易记录"""
        trade = {
            "id": UUID(),
            "type": trade_type,
            "price": price,
            "amount": amount,
            "timestamp": Unix()
        }
        self.trades.append(trade)
        Log(f"记录交易: {trade['id']}")
        return trade['id']
    
    def end_session(self):
        """结束会话"""
        end_time = Unix()
        duration = end_time - self.start_time
        
        Log(f"🏁 会话结束: {self.session_id}")
        Log(f"持续时间: {duration} 秒")
        Log(f"交易次数: {len(self.trades)}")
        
        # 保存会话数据
        _G(f"session_{self.session_id}", {
            "session_id": self.session_id,
            "start_time": self.start_time,
            "end_time": end_time,
            "duration": duration,
            "trades": self.trades
        })

# 使用示例
session = TradingSession()
session.add_trade("buy", 50000, 0.1)
session.add_trade("sell", 51000, 0.1)
session.end_session()

def save_temp_data(data, prefix="temp"):
    """保存临时数据"""
    import json
    
    # 生成唯一文件名
    filename = f"{prefix}_{UUID()}.json"
    
    # 保存数据
    with open(filename, 'w') as f:
        json.dump(data, f)
    
    Log(f"临时数据已保存: {filename}")
    return filename

# 使用示例
market_data = {
    "ticker": exchange.GetTicker(),
    "depth": exchange.GetDepth(),
    "timestamp": Unix()
}

filename = save_temp_data(market_data, "market")
# 输出: market_a1b2c3d4e5f678901234567890123456.json

def batch_place_orders(orders_config):
    """批量下单"""
    # 生成批次ID
    batch_id = UUID()
    
    Log(f"📦 批次下单开始: {batch_id}")
    Log(f"订单数量: {len(orders_config)}")
    
    results = []
    for config in orders_config:
        order_id = exchange.Buy(config['price'], config['amount'])
        results.append({
            "order_id": order_id,
            "config": config
        })
        Sleep(100)  # 避免限流
    
    # 保存批次信息
    _G(f"batch_{batch_id}", {
        "batch_id": batch_id,
        "timestamp": Unix(),
        "orders_count": len(orders_config),
        "results": results
    })
    
    Log(f"✅ 批次下单完成: {batch_id}")
    return batch_id

# 使用示例
orders = [
    {"price": 50000, "amount": 0.1},
    {"price": 49000, "amount": 0.1},
    {"price": 48000, "amount": 0.1}
]

batch_id = batch_place_orders(orders)

# 稍后查询批次结果
batch_info = _G(f"batch_{batch_id}")
Log(f"批次信息: {batch_info}")

class TradeChain:
    """交易链（追踪相关联的多笔交易）"""
    def __init__(self, initial_trade_id=None):
        self.chain_id = UUID()
        self.trades = []
        
        if initial_trade_id:
            self.add_trade(initial_trade_id)
        
        Log(f"🔗 创建交易链: {self.chain_id}")
    
    def add_trade(self, trade_id, relation="related"):
        """添加关联交易"""
        self.trades.append({
            "id": trade_id,
            "relation": relation,
            "timestamp": Unix()
        })
        Log(f"添加交易到链 {self.chain_id}: {trade_id} ({relation})")
    
    def get_chain_info(self):
        """获取链信息"""
        return {
            "chain_id": self.chain_id,
            "trades_count": len(self.trades),
            "trades": self.trades
        }

# 使用示例
# 开仓交易
open_order_id = exchange.Buy(50000, 0.1)
chain = TradeChain(open_order_id)

# 加仓交易
add_order_id = exchange.Buy(49000, 0.1)
chain.add_trade(add_order_id, "add_position")

# 平仓交易
close_order_id = exchange.Sell(51000, 0.2)
chain.add_trade(close_order_id, "close_position")

# 查看完整链
Log(chain.get_chain_info())