chentianrui
1618 lines
66 KiB
Python
1618 lines
66 KiB
Python
from __future__ import annotations
|
|
import logging
|
|
import xml.etree.ElementTree as ET
|
|
from typing import Dict, Callable, Any, Optional
|
|
import os
|
|
from enum import Enum, auto
|
|
from equipment_calculation.expressioncalculator import ExpressionCalculator
|
|
import copy
|
|
|
|
|
|
# 配置logging
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
|
|
handlers=[logging.FileHandler("bcl_calculator.log"), logging.StreamHandler()],
|
|
)
|
|
|
|
|
|
class BCLVariantType(Enum):
|
|
TEXT = "文本"
|
|
FLOAT = "浮点数"
|
|
INTEGER = "整形"
|
|
BOOLEAN = "布尔类型"
|
|
DATASOURCE = "数据源"
|
|
EXPRESSION = "表达式"
|
|
# NULL = "NULL"
|
|
|
|
|
|
class BCLOperatorType(Enum):
|
|
"""
|
|
BCL运算符类型枚举
|
|
"""
|
|
|
|
ADD = "+" # 加
|
|
SUBTRACT = "-" # 减
|
|
MULTIPLY = "*" # 乘
|
|
DIVIDE = "/" # 除
|
|
AND = "&&" # 与
|
|
OR = "||" # 或
|
|
NOT = "!" # 非
|
|
EQUAL = "==" # 等于
|
|
NOT_EQUAL = "!=" # 不等于
|
|
GREATER = ">"
|
|
GREATER_EQUAL = ">="
|
|
LESS = "<"
|
|
LESS_EQUAL = "<="
|
|
UNKNOWN = "unknown" # 未知运算符
|
|
|
|
|
|
def str_to_operator(op_str: str) -> BCLOperatorType:
|
|
"""
|
|
将字符串转换为BCLOperatorType枚举
|
|
:param op_str: 运算符字符串
|
|
:return: 对应的BCLOperatorType枚举值
|
|
"""
|
|
op_map = {
|
|
">": BCLOperatorType.GREATER,
|
|
">=": BCLOperatorType.GREATER_EQUAL,
|
|
"<": BCLOperatorType.LESS,
|
|
"<=": BCLOperatorType.LESS_EQUAL,
|
|
"+": BCLOperatorType.ADD,
|
|
"-": BCLOperatorType.SUBTRACT,
|
|
"*": BCLOperatorType.MULTIPLY,
|
|
"/": BCLOperatorType.DIVIDE,
|
|
"&&": BCLOperatorType.AND,
|
|
"||": BCLOperatorType.OR,
|
|
"!": BCLOperatorType.NOT,
|
|
"==": BCLOperatorType.EQUAL,
|
|
"!=": BCLOperatorType.NOT_EQUAL,
|
|
"加": BCLOperatorType.ADD,
|
|
"减": BCLOperatorType.SUBTRACT,
|
|
"乘": BCLOperatorType.MULTIPLY,
|
|
"除": BCLOperatorType.DIVIDE,
|
|
"与": BCLOperatorType.AND,
|
|
"或": BCLOperatorType.OR,
|
|
"非": BCLOperatorType.NOT,
|
|
"等于": BCLOperatorType.EQUAL,
|
|
"不等于": BCLOperatorType.NOT_EQUAL,
|
|
}
|
|
|
|
if op_str is None:
|
|
return BCLOperatorType.UNKNOWN
|
|
|
|
return op_map.get(op_str.strip(), BCLOperatorType.UNKNOWN)
|
|
|
|
|
|
class BCLVariant:
|
|
def _setobject(self, var_type: BCLVariantType, value):
|
|
self.type = var_type
|
|
self.value = value
|
|
|
|
def __init__(self, value: Any):
|
|
"""
|
|
根据value的类型自动确定变量类型
|
|
:param value: 变量值，可以是str, ET.Element, float, int, bool或list类型
|
|
"""
|
|
if isinstance(value, BCLVariant):
|
|
return self._setobject(value.type, value.value)
|
|
if isinstance(value, str):
|
|
return self._setobject(BCLVariantType.TEXT, value)
|
|
elif isinstance(value, ET.Element):
|
|
return self._setobject(BCLVariantType.EXPRESSION, value)
|
|
elif isinstance(value, list):
|
|
return self._setobject(BCLVariantType.DATASOURCE, value)
|
|
elif isinstance(value, bool):
|
|
return self._setobject(BCLVariantType.BOOLEAN, value)
|
|
elif isinstance(value, float):
|
|
return self._setobject(BCLVariantType.FLOAT, value)
|
|
elif isinstance(value, int):
|
|
return self._setobject(BCLVariantType.INTEGER, value)
|
|
elif value == None:
|
|
# return self._setobject(BCLVariantType.NULL, "")
|
|
return self._setobject(BCLVariantType.TEXT, "")
|
|
else:
|
|
raise ValueError(f"不支持的类型: {type(value)}")
|
|
|
|
def get_value(self) -> Any:
|
|
"""
|
|
获取变量值
|
|
:return: 变量值，转换为浮点数
|
|
"""
|
|
try:
|
|
if self.type == BCLVariantType.TEXT:
|
|
return self.value
|
|
elif self.type == BCLVariantType.DATASOURCE:
|
|
return self.value.get_value()
|
|
elif self.type == BCLVariantType.FLOAT:
|
|
return float(self.value)
|
|
elif self.type == BCLVariantType.INTEGER:
|
|
return int(self.value)
|
|
elif self.type == BCLVariantType.EXPRESSION:
|
|
return self.value
|
|
elif self.type == BCLVariantType.BOOLEAN:
|
|
return bool(self.value)
|
|
else:
|
|
raise ValueError(f"未知的变量类型: {self.type}")
|
|
except (ValueError, TypeError) as e:
|
|
raise ValueError(f"获取变量的值发生错误: {str(e)}\n")
|
|
|
|
def __str__(self) -> str:
|
|
"""
|
|
返回变量的字符串表示
|
|
:return: 变量的字符串表示
|
|
"""
|
|
return f"Variant({self.type}, {self.value})"
|
|
|
|
|
|
# BCL上下文类（用于供计算过程中从该类中获取变量值）
|
|
class BCLContext:
|
|
def __init__(self, valueDict: Dict[str, Any] = None, **kwargs):
|
|
self.variables = {} # 变量字典，键为变量名，值为BCLVariant对象
|
|
self.params = {} # 参数字典，键为字符串，单独存储参数
|
|
|
|
if valueDict:
|
|
for key, value in valueDict.items():
|
|
if isinstance(value, BCLVariant):
|
|
self.variables[key] = value
|
|
else:
|
|
self.variables[key] = BCLVariant(value.__dict__)
|
|
|
|
def _get_variable_value(self, var_name: str) -> BCLVariant:
|
|
"""
|
|
获取变量值
|
|
:param var_name: 变量名，格式为'对象.属性'
|
|
:return: 变量值,如果变量不存在则返回None，请勿抛出异常
|
|
"""
|
|
return self.variables.get(var_name)
|
|
|
|
def get_variable_value(self, var_name: str) -> BCLVariant:
|
|
"""
|
|
获取变量值
|
|
:param var_name: 变量名，格式为'对象.属性'
|
|
:return: 变量值,如果变量不存在则返回None，请勿抛出异常
|
|
"""
|
|
var = self._get_variable_value(var_name)
|
|
if var:
|
|
return var
|
|
else:
|
|
return None
|
|
|
|
def set_param(self, key: str, value):
|
|
"""
|
|
设置参数到参数字典
|
|
:param key: 参数键，必须为字符串
|
|
:param value: 参数值
|
|
"""
|
|
if not isinstance(key, str):
|
|
raise TypeError("参数键必须是字符串类型")
|
|
self.params[key] = value
|
|
|
|
def get_param(self, key: str, default=None):
|
|
"""
|
|
从参数字典获取参数
|
|
:param key: 参数键，必须为字符串
|
|
:param default: 默认值，如果参数不存在则返回
|
|
:return: 参数值或默认值
|
|
"""
|
|
if not isinstance(key, str):
|
|
raise TypeError("参数键必须是字符串类型")
|
|
return self.params.get(key, default)
|
|
|
|
|
|
# 链式BCL上下文类，用于将两个上下文对象穿成一个链表，从而实现依次从两个上下文中获取变量值（该类是抽象类，不支持直接使用）
|
|
class BCLPrevContext(BCLContext):
|
|
def __init__(self, prevContext: BCLContext = None):
|
|
super().__init__()
|
|
self._prevContext = prevContext
|
|
|
|
def _get_variable_value(self, var_name: str) -> BCLVariant:
|
|
"""
|
|
获取变量值，支持点号分隔的变量名查询
|
|
:param var_name: 变量名，可以是简单变量名或'对象.属性'格式
|
|
:return: 找到的变量或None
|
|
"""
|
|
result = super()._get_variable_value(var_name)
|
|
if result == None and self._prevContext:
|
|
# 如果当前对象没有找到变量，尝试在前一个上下文中查找
|
|
try:
|
|
result = self._prevContext._get_variable_value(var_name)
|
|
except ValueError:
|
|
pass
|
|
|
|
return result
|
|
|
|
def set_param(self, key: str, value):
|
|
"""
|
|
设置参数到参数字典
|
|
:param key: 参数键，必须为字符串
|
|
:param value: 参数值
|
|
"""
|
|
if not isinstance(key, str):
|
|
raise TypeError("参数键必须是字符串类型")
|
|
if self._prevContext:
|
|
self._prevContext.set_param(key, value)
|
|
else:
|
|
super().set_param(key, value)
|
|
|
|
def get_param(self, key: str, default=None):
|
|
"""
|
|
从参数字典获取参数
|
|
:param key: 参数键，必须为字符串
|
|
:param default: 默认值，如果参数不存在则返回
|
|
:return: 参数值或默认值
|
|
"""
|
|
if not isinstance(key, str):
|
|
raise TypeError("参数键必须是字符串类型")
|
|
result = super().get_param(key, default)
|
|
if result == None and self._prevContext:
|
|
result = self._prevContext.get_param(key, default)
|
|
return result
|
|
|
|
|
|
# 前缀BCL上下文类，用于将一个上下文对象与一个前缀绑定，从而实现从该上下文中获取变量值
|
|
class BCLPrefixContext(BCLContext):
|
|
def __init__(self, prefix: str, childContext: BCLContext):
|
|
self._childContext = childContext
|
|
self._prefix = prefix
|
|
|
|
def __init__(self, prefix: str, valueDict: Dict[str, Any] = None):
|
|
self._childContext = BCLContext(valueDict)
|
|
self._prefix = prefix
|
|
|
|
def _get_variable_value(self, var_name: str) -> BCLVariant:
|
|
"""
|
|
获取变量值，支持点号分隔的变量名查询
|
|
:param var_name: 变量名，可以是简单变量名或'对象.属性'格式
|
|
:return: 找到的变量或None
|
|
"""
|
|
result = None
|
|
# 检查是否是点号分隔的两段式变量名
|
|
if "." in var_name:
|
|
parts = var_name.split(".", maxsplit=1)
|
|
if len(parts) >= 2 and parts[0] == self._prefix:
|
|
# 如果是当前数据对象的属性，则查询对应的变量
|
|
try:
|
|
result = self._childContext._get_variable_value(parts[1])
|
|
except ValueError:
|
|
pass
|
|
return result
|
|
|
|
|
|
# 前缀链式BCL上下文类，用于将一个上下文对象与一个前缀绑定，从而实现从该上下文中获取变量值
|
|
class BCLPrefixPrevContext(BCLPrefixContext, BCLPrevContext):
|
|
def __init__(self, prefix: str, childContext: BCLContext, prevContext: BCLContext = None):
|
|
BCLPrefixContext.__init__(self, prefix, childContext)
|
|
BCLPrevContext.__init__(self, prevContext)
|
|
|
|
def __init__(self, prefix: str, valueDict: Dict[str, Any], prevContext: BCLContext = None):
|
|
BCLPrefixContext.__init__(self, prefix, valueDict)
|
|
BCLPrevContext.__init__(self, prevContext)
|
|
|
|
def _get_variable_value(self, var_name: str) -> BCLVariant:
|
|
"""
|
|
获取变量值，支持点号分隔的变量名查询
|
|
:param var_name: 变量名，可以是简单变量名或'对象.属性'格式
|
|
:return: 找到的变量或None
|
|
"""
|
|
result = BCLPrefixContext._get_variable_value(self, var_name)
|
|
if result == None:
|
|
# 如果当前对象没有找到变量，尝试在前一个上下文中查找
|
|
try:
|
|
result = BCLPrevContext._get_variable_value(self, var_name)
|
|
except ValueError:
|
|
pass
|
|
|
|
return result
|
|
|
|
|
|
class BCLDataSourceItem:
|
|
|
|
def __init__(self, valueDict: Any, parent: BCLDataSourceItem = None, data_name: str = ""):
|
|
self.variables = {} # 变量字典，键为变量名，值为BCLVariant对象
|
|
self._parent = parent
|
|
self._childs = []
|
|
self._dataname: str = data_name
|
|
|
|
# 处理值字典
|
|
if valueDict:
|
|
items = valueDict if isinstance(valueDict, Dict) else valueDict.__dict__
|
|
|
|
# 将所有属性添加到变量字典中
|
|
for key, value in items.items():
|
|
if isinstance(value, BCLVariant):
|
|
self.variables[key] = value
|
|
else:
|
|
self.variables[key] = BCLVariant(value)
|
|
|
|
# 检查是否有子节点列表（children 或其他名称）
|
|
if "children" in items:
|
|
child_nodes = items["children"]
|
|
if isinstance(child_nodes, list):
|
|
# 为每个子节点创建 BCLDataSourceItem 对象
|
|
self._childs = [BCLDataSourceItem(child, self) for child in child_nodes]
|
|
|
|
def get_dataname(self) -> str:
|
|
return self._dataname
|
|
|
|
def get_value(self, var_name: str) -> BCLVariant:
|
|
|
|
return self.variables.get(var_name)
|
|
|
|
def get_parent(self):
|
|
if self._parent:
|
|
return self._parent
|
|
else:
|
|
return None
|
|
# return self._parent
|
|
|
|
def get_items(self) -> list:
|
|
return self._childs
|
|
|
|
def set_parent(self, parent: BCLDataSourceItem):
|
|
self._parent = parent
|
|
|
|
def set_childs(self, childs: list):
|
|
self._childs = childs
|
|
|
|
|
|
class BCLDataSourceContext(BCLPrevContext):
|
|
def __init__(self, data_source: list[BCLDataSourceItem], prevContext: BCLContext = None):
|
|
super().__init__(prevContext)
|
|
self._data_source = data_source
|
|
|
|
def _get_variable_value(self, var_name: str) -> BCLVariant:
|
|
result = None
|
|
if var_name == "source":
|
|
return BCLVariant(self._data_source)
|
|
else:
|
|
return super()._get_variable_value(var_name)
|
|
|
|
|
|
class BCLCalcItemContext(BCLPrevContext):
|
|
def __init__(self, data_name: str, data_source: list[BCLDataSourceItem], prevContext: BCLContext = None):
|
|
super().__init__(prevContext)
|
|
self._index = 0
|
|
self._data_name = data_name
|
|
self._data_source = data_source
|
|
|
|
def _get_variable_value(self, var_name: str) -> BCLVariant:
|
|
"""
|
|
获取变量值，支持点号分隔的变量名查询
|
|
:param var_name: 变量名，可以是简单变量名或'对象.属性'格式
|
|
:return: 找到的变量或None
|
|
"""
|
|
result = None
|
|
# 检查是否是点号分隔的两段式变量名
|
|
if "." in var_name:
|
|
parts = var_name.split(".", maxsplit=1)
|
|
prefix_name = parts[0]
|
|
# 如果是当前数据对象的属性，则查询对应的变量
|
|
try:
|
|
if prefix_name == "parent":
|
|
value_name = parts[1]
|
|
child_pairt = parts[1]
|
|
item = self._data_source[self._index - 1].get_parent()
|
|
# 处理可能的多级属性访问
|
|
while "." in child_pairt and item:
|
|
child_parts = child_pairt.split(".", maxsplit=1)
|
|
if child_parts[0] == "parent":
|
|
item = item.get_parent()
|
|
value_name = child_parts[1]
|
|
child_pairt = child_parts[1]
|
|
else:
|
|
break
|
|
|
|
if item:
|
|
result = BCLVariant(item.get_value(value_name))
|
|
else:
|
|
result = BCLVariant("")
|
|
|
|
elif prefix_name == self._data_name or prefix_name == "curnode":
|
|
result = BCLVariant(self._data_source[self._index - 1].get_value(parts[1]))
|
|
elif (
|
|
self._data_source[self._index - 1].get_parent()
|
|
and prefix_name == self._data_source[self._index - 1].get_parent().get_dataname()
|
|
):
|
|
result = BCLVariant(self._data_source[self._index - 1].get_parent().get_value(parts[1]))
|
|
except ValueError:
|
|
pass
|
|
|
|
if result == None:
|
|
try:
|
|
if var_name == "curnode":
|
|
result = BCLVariant(self._data_source[self._index - 1])
|
|
elif var_name == "parent":
|
|
result = BCLVariant(self._data_source[self._index - 1].get_parent())
|
|
elif var_name == "items":
|
|
result = BCLVariant(self._data_source[self._index - 1].get_items())
|
|
elif (
|
|
self._data_source[self._index - 1].get_parent()
|
|
and var_name == self._data_source[self._index - 1].get_parent().get_dataname()
|
|
):
|
|
result = BCLVariant(self._data_source[self._index - 1].get_parent())
|
|
else:
|
|
result = super()._get_variable_value(var_name)
|
|
except ValueError:
|
|
pass
|
|
|
|
return result
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def __next__(self):
|
|
if self._index >= len(self._data_source):
|
|
raise StopIteration
|
|
value = self._data_source[self._index]
|
|
self._index += 1
|
|
return value
|
|
|
|
|
|
# 定义test函数
|
|
def test_func(funcname: str, claculate, context: BCLContext, *args):
|
|
logging.debug(f"call function : {funcname}")
|
|
return 0
|
|
|
|
|
|
def round_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 2:
|
|
raise ValueError(f"{funcname}函数需要2个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查第一个参数类型（浮点数或表达式）
|
|
if not isinstance(args[0], BCLVariant) or args[0].type not in (BCLVariantType.FLOAT, BCLVariantType.EXPRESSION):
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是浮点数或表达式类型")
|
|
|
|
# 检查第二个参数类型（整数或表达式）
|
|
if not isinstance(args[1], BCLVariant) or args[1].type not in (BCLVariantType.INTEGER, BCLVariantType.EXPRESSION):
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是整数或表达式类型")
|
|
|
|
# 获取参数值
|
|
value = args[0].value
|
|
decimal_places = args[1].value
|
|
|
|
# print(f"call function : {funcname}\n")
|
|
logging.debug(f"四舍五入值: {value}, 小数位数: {decimal_places}")
|
|
|
|
# 执行四舍五入计算
|
|
return BCLVariant(round(float(value), int(decimal_places)))
|
|
|
|
|
|
def calc_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 1:
|
|
raise ValueError(f"{funcname}函数需要1个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型（表达式）
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.EXPRESSION:
|
|
raise ValueError(f"{funcname}函数的参数必须是表达式类型")
|
|
|
|
# 获取参数值
|
|
expression = args[0].value
|
|
|
|
# print(f"call function : {funcname}\n")
|
|
logging.debug(f"计算表达式: {expression}")
|
|
|
|
# 执行表达式计算并返回结果
|
|
return BCLVariant(expression)
|
|
|
|
|
|
def sort_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 4:
|
|
raise ValueError(f"{funcname}函数需要4个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.DATASOURCE:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是数据源类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是文本类型")
|
|
if not isinstance(args[2], BCLVariant) or args[2].type != BCLVariantType.EXPRESSION:
|
|
raise ValueError(f"{funcname}函数的第三个参数必须是表达式类型")
|
|
if not isinstance(args[3], BCLVariant) or args[3].type != BCLVariantType.STRING:
|
|
raise ValueError(f"{funcname}函数的第四个参数必须是字符串类型")
|
|
|
|
# 获取参数值
|
|
data_source = args[0].value
|
|
text_param = args[1].value
|
|
expression = args[2].value
|
|
string_param = args[3].value
|
|
|
|
logging.debug(f"call function : {funcname}\n")
|
|
logging.debug(f"数据源: {data_source}")
|
|
logging.debug(f"文本参数: {text_param}")
|
|
logging.debug(f"表达式: {expression}")
|
|
logging.debug(f"字符串参数: {string_param}")
|
|
|
|
temp_calculator = copy.copy(claculate)
|
|
# 计算排序键并存储原始索引
|
|
sorted_items = []
|
|
temp_context = BCLCalcItemContext(text_param, data_source, context)
|
|
for index, item in enumerate(temp_context):
|
|
try:
|
|
# 计算排序表达式的值
|
|
result = temp_calculator.evaluate_node(expression, temp_context)
|
|
if not isinstance(result, BCLVariant):
|
|
raise TypeError("排序表达式计算结果必须是BCLVariant类型")
|
|
if result.type not in (BCLVariantType.INTEGER, BCLVariantType.FLOAT):
|
|
raise TypeError(f"排序表达式计算结果类型必须是数字，实际是{result.type}")
|
|
sorted_items.append((float(result.value if result.value else "0"), index, item))
|
|
except Exception as e:
|
|
logging.error(f"计算排序键时出错: {e}", exc_info=True)
|
|
# 出错项放在最后
|
|
sorted_items.append((float("inf"), index, item))
|
|
|
|
# 根据排序键和方向排序
|
|
reverse_order = string_param.lower() == "desc"
|
|
sorted_items.sort(key=lambda x: (x[0], x[1]), reverse=reverse_order)
|
|
|
|
# 提取排序后的数据源
|
|
sorted_data = [item for (key, index, item) in sorted_items]
|
|
|
|
# 返回排序后的结果
|
|
return BCLVariant(sorted_data)
|
|
|
|
|
|
def isempty_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 1:
|
|
raise ValueError(f"{funcname}函数需要1个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.DATASOURCE:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是数据源类型")
|
|
|
|
# 获取参数值
|
|
data_source = args[0].value
|
|
|
|
logging.debug(f"call function : {funcname}\n")
|
|
logging.debug(f"数据源: {data_source}\n")
|
|
|
|
# 检查数据源是否为空
|
|
is_empty = len(data_source) == 0
|
|
# 返回检查结果
|
|
return BCLVariant(is_empty)
|
|
|
|
|
|
def setparam_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 2:
|
|
raise ValueError(f"{funcname}函数需要2个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查第一个参数类型 (文本或表达式)
|
|
if not isinstance(args[0], BCLVariant) or args[0].type not in (BCLVariantType.TEXT, BCLVariantType.EXPRESSION):
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是文本或表达式类型")
|
|
|
|
# 检查第二个参数类型 (BCLVariant)
|
|
if not isinstance(args[1], BCLVariant):
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是BCLVariant类型")
|
|
|
|
# 获取参数值
|
|
param_name_var = args[0]
|
|
param_value = args[1]
|
|
|
|
if param_name_var.type == BCLVariantType.EXPRESSION:
|
|
# 计算参数名 (如果是表达式则求值)
|
|
calculator = BCLCalculator()
|
|
param_name_result = calculator._evaluate_node(param_name_var.value, context)
|
|
if param_name_result.type != BCLVariantType.TEXT:
|
|
raise TypeError(f"{funcname}函数的第一个参数表达式必须返回文本类型")
|
|
param_name = param_name_result.value
|
|
else:
|
|
param_name = param_name_var.value
|
|
|
|
if param_value.type == BCLVariantType.EXPRESSION:
|
|
# 计算参数名 (如果是表达式则求值)
|
|
calculator = BCLCalculator()
|
|
param_value_result = calculator._evaluate_node(param_value.value, context)
|
|
if param_value_result.type != BCLVariantType.TEXT:
|
|
raise TypeError(f"{funcname}函数的第二个参数表达式必须返回文本类型")
|
|
param_value = param_value_result.value
|
|
|
|
# 设置参数到上下文
|
|
context.set_param(param_name, param_value)
|
|
|
|
# 返回设置的参数值
|
|
return param_value
|
|
|
|
|
|
def getparam_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 1:
|
|
raise ValueError(f"{funcname}函数需要1个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型 (文本或表达式)
|
|
if not isinstance(args[0], BCLVariant) or args[0].type not in (BCLVariantType.TEXT, BCLVariantType.EXPRESSION):
|
|
raise ValueError(f"{funcname}函数的参数必须是文本或表达式类型")
|
|
|
|
# 获取参数值
|
|
param_name_var = args[0]
|
|
|
|
# 计算参数名 (如果是表达式则求值)
|
|
calculator = BCLCalculator()
|
|
if param_name_var.type == BCLVariantType.EXPRESSION:
|
|
param_name_result = calculator._evaluate_node(param_name_var.value, context)
|
|
if param_name_result.type != BCLVariantType.TEXT:
|
|
raise TypeError(f"{funcname}函数的参数表达式必须返回文本类型")
|
|
param_name = param_name_result.value
|
|
else:
|
|
param_name = param_name_var.value
|
|
|
|
# 从上下文获取参数
|
|
param_value = context.get_param(param_name)
|
|
|
|
# 返回参数值，如果不存在则返回NULL类型
|
|
if param_value is None:
|
|
return BCLVariant(None, BCLVariantType.NULL)
|
|
return param_value
|
|
|
|
|
|
def groupby_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 4:
|
|
raise ValueError(f"{funcname}函数需要4个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.DATASOURCE:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是数据源类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是文本类型")
|
|
if not isinstance(args[2], BCLVariant) or args[2].type not in (BCLVariantType.TEXT, BCLVariantType.EXPRESSION):
|
|
raise ValueError(f"{funcname}函数的第三个参数必须是文本或表达式类型")
|
|
if not isinstance(args[3], BCLVariant) or args[3].type != BCLVariantType.EXPRESSION:
|
|
raise ValueError(f"{funcname}函数的第四个参数必须是表达式类型")
|
|
|
|
# 获取参数值
|
|
data_source = args[0].value
|
|
text_param = args[1].value
|
|
group_param = args[2].value
|
|
calc_expression = args[3].value
|
|
|
|
logging.debug(f"call function : {funcname}\n")
|
|
logging.debug(f"分组参数: {group_param}")
|
|
logging.debug(f"计算表达式: {calc_expression}")
|
|
|
|
temp_calculator = copy.copy(claculate)
|
|
groups = {}
|
|
|
|
# 遍历数据源进行分组
|
|
temp_context = BCLCalcItemContext(text_param, data_source, context)
|
|
for index, item in enumerate(temp_context):
|
|
try:
|
|
# 根据第三个参数类型获取分组键
|
|
if args[2].type == BCLVariantType.TEXT:
|
|
# 文本类型直接作为键
|
|
group_key = group_param
|
|
else:
|
|
# 表达式类型计算结果作为键
|
|
result = temp_calculator.evaluate_node(group_param, temp_context)
|
|
if not isinstance(result, BCLVariant):
|
|
raise TypeError("分组表达式计算结果必须是BCLVariant类型")
|
|
group_key = str(result.value)
|
|
|
|
# 添加到对应分组
|
|
if group_key not in groups:
|
|
groups[group_key] = []
|
|
groups[group_key].append(item)
|
|
except Exception as e:
|
|
logging.error(f"分组处理出错: {e}", exc_info=True)
|
|
# 错误项放入'error'分组
|
|
if "error" not in groups:
|
|
groups["error"] = []
|
|
groups["error"].append(item)
|
|
|
|
# 对每个分组执行第四个表达式计算
|
|
group_results = {}
|
|
group_context = BCLCalcItemContext(text_param, groups.items(), context)
|
|
for index, (key, items) in enumerate(group_context):
|
|
try:
|
|
# 计算表达式结果
|
|
result = temp_calculator.evaluate_node(calc_expression, group_context)
|
|
group_results[key] = {"items": items, "result": result.value if isinstance(result, BCLVariant) else None}
|
|
except Exception as e:
|
|
logging.error(f"分组计算出错: {e}", exc_info=True)
|
|
group_results[key] = {"items": items, "result": None}
|
|
|
|
# 返回分组计算结果
|
|
return BCLVariant(group_results)
|
|
|
|
|
|
def strfind_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 2:
|
|
raise ValueError(f"{funcname}函数需要2个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是文本类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是文本类型")
|
|
|
|
# 获取参数值
|
|
text1 = args[0].value
|
|
text2 = args[1].value
|
|
|
|
# print(f"call function : {funcname}\n")
|
|
logging.debug(f"文本1: {text1}")
|
|
logging.debug(f"文本2: {text2}")
|
|
|
|
# 查找子字符串位置
|
|
position = text1.find(text2)
|
|
|
|
# 返回查找结果
|
|
return BCLVariant(position)
|
|
|
|
|
|
def in_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 参数数量校验
|
|
if len(args) != 2:
|
|
raise ValueError(f"函数 {funcname} 需要传入2个参数，实际传入了{len(args)}个参数")
|
|
|
|
# 参数类型校验
|
|
param1 = args[0]
|
|
param2 = args[1]
|
|
|
|
# 验证参数1：文本或表达式类型
|
|
if not (isinstance(param1, BCLVariant) and param1.type in (BCLVariantType.TEXT, BCLVariantType.EXPRESSION)):
|
|
raise TypeError(f"函数 {funcname} 的第1个参数必须是文本或表达式类型，实际类型为{type(param1).__name__}")
|
|
|
|
# 验证参数2：文本或表达式类型
|
|
if not (isinstance(param2, BCLVariant) and param2.type in (BCLVariantType.TEXT, BCLVariantType.EXPRESSION)):
|
|
raise TypeError(f"函数 {funcname} 的第2个参数必须是文本或表达式类型，实际类型为{type(param2).__name__}")
|
|
|
|
# 调试信息
|
|
logging.debug(f"调用 {funcname} 函数，参数1: {param1}, 参数2: {param2}")
|
|
|
|
# 创建计算器实例
|
|
temp_calculator = copy.copy(claculate)
|
|
|
|
try:
|
|
# 计算两个表达式的值
|
|
value1 = (
|
|
temp_calculator.calculate_expression(param1.value)
|
|
if param1.type == BCLVariantType.EXPRESSION
|
|
else param1.value
|
|
)
|
|
value2 = (
|
|
temp_calculator.calculate_expression(param2.value)
|
|
if param2.type == BCLVariantType.EXPRESSION
|
|
else param2.value
|
|
)
|
|
|
|
# 判断value1是否在value2中
|
|
result = value1 in value2
|
|
|
|
# 返回布尔类型的BCLVariant对象
|
|
return BCLVariant(result)
|
|
except Exception as e:
|
|
logging.error(f"{funcname} 函数执行错误: {str(e)}", exc_info=True)
|
|
raise
|
|
|
|
|
|
def iif_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 3:
|
|
raise ValueError(f"{funcname}函数需要3个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type not in (BCLVariantType.BOOLEAN, BCLVariantType.EXPRESSION):
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是布尔或表达式类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.EXPRESSION,
|
|
):
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是表达式类型")
|
|
if not isinstance(args[2], BCLVariant) or args[2].type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.EXPRESSION,
|
|
):
|
|
raise ValueError(f"{funcname}函数的第三个参数必须是表达式类型")
|
|
|
|
# 获取参数值
|
|
condition_param = args[0]
|
|
true_expr = args[1]
|
|
false_expr = args[2]
|
|
|
|
# print(f"call function : {funcname}\n")
|
|
|
|
temp_calculator = copy.copy(claculate)
|
|
|
|
try:
|
|
# 计算条件结果
|
|
if condition_param.type == BCLVariantType.EXPRESSION:
|
|
condition_result = temp_calculator.evaluate_node(condition_param.value, context)
|
|
if condition_result.type != BCLVariantType.BOOLEAN:
|
|
raise TypeError("条件表达式必须返回布尔值")
|
|
condition_value = condition_result.value
|
|
else:
|
|
condition_value = condition_param.value
|
|
|
|
# 根据条件计算结果
|
|
if condition_value:
|
|
if true_expr.type == BCLVariantType.EXPRESSION:
|
|
result = temp_calculator.evaluate_node(true_expr.value, context)
|
|
else:
|
|
result = true_expr
|
|
else:
|
|
if false_expr.type == BCLVariantType.EXPRESSION:
|
|
result = temp_calculator.evaluate_node(false_expr.value, context)
|
|
else:
|
|
result = false_expr
|
|
|
|
return result
|
|
except Exception as e:
|
|
print(f"iif函数计算出错: {e}")
|
|
raise e
|
|
|
|
|
|
def for_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 4:
|
|
raise ValueError(f"{funcname}函数需要4个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.DATASOURCE:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是数据源类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是文本类型")
|
|
if not isinstance(args[2], BCLVariant) or args[2].type != BCLVariantType.EXPRESSION:
|
|
raise ValueError(f"{funcname}函数的第三个参数必须是表达式类型")
|
|
if not isinstance(args[3], BCLVariant) or args[3].type != BCLVariantType.EXPRESSION:
|
|
raise ValueError(f"{funcname}函数的第四个参数必须是表达式类型")
|
|
|
|
# 获取参数值
|
|
data_source = args[0].value
|
|
loop_var_name = args[1].value
|
|
expr1 = args[2].value
|
|
expr2 = args[3].value
|
|
|
|
logging.debug(f"call function : {funcname}\n")
|
|
logging.debug(f"数据源: {data_source}\n")
|
|
logging.debug(f"循环变量名: {loop_var_name}")
|
|
logging.debug(f"表达式1: {expr1}")
|
|
logging.debug(f"表达式2: {expr2}")
|
|
|
|
temp_calculator = copy.copy(claculate)
|
|
result = None
|
|
|
|
temp_context = BCLCalcItemContext(loop_var_name, data_source, context)
|
|
for index, item in enumerate(temp_context):
|
|
try:
|
|
# 执行第一个表达式
|
|
result1 = temp_calculator.evaluate_node(expr1, temp_context)
|
|
except Exception as e:
|
|
logging.error(f"循环处理出错: {e}", exc_info=True)
|
|
continue
|
|
|
|
if args[3].type == BCLVariantType.EXPRESSION:
|
|
result = claculate.evaluate_node(expr2, context)
|
|
# 返回循环结果
|
|
return BCLVariant(result)
|
|
|
|
|
|
def group_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 3:
|
|
raise ValueError(f"{funcname}函数需要3个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.DATASOURCE:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是数据源类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是文本类型")
|
|
if not isinstance(args[2], BCLVariant) or args[2].type not in (BCLVariantType.TEXT, BCLVariantType.EXPRESSION):
|
|
raise ValueError(f"{funcname}函数的第三个参数必须是文本或表达式类型")
|
|
|
|
# 获取参数值
|
|
data_source = args[0].value
|
|
text_param = args[1].value
|
|
third_param = args[2].value
|
|
|
|
logging.debug(f"call function : {funcname}\n")
|
|
logging.debug(f"数据源: {data_source}\n")
|
|
logging.debug(f"文本参数: {text_param}\n")
|
|
logging.debug(f"第三个参数: {third_param}")
|
|
|
|
temp_calculator = copy.copy(claculate)
|
|
groups = {}
|
|
|
|
# 遍历数据源进行分组
|
|
temp_context = BCLCalcItemContext(text_param, data_source, context)
|
|
for index, item in enumerate(temp_context):
|
|
try:
|
|
# 根据第三个参数类型获取分组键
|
|
if args[2].type == BCLVariantType.TEXT:
|
|
# 文本类型直接作为键
|
|
group_key = third_param
|
|
else:
|
|
result = temp_calculator.evaluate_node(third_param, temp_context)
|
|
if not isinstance(result, BCLVariant):
|
|
raise TypeError("分组表达式计算结果必须是BCLVariant类型")
|
|
group_key = str(result.value)
|
|
|
|
# 添加到对应分组
|
|
if group_key not in groups:
|
|
groups[group_key] = []
|
|
groups[group_key].append(item)
|
|
except Exception as e:
|
|
print(f"分组处理出错: {e}")
|
|
# 错误项放入'error'分组
|
|
if "error" not in groups:
|
|
groups["error"] = []
|
|
groups["error"].append(item)
|
|
|
|
# 返回分组后的结果
|
|
return BCLVariant(groups)
|
|
|
|
|
|
def sum_func(funcname: str, claculate, context: BCLContext, *args):
|
|
# 检查参数数量
|
|
if len(args) != 3:
|
|
raise ValueError(f"{funcname}函数需要3个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.DATASOURCE:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是数据源类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是文本类型")
|
|
if not isinstance(args[2], BCLVariant) or args[2].type != BCLVariantType.EXPRESSION:
|
|
raise ValueError(f"{funcname}函数的第三个参数必须是表达式类型")
|
|
|
|
# 获取并存储三个参数
|
|
data_source = args[0].value
|
|
data_name = args[1].value
|
|
expression = args[2].value
|
|
|
|
logging.debug(f"call function : {funcname}\n")
|
|
logging.debug(f"数据源: {data_source}\n")
|
|
logging.debug(f"数据变量名称: {data_name}")
|
|
logging.debug(f"表达式: {expression}\n")
|
|
|
|
temp_calculator = copy.copy(claculate)
|
|
# 遍历数据源并累加结果
|
|
total = 0.0
|
|
temp_context = BCLCalcItemContext(data_name, data_source, context)
|
|
for index, item in enumerate(temp_context):
|
|
try:
|
|
result = temp_calculator.evaluate_node(expression, temp_context)
|
|
# 验证结果类型必须是BCLVariant且类型为数字
|
|
if not isinstance(result, BCLVariant):
|
|
raise TypeError("表达式计算结果必须是BCLVariant类型")
|
|
if result.type not in (BCLVariantType.INTEGER, BCLVariantType.FLOAT):
|
|
raise TypeError(f"表达式计算结果类型必须是数字，实际是{result.type}")
|
|
total += float(result.value)
|
|
except Exception as e:
|
|
logging.error(f"表达式计算错误: {str(e)}", exc_info=True)
|
|
continue
|
|
|
|
return BCLVariant(total)
|
|
|
|
|
|
def filter_func(funcname: str, claculate, context: BCLContext, *args):
|
|
"""
|
|
过滤函数，检查参数并执行过滤操作
|
|
:param funcname: 函数名
|
|
:param args: 参数列表，必须包含3个BCLVariant参数
|
|
:return: 过滤结果
|
|
"""
|
|
# 检查参数数量
|
|
if len(args) != 3:
|
|
raise ValueError(f"{funcname}函数需要3个参数，但提供了{len(args)}个参数")
|
|
|
|
# 检查参数类型
|
|
if not isinstance(args[0], BCLVariant) or args[0].type != BCLVariantType.DATASOURCE:
|
|
raise ValueError(f"{funcname}函数的第一个参数必须是数据源类型")
|
|
if not isinstance(args[1], BCLVariant) or args[1].type != BCLVariantType.TEXT:
|
|
raise ValueError(f"{funcname}函数的第二个参数必须是文本类型")
|
|
if not isinstance(args[2], BCLVariant) or args[2].type != BCLVariantType.EXPRESSION:
|
|
raise ValueError(f"{funcname}函数的第三个参数必须是表达式类型")
|
|
|
|
# 获取并存储三个参数
|
|
data_source = args[0].value
|
|
data_name = args[1].value
|
|
expression = args[2].value
|
|
|
|
logging.debug(f"call function : {funcname}\n")
|
|
logging.debug(f"数据源: {data_source}\n")
|
|
logging.debug(f"数据变量名称: {data_name}\n")
|
|
logging.debug(f"表达式: {expression}\n")
|
|
|
|
temp_calculator = copy.copy(claculate)
|
|
|
|
# 遍历数据源并应用过滤条件
|
|
filtered_results = []
|
|
temp_context = BCLCalcItemContext(data_name, data_source, context)
|
|
for index, item in enumerate(temp_context):
|
|
# 调用计算器的evaluate_node方法计算表达式
|
|
try:
|
|
result = temp_calculator.evaluate_node(expression, temp_context)
|
|
# 验证结果类型必须是BCLVariant且类型为布尔或整数
|
|
if not isinstance(result, BCLVariant):
|
|
raise TypeError("表达式计算结果必须是BCLVariant类型")
|
|
if result.type not in (BCLVariantType.BOOLEAN, BCLVariantType.INTEGER):
|
|
raise TypeError(f"表达式计算结果类型必须是布尔或整数，实际是{result.type}")
|
|
# 判别其值为true才添加到filtered_results
|
|
if result.value:
|
|
filtered_results.append(item)
|
|
except Exception as e:
|
|
logging.error(f"表达式计算错误: {str(e)}", exc_info=True)
|
|
continue
|
|
|
|
return BCLVariant(filtered_results)
|
|
|
|
|
|
def recursion_counter(func):
|
|
def wrapper(self, node, *args, **kwargs):
|
|
if not hasattr(self, "_recursion_depth"):
|
|
self._recursion_depth = 0
|
|
if not hasattr(self, "_total_count"):
|
|
self._total_count = 0
|
|
|
|
self._total_count += 1
|
|
self._recursion_depth += 1
|
|
try:
|
|
result = func(self, node, *args, **kwargs)
|
|
return result
|
|
finally:
|
|
self._recursion_depth -= 1
|
|
|
|
return wrapper
|
|
|
|
|
|
class BCLCalculator:
|
|
def __init__(self):
|
|
self.expressions: Dict[str, ET.Element] = {}
|
|
self.functions: Dict[str, Callable] = {}
|
|
self.last_error: Optional[str] = None
|
|
self.loaded_scripts = [] # 存储已加载的脚本相对路径
|
|
|
|
# 注册sum函数
|
|
self.register_function("sum", sum_func)
|
|
self.register_function("calc", calc_func)
|
|
self.register_function("round", round_func)
|
|
self.register_function("filter", filter_func)
|
|
self.register_function("iif", iif_func)
|
|
self.register_function("sort", sort_func)
|
|
self.register_function("group", group_func)
|
|
self.register_function("groupby", groupby_func)
|
|
self.register_function("for", for_func)
|
|
self.register_function("in", in_func)
|
|
self.register_function("isEmpty", isempty_func)
|
|
self.register_function("setparam", setparam_func)
|
|
self.register_function("getparam", getparam_func)
|
|
self.register_function("strFind", strfind_func)
|
|
|
|
def __copy__(self):
|
|
# 创建新实例，复制基本属性
|
|
new_instance = self.__class__()
|
|
new_instance.loaded_scripts = self.loaded_scripts # 直接引用
|
|
new_instance.expressions = self.expressions # 直接引用
|
|
new_instance.functions = self.functions # 直接引用
|
|
return new_instance
|
|
|
|
def load_scripts_dir(self, dir_path: str) -> bool:
|
|
"""
|
|
加载目录下所有XML脚本文件
|
|
:param dir_path: 包含XML文件的目录路径
|
|
:return: 是否全部加载成功
|
|
"""
|
|
if not os.path.isdir(dir_path):
|
|
self.last_error = f"目录'{dir_path}'不存在或不是目录\n"
|
|
return False
|
|
|
|
success = True
|
|
for filename in os.listdir(dir_path):
|
|
if filename.lower().endswith(".xml"):
|
|
xml_path = os.path.join(dir_path, filename)
|
|
if not self.load_script(xml_path):
|
|
success = False
|
|
|
|
return success
|
|
|
|
def load_script(self, xml_path: str) -> bool:
|
|
"""
|
|
加载XML脚本文件并验证其结构
|
|
:param xml_path: XML文件路径
|
|
:return: 是否加载成功
|
|
"""
|
|
try:
|
|
# 检查文件是否存在
|
|
if not os.path.exists(xml_path):
|
|
self.last_error = f"文件'{xml_path}'不存在\n"
|
|
return False
|
|
|
|
# 读取并清理XML文件内容
|
|
import chardet
|
|
|
|
# 检测文件编码
|
|
with open(xml_path, "rb") as f:
|
|
raw_data = f.read()
|
|
encoding = chardet.detect(raw_data)["encoding"]
|
|
|
|
# 使用检测到的编码读取文件内容，并转换为UTF-8
|
|
with open(xml_path, "r", encoding=encoding, errors="replace") as f:
|
|
content = f.read()
|
|
|
|
# 确保内容是UTF-8编码
|
|
if encoding.lower() != "utf-8":
|
|
content = content.encode("utf-8", errors="replace").decode("utf-8")
|
|
|
|
# 清理重复的Type属性
|
|
content = self._clean_xml_attributes(content)
|
|
|
|
# 解析清理后的XML
|
|
root = ET.fromstring(content)
|
|
|
|
# 记录已加载的脚本相对路径
|
|
relative_path = os.path.relpath(xml_path, start=os.getcwd())
|
|
self.loaded_scripts.append(relative_path)
|
|
|
|
# 验证根节点 - 兼容BclDocument作为根节点或在Document-DataDefs下
|
|
if root.tag == "Document":
|
|
data_defs = root.find("DataDefs")
|
|
if data_defs is not None:
|
|
bcl_doc = data_defs.find("BclDocument")
|
|
if bcl_doc is not None:
|
|
root = bcl_doc
|
|
else:
|
|
self.last_error = "在Document/DataDefs下未找到BclDocument节点\n"
|
|
return False
|
|
else:
|
|
self.last_error = "Document节点缺少DataDefs子节点\n"
|
|
return False
|
|
elif root.tag != "BclDocument":
|
|
self.last_error = "根节点必须是BclDocument或Document\n"
|
|
return True
|
|
|
|
# 验证所有BCLExpression节点
|
|
for expr in root.findall("BCLExpression"):
|
|
if not self._validate_expression_node(expr):
|
|
return False
|
|
|
|
name = expr.get("name")
|
|
self.expressions[name] = expr
|
|
|
|
return True
|
|
except ET.ParseError as e:
|
|
self.last_error = f"XML解析错误: {str(e)}\n"
|
|
return False
|
|
except Exception as e:
|
|
self.last_error = f"加载脚本失败: {str(e)}\n"
|
|
return False
|
|
|
|
def _clean_xml_attributes(self, xml_content: str) -> str:
|
|
"""
|
|
清理XML中的重复属性，保留最后一个出现的属性值
|
|
:param xml_content: XML内容字符串
|
|
:return: 清理后的XML内容
|
|
"""
|
|
# 使用正则表达式匹配并清理重复的Type属性
|
|
import re
|
|
|
|
# xml_content = '''<ELNode type="函数" Type="TextW" text="_过滤取费定额" Type="TextW" valtype="5" Type="Int" />'''
|
|
|
|
# 正则表达式删除所有 Type="*" 属性
|
|
xml_content = re.sub(r'Type="[^"]*"', "", xml_content)
|
|
return xml_content
|
|
|
|
def _validate_expression_node(self, node: ET.Element) -> bool:
|
|
"""
|
|
验证表达式节点结构
|
|
:param node: ELNode节点
|
|
:return: 是否验证通过
|
|
"""
|
|
# 检查必须包含ELNode子节点
|
|
el_node = node.find("ELNode")
|
|
if el_node is None:
|
|
self.last_error = f"表达式节点'{node.get('name')}'缺少ELNode子节点"
|
|
return False
|
|
|
|
# 检查ELNode类型
|
|
if el_node.get("type") != "表达式序列":
|
|
self.last_error = f"表达式节点'{node.get('name')}'的ELNode类型必须是'表达式序列'"
|
|
return False
|
|
|
|
return True
|
|
|
|
def register_function(self, name: str, func: Callable) -> None:
|
|
self.functions[name] = func
|
|
|
|
def calculate(self, expr_name: str, context: BCLContext) -> float:
|
|
self.last_error = None
|
|
if expr_name not in self.expressions:
|
|
self.last_error = f"表达式'{expr_name}'未找到"
|
|
logging.error(f"错误: {self.last_error}")
|
|
return None
|
|
|
|
try:
|
|
expr_node = self.expressions[expr_name]
|
|
result = self._evaluate_node(expr_node, context)
|
|
if result is None:
|
|
logging.error(f"错误: {self.last_error}")
|
|
return None
|
|
|
|
return result.value
|
|
except Exception as e:
|
|
self.last_error = f"计算错误: {str(e)}"
|
|
print(f"错误: {self.last_error}")
|
|
return None
|
|
|
|
def evaluate_node(self, node: ET.Element, context: BCLContext) -> BCLVariant:
|
|
self.last_error = None
|
|
|
|
try:
|
|
result = self._evaluate_node(node, context)
|
|
if result is None:
|
|
logging.error(f"错误: {self.last_error}")
|
|
|
|
return result
|
|
except Exception as e:
|
|
self.last_error = f"计算错误: {str(e)}"
|
|
print(f"错误: {self.last_error}")
|
|
return None
|
|
|
|
def _get_variable_value(self, var_name: str, context: BCLContext) -> BCLVariant:
|
|
try:
|
|
var = context.get_variable_value(var_name)
|
|
if var is not None:
|
|
logging.debug(f"找到变量: {var_name}, 值: {var.value}, 类型: {var.type}")
|
|
return var
|
|
else:
|
|
logging.warning(f"未找到变量: {var_name}")
|
|
raise ValueError(f"变量'{var_name}'不存在")
|
|
except (AttributeError, ValueError) as e:
|
|
raise e
|
|
|
|
@recursion_counter
|
|
def _evaluate_node(self, node: ET.Element, context: BCLContext) -> BCLVariant:
|
|
node_type = node.get("type")
|
|
if node_type is not None:
|
|
node_type = node_type.strip()
|
|
|
|
indent = " " * self._recursion_depth
|
|
if node_type is None:
|
|
logging.debug(f"{indent} {node.tag} {node.get('name')}")
|
|
else:
|
|
logging.debug(f"{indent} {node.tag} {node_type} {node.get('text')}")
|
|
|
|
if node_type == "变量":
|
|
var_name = node.get("text").strip()
|
|
return self._get_variable_value(var_name, context)
|
|
elif node_type == "数值":
|
|
return BCLVariant(float(node.get("text").strip()))
|
|
elif node_type == "字符串":
|
|
return BCLVariant(str(node.get("text") if node.get("text") else "").strip())
|
|
elif node_type == "函数":
|
|
func_name = node.get("text").strip()
|
|
return self._call_function(func_name, node, context)
|
|
elif str_to_operator(node_type) != BCLOperatorType.UNKNOWN:
|
|
return self._evaluate_logical_expression(node, context)
|
|
elif node_type == "条件运算符":
|
|
return self._evaluate_flow_expression(node[0], context)
|
|
elif node_type == "简单计算式":
|
|
return self._evaluate_expression(node, context)
|
|
elif node_type == "表达式序列":
|
|
# 处理表达式序列节点
|
|
result = None
|
|
for child in node:
|
|
result = self._evaluate_node(child, context)
|
|
|
|
return result
|
|
elif node_type == "参数起始符号":
|
|
# 处理参数起始符号节点
|
|
result = None
|
|
for child in node:
|
|
result = self._evaluate_node(child, context)
|
|
|
|
return result
|
|
elif node.tag == "BCLExpression" or node.tag == "LeftNode" or node.tag == "RightNode":
|
|
# 处理BCLExpression节点
|
|
child = node[0]
|
|
if child.tag == "ELNode" and child.get("type") == "表达式序列":
|
|
return self._evaluate_node(node[0], context)
|
|
else:
|
|
logging.warning(f"{indent} 未知的计算节点类型: {node_type}")
|
|
raise ValueError(f"未知的计算节点类型: {node_type}")
|
|
|
|
def _evaluate_logical_expression(self, node: ET.Element, context: BCLContext) -> BCLVariant:
|
|
"""
|
|
计算逻辑表达式
|
|
:param node: XML节点
|
|
:param context: 上下文对象
|
|
:return: 逻辑运算结果
|
|
"""
|
|
node_type = node.get("type").strip()
|
|
operator_type = str_to_operator(node_type)
|
|
|
|
left = self._evaluate_node(node.find("LeftNode"), context)
|
|
if left is None:
|
|
left = BCLVariant(False)
|
|
|
|
if operator_type == BCLOperatorType.NOT:
|
|
if not isinstance(left, BCLVariant):
|
|
raise ValueError(f"NOT运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}")
|
|
if left.type in [BCLVariantType.BOOLEAN, BCLVariantType.INTEGER]:
|
|
return BCLVariant(not bool(left.value))
|
|
|
|
raise ValueError(f"运算符 '{node_type}' 参数类型为 {left.type} ,不支持的\n")
|
|
|
|
right = self._evaluate_node(node.find("RightNode"), context)
|
|
if left is None:
|
|
left = BCLVariant(False)
|
|
|
|
if operator_type == BCLOperatorType.AND:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'与'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type in [BCLVariantType.BOOLEAN, BCLVariantType.INTEGER] and right.type in [
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.INTEGER,
|
|
]:
|
|
return BCLVariant(bool(left.value) and bool(right.value))
|
|
|
|
raise ValueError(f"运算符 '{node_type}' 两边参数类型分别为 {left.type} {right.type} ,不支持的\n")
|
|
|
|
elif operator_type == BCLOperatorType.OR:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'或'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type in [BCLVariantType.BOOLEAN, BCLVariantType.INTEGER] and right.type in [
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.INTEGER,
|
|
]:
|
|
return BCLVariant(bool(left.value) or bool(right.value))
|
|
|
|
raise ValueError(f"运算符 '{node_type}' 两边参数类型分别为 {left.type} {right.type} ,不支持的\n")
|
|
|
|
elif operator_type == BCLOperatorType.EQUAL:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'等于'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
# 类型转换逻辑
|
|
if BCLVariantType.BOOLEAN in [left.type, right.type]:
|
|
left_value = bool(left.value if left.value else "0")
|
|
right_value = bool(right.value if right.value else "0")
|
|
elif BCLVariantType.FLOAT in [left.type, right.type]:
|
|
left_value = float(left.value if left.value else "0")
|
|
right_value = float(right.value if right.value else "0")
|
|
elif BCLVariantType.INTEGER in [left.type, right.type]:
|
|
left_value = float(left.value if left.value else "0")
|
|
right_value = float(right.value if right.value else "0")
|
|
else:
|
|
left_value = left.value
|
|
right_value = right.value
|
|
|
|
return BCLVariant(left_value == right_value)
|
|
|
|
elif operator_type == BCLOperatorType.NOT_EQUAL:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'不等于'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
return BCLVariant(left.value != right.value)
|
|
|
|
elif operator_type == BCLOperatorType.GREATER:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'>'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
|
|
# 支持 FLOAT 和 INTEGER 类型的比较
|
|
if left.type in [BCLVariantType.FLOAT, BCLVariantType.INTEGER] and right.type in [
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.INTEGER,
|
|
]:
|
|
return BCLVariant(float(left.value if left.value else "0") > float(right.value if right.value else "0"))
|
|
|
|
raise ValueError(f"运算符 '{node_type}' 两边参数类型分别为 {left.type} {right.type} ,不支持的\n")
|
|
|
|
elif operator_type == BCLOperatorType.GREATER_EQUAL:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'>='运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type in [BCLVariantType.INTEGER] and right.type in [BCLVariantType.INTEGER]:
|
|
return BCLVariant(
|
|
float(left.value if left.value else "0") >= float(right.value if right.value else "0")
|
|
)
|
|
raise ValueError(f"运算符 '{node_type}' 两边参数类型分别为 {left.type} {right.type} ,不支持的\n")
|
|
|
|
elif operator_type == BCLOperatorType.LESS:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'<'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type in [BCLVariantType.INTEGER] and right.type in [BCLVariantType.INTEGER]:
|
|
return BCLVariant(float(left.value if left.value else "0") < float(right.value if right.value else "0"))
|
|
raise ValueError(f"运算符 '{node_type}' 两边参数类型分别为 {left.type} {right.type} ,不支持的\n")
|
|
|
|
elif operator_type == BCLOperatorType.LESS_EQUAL:
|
|
if not isinstance(left, BCLVariant) or not isinstance(right, BCLVariant):
|
|
raise ValueError(f"'<='运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type in [BCLVariantType.INTEGER] and right.type in [BCLVariantType.INTEGER]:
|
|
return BCLVariant(
|
|
float(left.value if left.value else "0") <= float(right.value if right.value else "0")
|
|
)
|
|
raise ValueError(f"运算符 '{node_type}' 两边参数类型分别为 {left.type} {right.type} ,不支持的\n")
|
|
|
|
# 四则运算符处理
|
|
elif operator_type == BCLOperatorType.ADD:
|
|
if not (isinstance(left, BCLVariant) and isinstance(right, BCLVariant)):
|
|
raise ValueError(f"'加'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
) or right.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
):
|
|
raise ValueError(
|
|
f"'加'运算符的操作数类型必须为数值、浮点数、布尔或文本，实际为: {left.type}和{right.type}"
|
|
)
|
|
return BCLVariant(float(left.value if left.value else "0") + float(right.value if right.value else "0"))
|
|
|
|
elif operator_type == BCLOperatorType.SUBTRACT:
|
|
if not (isinstance(left, BCLVariant) and isinstance(right, BCLVariant)):
|
|
raise ValueError(f"'减'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
) or right.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
):
|
|
raise ValueError(
|
|
f"'减'运算符的操作数类型必须为数值、浮点数、布尔或文本，实际为: {left.type}和{right.type}"
|
|
)
|
|
return BCLVariant(float(left.value if left.value else "0") - float(right.value if right.value else "0"))
|
|
|
|
elif operator_type == BCLOperatorType.MULTIPLY:
|
|
if not (isinstance(left, BCLVariant) and isinstance(right, BCLVariant)):
|
|
raise ValueError(f"'乘'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
) or right.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
):
|
|
raise ValueError(
|
|
f"'乘'运算符的操作数类型必须为数值、浮点数、布尔或文本，实际为: {left.type}和{right.type}"
|
|
)
|
|
try:
|
|
left_val = float(left.value) if left.value and str(left.value).strip() not in ("", "None") else 0.0
|
|
right_val = float(right.value) if right.value and str(right.value).strip() not in ("", "None") else 0.0
|
|
result = left_val * right_val
|
|
except (TypeError, ValueError, AttributeError):
|
|
result = 0.0
|
|
|
|
return BCLVariant(result)
|
|
|
|
elif operator_type == BCLOperatorType.DIVIDE:
|
|
if not (isinstance(left, BCLVariant) and isinstance(right, BCLVariant)):
|
|
raise ValueError(f"'除'运算符的操作数必须是BCLVariant类型，实际得到: {type(left)}和{type(right)}")
|
|
if left.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
) or right.type not in (
|
|
BCLVariantType.INTEGER,
|
|
BCLVariantType.FLOAT,
|
|
BCLVariantType.BOOLEAN,
|
|
BCLVariantType.TEXT,
|
|
):
|
|
raise ValueError(
|
|
f"'除'运算符的操作数类型必须为数值、浮点数、布尔或文本，实际为: {left.type}和{right.type}"
|
|
)
|
|
if float(right.value) == 0:
|
|
raise ZeroDivisionError("除数不能为零")
|
|
return BCLVariant(float(left.value if left.value else "0") / float(right.value if right.value else "0"))
|
|
|
|
raise ValueError(f"运算符 '{node_type}' 类型不支持的\n")
|
|
|
|
def _evaluate_expression(self, expr_node: ET.Element, context: BCLContext) -> BCLVariant:
|
|
try:
|
|
# 收集所有变量值
|
|
variables = {}
|
|
for var_node in expr_node:
|
|
if var_node.get("type") != "变量":
|
|
continue
|
|
|
|
var_name = var_node.get("text")
|
|
variables[var_name] = self._get_variable_value(var_name, context)
|
|
|
|
# 构建表达式字符串
|
|
expr_str = expr_node.get("text")
|
|
|
|
symbols = {}
|
|
for var_name, var_value in variables.items():
|
|
symbols[var_name] = float("0" if not var_value.get_value() else var_value.get_value())
|
|
|
|
calculator = ExpressionCalculator()
|
|
parse_success = calculator.parse_expression(expr_str)
|
|
if not parse_success:
|
|
logging.error(f"表达式解析失败: {calculator.get_last_error()}")
|
|
raise ValueError(f"表达式解析失败: {calculator.get_last_error()}")
|
|
|
|
# 执行四则运算并返回结果
|
|
result, value = calculator.evaluate(symbols)
|
|
if not result:
|
|
logging.error(f"表达式计算失败: {calculator.get_last_error()}")
|
|
raise ValueError(f"表达式计算失败: {calculator.get_last_error()}")
|
|
|
|
return BCLVariant(value)
|
|
except Exception as e:
|
|
raise e
|
|
|
|
def _call_function(self, func_name: str, node: ET.Element, context: BCLContext) -> BCLVariant:
|
|
|
|
if func_name in self.expressions:
|
|
expr_node = self.expressions[func_name]
|
|
result = self._evaluate_node(expr_node, context)
|
|
return result
|
|
|
|
if func_name not in self.functions:
|
|
raise ValueError(f"函数'{func_name}'未注册\n")
|
|
|
|
args = []
|
|
for child in node:
|
|
if child.get("type") == "参数起始符号":
|
|
current_node = child
|
|
while True:
|
|
# 验证子节点数量必须为1
|
|
if len(current_node) != 1:
|
|
raise ValueError(f"函数'{func_name}'参数节点数量错误，预期1个实际{len(current_node)}个\n")
|
|
child_node = current_node[0]
|
|
# 检查是否存在type属性
|
|
if child_node.get("type") != None:
|
|
break
|
|
# 继续遍历子节点
|
|
current_node = child_node
|
|
args.append(BCLVariant(child_node))
|
|
continue
|
|
|
|
args.append(self._evaluate_node(child, context))
|
|
|
|
return self.functions[func_name](func_name, self, context, *args)
|
|
|
|
def get_last_error(self) -> Optional[str]:
|
|
return self.last_error
|
|
|
|
def _evaluate_flow_expression(self, node: ET.Element, context: BCLContext) -> BCLVariant:
|
|
"""
|
|
处理流程表达式（如ConditionNode/ConListElm/ConNode条件分支结构）
|
|
:param node: ConListElm节点
|
|
:param context: 上下文对象
|
|
:return: 满足条件的ValueNode的计算结果
|
|
"""
|
|
defval = None
|
|
# 只处理当前ConListElm节点，不递归遍历所有ConListElm
|
|
for block in node:
|
|
if block.tag == "ConListElm":
|
|
con_node = None
|
|
value_node = None
|
|
for sub in block:
|
|
if sub.tag == "ConNode":
|
|
con_node = sub
|
|
elif sub.tag == "ValueNode":
|
|
value_node = sub
|
|
if con_node is not None and value_node is not None:
|
|
cond_result = self._evaluate_node(con_node, context)
|
|
if cond_result and bool(cond_result.value):
|
|
return self._evaluate_node(
|
|
value_node if value_node.get("type") != None else value_node[0], context
|
|
)
|
|
elif block.tag == "DefVal":
|
|
defval = block
|
|
|
|
if defval is not None:
|
|
return self._evaluate_node(defval, context)
|
|
else:
|
|
# 没有条件成立，返回0.0
|
|
return BCLVariant(0.0)
|