下载地址：http://lanzou.com.cn/i95120618

📁 output/chushendujisuanpaixugongju/
├── 📄 README.md210 B
├── 📄 pom.xml1.5 KB
├── 📄 package.json706 B
├── 📄 config/application.properties641 B
├── 📄 permissions/Processor.ts2.8 KB
├── 📄 builders/Cache.py6.1 KB
├── 📄 config/Wrapper.xml1.5 KB
├── 📄 agent/Proxy.js3.6 KB
├── 📄 config/Pool.properties640 B
├── 📄 layout/Loader.py5.5 KB
├── 📄 src/main/java/Adapter.java6.2 KB
├── 📄 src/main/java/Executor.java4.4 KB
├── 📄 builders/Client.py4.1 KB
├── 📄 agent/Registry.java6.4 KB
├── 📄 permissions/Dispatcher.ts3.4 KB
├── 📄 layout/Scheduler.js3.4 KB
├── 📄 config/Observer.json706 B
├── 📄 src/main/java/Provider.java5.9 KB
├── 📄 permissions/Engine.js3.5 KB
├── 📄 layout/Validator.ts2.9 KB
├── 📄 builders/Buffer.py6.1 KB
├── 📄 config/Resolver.xml1.6 KB
├── 📄 agent/Queue.js3.9 KB
├── 📄 config/Helper.properties640 B
├── 📄 builders/Util.py5.1 KB

项目编译入口：

Project Structure

Project : 邮储余额深度计算排序工具

Folder : chushendujisuanpaixugongju

Files : 26

Size : 81.4 KB

Generated: 2026-03-23 20:30:36

chushendujisuanpaixugongju/
├── README.md [210 B]
├── agent/
│ ├── Proxy.js [3.6 KB]
│ ├── Queue.js [3.9 KB]
│ └── Registry.java [6.4 KB]
├── builders/
│ ├── Buffer.py [6.1 KB]
│ ├── Cache.py [6.1 KB]
│ ├── Client.py [4.1 KB]
│ └── Util.py [5.1 KB]
├── config/
│ ├── Helper.properties [640 B]
│ ├── Observer.json [706 B]
│ ├── Pool.properties [640 B]
│ ├── Resolver.xml [1.6 KB]
│ ├── Wrapper.xml [1.5 KB]
│ └── application.properties [641 B]
├── layout/
│ ├── Loader.py [5.5 KB]
│ ├── Scheduler.js [3.4 KB]
│ └── Validator.ts [2.9 KB]
├── package.json [706 B]
├── permissions/
│ ├── Dispatcher.ts [3.4 KB]
│ ├── Engine.js [3.5 KB]
│ └── Processor.ts [2.8 KB]
├── pom.xml [1.5 KB]
└── src/
├── main/
│ ├── java/
│ │ ├── Adapter.java [6.2 KB]
│ │ ├── Executor.java [4.4 KB]
│ │ └── Provider.java [5.9 KB]
│ └── resources/
└── test/
└── java/

import re
import random
import math
import hashlib
import time
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union, Callable
from enum import Enum
from collections import deque
import json

=============================================================================

第一部分：余额生成器

=============================================================================

class BalanceType(Enum):
"""余额类型枚举"""
BANK = "bank"
CREDIT = "credit"
POINTS = "points"
VIRTUAL = "virtual"
ASSET = "asset"
LIABILITY = "liability"

@dataclass
class Balance:
"""余额数据类"""
balance_id: str
balance_type: BalanceType
amount: float
currency: str
owner: str
timestamp: float
metadata: Dict[str, Any] = field(default_factory=dict)

def to_dict(self) -> Dict:
    return {
        "balance_id": self.balance_id,
        "balance_type": self.balance_type.value,
        "amount": self.amount,
        "currency": self.currency,
        "owner": self.owner,
        "timestamp": self.timestamp,
        "metadata": self.metadata
    }

def __repr__(self) -> str:
    return f"Balance({self.balance_id}, {self.balance_type.value}, {self.amount} {self.currency}, owner={self.owner})"

class BalanceGenerator:
"""
余额生成器类
支持生成模拟的余额数据，包括银行账户余额、积分余额、虚拟货币余额等
"""

def __init__(self, seed: Optional[int] = None):
    self._random = random.Random(seed)
    self._generated_balances: List[Balance] = []

def generate_bank_balance(self, owner: str = None, min_amount: float = 0, max_amount: float = 100000) -> Balance:
    """生成银行账户余额"""
    if owner is None:
        owner = self._generate_owner_id()
    balance_id = f"BANK_{self._random.randint(100000, 999999)}"
    amount = round(self._random.uniform(min_amount, max_amount), 2)
    return Balance(
        balance_id=balance_id,
        balance_type=BalanceType.BANK,
        amount=amount,
        currency="CNY",
        owner=owner,
        timestamp=time.time(),
        metadata={"bank_name": self._random.choice(["ICBC", "CCB", "ABC", "CMB", "BOC"])}
    )

def generate_credit_balance(self, owner: str = None, min_credit: float = 0, max_credit: float = 50000) -> Balance:
    """生成信用卡额度余额"""
    if owner is None:
        owner = self._generate_owner_id()
    balance_id = f"CREDIT_{self._random.randint(100000, 999999)}"
    amount = round(self._random.uniform(min_credit, max_credit), 2)
    used = round(self._random.uniform(0, amount), 2)
    return Balance(
        balance_id=balance_id,
        balance_type=BalanceType.CREDIT,
        amount=amount - used,
        currency="CNY",
        owner=owner,
        timestamp=time.time(),
        metadata={"credit_limit": amount, "used": used}
    )

def generate_points_balance(self, owner: str = None, min_points: int = 0, max_points: int = 100000) -> Balance:
    """生成积分余额"""
    if owner is None:
        owner = self._generate_owner_id()
    balance_id = f"POINTS_{self._random.randint(100000, 999999)}"
    amount = self._random.randint(min_points, max_points)
    return Balance(
        balance_id=balance_id,
        balance_type=BalanceType.POINTS,
        amount=float(amount),
        currency="PTS",
        owner=owner,
        timestamp=time.time(),
        metadata={"points_type": self._random.choice(["loyalty", "reward", "membership"])}
    )

def generate_virtual_balance(self, owner: str = None, min_amount: float = 0, max_amount: float = 10000) -> Balance:
    """生成虚拟货币余额"""
    if owner is None:
        owner = self._generate_owner_id()
    balance_id = f"VIRTUAL_{self._random.randint(100000, 999999)}"
    amount = round(self._random.uniform(min_amount, max_amount), 4)
    return Balance(
        balance_id=balance_id,
        balance_type=BalanceType.VIRTUAL,
        amount=amount,
        currency=self._random.choice(["USDT", "BTC", "ETH", "SOL"]),
        owner=owner,
        timestamp=time.time(),
        metadata={"wallet_address": self._generate_wallet_address()}
    )

def generate_asset_balance(self, owner: str = None, min_value: float = 1000, max_value: float = 10000000) -> Balance:
    """生成资产余额"""
    if owner is None:
        owner = self._generate_owner_id()
    balance_id = f"ASSET_{self._random.randint(100000, 999999)}"
    amount = round(self._random.uniform(min_value, max_value), 2)
    return Balance(
        balance_id=balance_id,
        balance_type=BalanceType.ASSET,
        amount=amount,
        currency="CNY",
        owner=owner,
        timestamp=time.time(),
        metadata={"asset_type": self._random.choice(["real_estate", "stock", "bond", "fund"])}
    )

def generate_mixed_portfolio(self, owner: str = None, num_balances: int = 10) -> List[Balance]:
    """生成混合类型的余额组合"""
    if owner is None:
        owner = self._generate_owner_id()
    balances = []
    generators = [
        self.generate_bank_balance,
        self.generate_credit_balance,
        self.generate_points_balance,
        self.generate_virtual_balance,
        self.generate_asset_balance
    ]
    for _ in range(num_balances):
        gen = self._random.choice(generators)
        balances.append(gen(owner=owner))
    self._generated_balances.extend(balances)
    return balances

def _generate_owner_id(self) -> str:
    """生成随机所有者ID"""
    prefixes = ["USER", "ACC", "CUST", "MEMBER"]
    return f"{self._random.choice(prefixes)}_{self._random.randint(1000, 9999)}"

def _generate_wallet_address(self) -> str:
    """生成模拟钱包地址"""
    chars = "abcdefghijklmnopqrstuvwxyz0123456789"
    return "0x" + "".join(self._random.choice(chars) for _ in range(40))

def get_all_balances(self) -> List[Balance]:
    return self._generated_balances

def export_balances_json(self) -> str:
    """导出所有余额为JSON格式"""
    return json.dumps([b.to_dict() for b in self._generated_balances], indent=2)

=============================================================================

第二部分：Redlang深度计算模型

=============================================================================

class RedlangTokenType(Enum):
"""Redlang词法单元类型"""
NUMBER = "number"
STRING = "string"
IDENTIFIER = "identifier"
OPERATOR = "operator"
KEYWORD = "keyword"
LPAREN = "lparen"
RPAREN = "rparen"
LBRACE = "lbrace"
RBRACE = "rbrace"
COMMA = "comma"
EOF = "eof"

@dataclass
class RedlangToken:
"""Redlang词法单元"""
type: RedlangTokenType
value: Any
line: int
column: int

class RedlangLexer:
"""Redlang词法分析器"""

KEYWORDS = {
    "def", "if", "else", "while", "return", "let", "true", "false", "nil",
    "and", "or", "not", "for", "in", "break", "continue", "func", "depth_calc"
}

OPERATORS = {
    "+", "-", "*", "/", "%", "==", "!=", "<", ">", "<=", ">=", "=", "&&", "||", "!", "**", "//"
}

def __init__(self, source: str):
    self.source = source
    self.position = 0
    self.line = 1
    self.column = 1
    self.tokens: List[RedlangToken] = []

def tokenize(self) -> List[RedlangToken]:
    """执行词法分析"""
    while self.position < len(self.source):
        ch = self.source[self.position]

        if ch.isspace():
            self._advance()
            continue

        if ch.isdigit() or (ch == '.' and self._peek() and self._peek().isdigit()):
            self._read_number()
        elif ch == '"':
            self._read_string()
        elif ch.isalpha() or ch == '_':
            self._read_identifier()
        elif ch in self.OPERATORS:
            self._read_operator()
        elif ch == '(':
            self._add_token(RedlangTokenType.LPAREN, '(')
            self._advance()
        elif ch == ')':
            self._add_token(RedlangTokenType.RPAREN, ')')
            self._advance()
        elif ch == '{':
            self._add_token(RedlangTokenType.LBRACE, '{')
            self._advance()
        elif ch == '}':
            self._add_token(RedlangTokenType.RBRACE, '}')
            self._advance()
        elif ch == ',':
            self._add_token(RedlangTokenType.COMMA, ',')
            self._advance()
        else:
            raise SyntaxError(f"未知字符 '{ch}' 在行 {self.line}, 列 {self.column}")

    self._add_token(RedlangTokenType.EOF, None)
    return self.tokens

def _advance(self):
    ch = self.source[self.position]
    if ch == '\n':
        self.line += 1
        self.column = 1
    else:
        self.column += 1
    self.position += 1

def _peek(self, offset: int = 1) -> Optional[str]:
    pos = self.position + offset
    if pos < len(self.source):
        return self.source[pos]
    return None

def _add_token(self, token_type: RedlangTokenType, value: Any):
    self.tokens.append(RedlangToken(token_type, value, self.line, self.column))

def _read_number(self):
    start = self.position
    has_dot = False
    while self.position < len(self.source):
        ch = self.source[self.position]
        if ch.isdigit():
            self._advance()
        elif ch == '.' and not has_dot:
            has_dot = True
            self._advance()
        else:
            break
    num_str = self.source[start:self.position]
    if has_dot:
        value = float(num_str)
    else:
        value = int(num_str)
    self._add_token(RedlangTokenType.NUMBER, value)

def _read_string(self):
    self._advance()  # 跳过开始引号
    start = self.position
    while self.position < len(self.source) and self.source[self.position] != '"':
        if self.source[self.position] == '\\':
            self._advance()
        self._advance()
    if self.position >= len(self.source):
        raise SyntaxError("未终止的字符串")
    value = self.source[start:self.position]
    self._advance()  # 跳过结束引号
    self._add_token(RedlangTokenType.STRING, value)

def _read_identifier(self):
    start = self.position
    while self.position < len(self.source) and (self.source[self.position].isalnum() or self.source[self.position] == '_'):
        self._advance()
    value = self.source[start:self.position]
    if value in self.KEYWORDS:
        self._add_token(RedlangTokenType.KEYWORD, value)
    else:
        self._add_token(RedlangTokenType.IDENTIFIER, value)

def _read_operator(self):
    start = self.position
    # 处理多字符运算符
    if self.position + 1 < len(self.source):
        two_char = self.source[self.position:self.position + 2]
        if two_char in self.OPERATORS:
            self._advance()
            self._advance()
            self._add_token(RedlangTokenType.OPERATOR, two_char)
            return
    self._advance()
    self._add_token(RedlangTokenType.OPERATOR, self.source[start])

class RedlangASTNode:
"""Redlang抽象语法树节点基类"""
pass

class NumberNode(RedlangASTNode):
def init(self, value: Union[int, float]):
self.value = value
def repr(self): return f"Number({self.value})"

class StringNode(RedlangASTNode):
def init(self, value: str):
self.value = value
def repr(self): return f"String({self.value})"

class IdentifierNode(RedlangASTNode):
def init(self, name: str):
self.name = name
def repr(self): return f"Identifier({self.name})"

class BinaryOpNode(RedlangASTNode):
def init(self, left: RedlangASTNode, operator: str, right: RedlangASTNode):
self.left = left
self.operator = operator
self.right = right
def repr(self): return f"BinaryOp({self.left}, {self.operator}, {self.right})"

class UnaryOpNode(RedlangASTNode):
def init(self, operator: str, operand: RedlangASTNode):
self.operator = operator
self.operand = operand
def repr(self): return f"UnaryOp({self.operator}, {self.operand})"

class AssignmentNode(RedlangASTNode):
def init(self, identifier: str, value: RedlangASTNode):
self.identifier = identifier
self.value = value
def repr(self): return f"Assignment({self.identifier}, {self.value})"

class IfNode(RedlangASTNode):
def init(self, condition: RedlangASTNode, then_branch: List[RedlangASTNode], else_branch: Optional[List[RedlangASTNode]]):
self.condition = condition
self.then_branch = then_branch
self.else_branch = else_branch
def repr(self): return f"If({self.condition}, ...)"

class WhileNode(RedlangASTNode):
def init(self, condition: RedlangASTNode, body: List[RedlangASTNode]):
self.condition = condition
self.body = body
def repr(self): return f"While({self.condition}, ...)"

class ForNode(RedlangASTNode):
def init(self, iterator: str, iterable: RedlangASTNode, body: List[RedlangASTNode]):
self.iterator = iterator
self.iterable = iterable
self.body = body
def repr(self): return f"For({self.iterator} in ...)"

class FunctionDefNode(RedlangASTNode):
def init(self, name: str, params: List[str], body: List[RedlangASTNode]):
self.name = name
self.params = params
self.body = body
def repr(self): return f"FunctionDef({self.name}, {self.params})"

class CallNode(RedlangASTNode):
def init(self, callee: str, arguments: List[RedlangASTNode]):
self.callee = callee
self.arguments = arguments
def repr(self): return f"Call({self.callee}, {self.arguments})"

class ReturnNode(RedlangASTNode):
def init(self, value: Optional[RedlangASTNode]):
self.value = value
def repr(self): return f"Return({self.value})"

class ListNode(RedlangASTNode):
def init(self, elements: List[RedlangASTNode]):
self.elements = elements
def repr(self): return f"List({self.elements})"

class DepthCalcNode(RedlangASTNode):
"""深度计算节点 - Redlang的核心特性"""
def init(self, expression: RedlangASTNode, depth: Optional[RedlangASTNode] = None):
self.expression = expression
self.depth = depth
def repr(self): return f"DepthCalc({self.expression}, depth={self.depth})"

class RedlangParser:
"""Redlang语法分析器"""

def __init__(self, tokens: List[RedlangToken]):
    self.tokens = tokens
    self.position = 0

def parse(self) -> List[RedlangASTNode]:
    """解析程序入口"""
    statements = []
    while not self._is_at_end():
        statements.append(self._parse_statement())
    return statements

def _parse_statement(self) -> RedlangASTNode:
    if self._match(RedlangTokenType.KEYWORD):
        keyword = self._previous().value
        if keyword == "let":
            return self._parse_let()
        elif keyword == "if":
            return self._parse_if()
        elif keyword == "while":
            return self._parse_while()
        elif keyword == "for":
            return self._parse_for()
        elif keyword == "return":
            return self._parse_return()
        elif keyword == "func" or keyword == "def":
            return self._parse_function()
        elif keyword == "depth_calc":
            return self._parse_depth_calc()
    elif self._match(RedlangTokenType.IDENTIFIER):
        # 可能是赋值或函数调用
        identifier = self._previous().value
        if self._match(RedlangTokenType.OPERATOR) and self._previous().value == "=":
            value = self._parse_expression()
            self._consume(RedlangTokenType.SEMICOLON, "期待 ';'")
            return AssignmentNode(identifier, value)
        else:
            # 回退并解析表达式
            self.position -= 1
            expr = self._parse_expression()
            self._consume(RedlangTokenType.SEMICOLON, "期待 ';'")
            return expr
    else:
        expr = self._parse_expression()
        self._consume(RedlangTokenType.SEMICOLON, "期待 ';'")
        return expr

def _parse_let(self) -> AssignmentNode:
    identifier = self._consume(RedlangTokenType.IDENTIFIER, "期待变量名").value
    self._consume(RedlangTokenType.OPERATOR, "期待 '='", value="=")
    value = self._parse_expression()
    self._consume(RedlangTokenType.SEMICOLON, "期待 ';'")
    return AssignmentNode(identifier, value)

def _parse_if(self) -> IfNode:
    condition = self._parse_expression()
    self._consume(RedlangTokenType.LBRACE, "期待 '{'")
    then_branch = self._parse_block()
    else_branch = None
    if self._match(RedlangTokenType.KEYWORD) and self._previous().value == "else":
        self._consume(RedlangTokenType.LBRACE, "期待 '{'")
        else_branch = self._parse_block()
    return IfNode(condition, then_branch, else_branch)

def _parse_while(self) -> WhileNode:
    condition = self._parse_expression()
    self._consume(RedlangTokenType.LBRACE, "期待 '{'")
    body = self._parse_block()
    return WhileNode(condition, body)

def _parse_for(self) -> ForNode:
    iterator = self._consume(RedlangTokenType.IDENTIFIER, "期待迭代变量").value
    self._consume(RedlangTokenType.KEYWORD, "期待 'in'", value="in")
    iterable = self._parse_expression()
    self._consume(RedlangTokenType.LBRACE, "期待 '{'")
    body = self._parse_block()
    return ForNode(iterator, iterable, body)

def _parse_return(self) -> ReturnNode:
    if self._check(RedlangTokenType.SEMICOLON):
        value = None
    else:
        value = self._parse_expression()
    self._consume(RedlangTokenType.SEMICOLON, "期待 ';'")
    return ReturnNode(value)

def _parse_function(self) -> FunctionDefNode:
    name = self._consume(RedlangTokenType.IDENTIFIER, "期待函数名").value
    self._consume(RedlangTokenType.LPAREN, "期待 '('")
    params = []
    if not self._check(RedlangTokenType.RPAREN):
        params.append(self._consume(RedlangTokenType.IDENTIFIER, "期待参数").value)
        while self._match(RedlangTokenType.COMMA):
            params.append(self._consume(RedlangTokenType.IDENTIFIER, "期待参数").value)
    self._consume(RedlangTokenType.RPAREN, "期待 ')'")
    self._consume(RedlangTokenType.LBRACE, "期待 '{'")
    body = self._parse_block()
    return FunctionDefNode(name, params, body)

def _parse_depth_calc(self) -> DepthCalcNode:
    """解析深度计算表达式: depth_calc(expression, depth?)"""
    self._consume(RedlangTokenType.LPAREN, "期待 '('")
    expression = self._parse_expression()
    depth = None
    if self._match(RedlangTokenType.COMMA):
        depth = self._parse_expression()
    self._consume(RedlangTokenType.RPAREN, "期待 ')'")
    self._consume(RedlangTokenType.SEMICOLON, "期待 ';'")
    return DepthCalcNode(expression, depth)

def _parse_block(self) -> List[RedlangASTNode]:
    statements = []
    while not self._check(RedlangTokenType.RBRACE) and not self._is_at_end():
        statements.append(self._parse_statement())
    self._consume(RedlangTokenType.RBRACE, "期待 '}'")
    return statements

def _parse_expression(self) -> RedlangASTNode:
    return self._parse_assignment()

def _parse_assignment(self) -> RedlangASTNode:
    expr = self._parse_logical_or()
    if self._match(RedlangTokenType.OPERATOR) and self._previous().value == "=":
        if isinstance(expr, IdentifierNode):
            value = self._parse_assignment()
            return AssignmentNode(expr.name, value)
        else:
            raise SyntaxError("赋值语句左侧必须是标识符")
    return expr

def _parse_logical_or(self) -> RedlangASTNode:
    expr = self._parse_logical_and()
    while self._match(RedlangTokenType.OPERATOR) and self._previous().value == "||":
        operator = self._previous().value
        right = self._parse_logical_and()
        expr = BinaryOpNode(expr, operator, right)
    return expr

def _parse_logical_and(self) -> RedlangASTNode:
    expr = self._parse_equality()
    while self._match(RedlangTokenType.OPERATOR) and self._previous().value == "&&":
        operator = self._previous().value
        right = self._parse_equality()
        expr = BinaryOpNode(expr, operator, right)
    return expr

def _parse_equality(self) -> RedlangASTNode:
    expr = self._parse_comparison()
    while self._match(RedlangTokenType.OPERATOR) and self._previous().value in ("==", "!="):
        operator = self._previous().value
        right = self._parse_comparison()
        expr = BinaryOpNode(expr, operator, right)
    return expr

def _parse_comparison(self) -> RedlangASTNode:
    expr = self._parse_term()
    while self._match(RedlangTokenType.OPERATOR) and self._previous().value in ("<", ">", "<=", ">="):
        operator = self._previous().value
        right = self._parse_term()
        expr = BinaryOpNode(expr, operator, right)
    return expr

def _parse_term(self) -> RedlangASTNode:
    expr = self._parse_factor()
    while self._match(RedlangTokenType.OPERATOR) and self._previous().value in ("+", "-"):
        operator = self._previous().value
        right = self._parse_factor()
        expr = BinaryOpNode(expr, operator, right)
    return expr

def _parse_factor(self) -> RedlangASTNode:
    expr = self._parse_unary()
    while self._match(RedlangTokenType.OPERATOR) and self._previous().value in ("*", "/", "%", "//", "**"):
        operator = self._previous().value
        right = self._parse_unary()
        expr = BinaryOpNode(expr, operator, right)
    return expr

def _parse_unary(self) -> RedlangASTNode:
    if self._match(RedlangTokenType.OPERATOR) and self._previous().value in ("!", "-"):
        operator = self._previous().value
        operand = self._parse_unary()
        return UnaryOpNode(operator, operand)
    return self._parse_primary()

def _parse_primary(self) -> RedlangASTNode:
    if self._match(RedlangTokenType.NUMBER):
        return NumberNode(self._previous().value)
    if self._match(RedlangTokenType.STRING):
        return StringNode(self._previous().value)
    if self._match(RedlangTokenType.IDENTIFIER):
        identifier = self._previous().value
        if self._match(RedlangTokenType.LPAREN):
            args = []
            if not self._check(RedlangTokenType.RPAREN):
                args.append(self._parse_expression())
                while self._match(RedlangTokenType.COMMA):
                    args.append(self._parse_expression())
            self._consume(RedlangTokenType.RPAREN, "期待 ')'")
            return CallNode(identifier, args)
        return IdentifierNode(identifier)
    if self._match(RedlangTokenType.LPAREN):
        expr = self._parse_expression()
        self._consume(RedlangTokenType.RPAREN, "期待 ')'")
        return expr
    if self._match(RedlangTokenType.LBRACKET):
        elements = []
        if not self._check(RedlangTokenType.RBRACKET):
            elements.append(self._parse_expression())
            while self._match(RedlangTokenType.COMMA):
                elements.append(self._parse_expression())
        self._consume(RedlangTokenType.RBRACKET, "期待 ']'")
        return ListNode(elements)
    raise SyntaxError(f"意外的词法单元: {self._peek()}")

def _match(self, *types: RedlangTokenType) -> bool:
    for t in types:
        if self._check(t):
            self._advance()
            return True
    return False

def _check(self, token_type: RedlangTokenType) -> bool:
    if self._is_at_end():
        return False
    return self._peek().type == token_type

def _advance(self) -> RedlangToken:
    if not self._is_at_end():
        self.position += 1
    return self._previous()

def _peek(self) -> RedlangToken:
    return self.tokens[self.position]

def _previous(self) -> RedlangToken:
    return self.tokens[self.position - 1]

def _is_at_end(self) -> bool:
    return self._peek().type == RedlangTokenType.EOF

def _consume(self, token_type: RedlangTokenType, message: str, value: Any = None) -> RedlangToken:
    if self._check(token_type):
        if value is not None and self._peek().value != value:
            raise SyntaxError(message)
        return self._advance()
    raise SyntaxError(message)

添加缺失的Token类型

RedlangTokenType.SEMICOLON = "semicolon"
RedlangTokenType.LBRACKET = "lbracket"
RedlangTokenType.RBRACKET = "rbracket"

class RedlangInterpreter:
"""Redlang解释器 - 执行深度计算"""

def __init__(self):
    self.globals: Dict[str, Any] = {
        "print": lambda x: print(x),
        "len": len,
        "range": range,
        "str": str,
        "int": int,
        "float": float,
        "abs": abs,
        "sum": sum,
        "min": min,
        "max": max,
        "sqrt": math.sqrt,
        "pow": pow,
        "random": random.random,
        "randint": random.randint,
        "balance_generator": None  # 将在运行时注入
    }
    self.locals: Dict[str, Any] = {}
    self.functions: Dict[str, FunctionDefNode] = {}
    self.return_value = None

def interpret(self, statements: List[RedlangASTNode]) -> Any:
    result = None
    for stmt in statements:
        result = self._execute(stmt)
        if self.return_value is not None:
            break
    return result

def _execute(self, node: RedlangASTNode) -> Any:
    if isinstance(node, NumberNode):
        return node.value
    elif isinstance(node, StringNode):
        return node.value
    elif isinstance(node, IdentifierNode):
        if node.name in self.locals:
            return self.locals[node.name]
        elif node.name in self.globals:
            return self.globals[node.name]
        else:
            raise NameError(f"未定义的变量 '{node.name}'")
    elif isinstance(node, BinaryOpNode):
        return self._eval_binary_op(node)
    elif isinstance(node, UnaryOpNode):
        return self._eval_unary_op(node)
    elif isinstance(node, AssignmentNode):
        value = self._execute(node.value)
        self.locals[node.identifier] = value
        return value
    elif isinstance(node, IfNode):
        condition = self._execute(node.condition)
        if condition:
            for stmt in node.then_branch:
                self._execute(stmt)
                if self.return_value is not None:
                    break
        elif node.else_branch:
            for stmt in node.else_branch:
                self._execute(stmt)
                if self.return_value is not None:
                    break
        return None
    elif isinstance(node, WhileNode):
        while self._execute(node.condition):
            for stmt in node.body:
                self._execute(stmt)
                if self.return_value is not None:
                    break
            if self.return_value is not None:
                break
        return None
    elif isinstance(node, ForNode):
        iterable = self._execute(node.iterable)
        for item in iterable:
            self.locals[node.iterator] = item
            for stmt in node.body:
                self._execute(stmt)
                if self.return_value is not None:
                    break
            if self.return_value is not None:
                break
        return None
    elif isinstance(node, FunctionDefNode):
        self.functions[node.name] = node
        return None
    elif isinstance(node, CallNode):
        if node.callee in self.functions:
            func_node = self.functions[node.callee]
            if len(func_node.params) != len(node.arguments):
                raise RuntimeError(f"函数 {node.callee} 参数数量不匹配")
            args = [self._execute(arg) for arg in node.arguments]
            old_locals = self.locals.copy()
            self.locals = {}
            for param, arg in zip(func_node.params, args):
                self.locals[param] = arg
            self.return_value = None
            for stmt in func_node.body:
                self._execute(stmt)
                if self.return_value is not None:
                    break
            result = self.return_value
            self.return_value = None
            self.locals = old_locals
            return result
        elif node.callee in self.globals:
            func = self.globals[node.callee]
            args = [self._execute(arg) for arg in node.arguments]
            return func(*args)
        else:
            raise NameError(f"未定义的函数 '{node.callee}'")
    elif isinstance(node, ReturnNode):
        self.return_value = self._execute(node.value) if node.value else None
        return self.return_value
    elif isinstance(node, ListNode):
        return [self._execute(elem) for elem in node.elements]
    elif isinstance(node, DepthCalcNode):
        return self._eval_depth_calc(node)
    else:
        raise RuntimeError(f"未知节点类型: {type(node)}")

def _eval_binary_op(self, node: BinaryOpNode) -> Any:
    left = self._execute(node.left)
    right = self._execute(node.right)
    op = node.operator

    if op == "+":
        return left + right
    elif op == "-":
        return left - right
    elif op == "*":
        return left * right
    elif op == "/":
        if right == 0:
            raise ZeroDivisionError("除以零")
        return left / right
    elif op == "//":
        return left // right
    elif op == "%":
        return left % right
    elif op == "**":
        return left ** right
    elif op == "==":
        return left == right
    elif op == "!=":
        return left != right
    elif op == "<":
        return left < right
    elif op == ">":
        return left > right
    elif op == "<=":
        return left <= right
    elif op == ">=":
        return left >= right
    elif op == "&&":
        return left and right
    elif op == "||":
        return left or right
    else:
        raise RuntimeError(f"未知运算符 '{op}'")

def _eval_unary_op(self, node: UnaryOpNode) -> Any:
    operand = self._execute(node.operand)
    if node.operator == "-":
        return -operand
    elif node.operator == "!":
        return not operand
    else:
        raise RuntimeError(f"未知一元运算符 '{node.operator}'")

def _eval_depth_calc(self, node: DepthCalcNode) -> Any:
    """
    深度计算模型的核心算法
    支持递归深度计算、多层嵌套分析和聚合统计
    """
    expression = self._execute(node.expression)
    depth = self._execute(node.depth) if node.depth else 1

    if not isinstance(depth, (int, float)) or depth < 1:
        depth = 1

    def recursive_calc(data, current_depth, max_depth):
        if current_depth > max_depth:
            return data

        if isinstance(data, (int, float)):
            # 对数值进行深度变换
            result = data
            for _ in range(current_depth):
                result = math.sin(result) * math.cos(result) + math.log(abs(result) + 1)
            return result
        elif isinstance(data, list):
            #