chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/legacy/updates.py

@@ -0,0 +1,277 @@
+"""表示旧路径一次实际求值所见的更新，并校验单来源的求值顺序。
+
+输入是调用方已经取得的时间、原帧身份、SourceRef、原求值序号和完整值字典；
+输出是冻结的LegacyDecodedUpdate及只保存最后事实的LegacyUpdateOrder。
+无需时间的固定周期消息累计显式使用LegacyUntimedUpdate，其time_ns只能
+为None；同一顺序器不能混用有时间和无时间更新，不补造0时间。
+模型保留原字段全文、None和非有限浮点，不推断类型、单位、缩放、TTL、缓存
+或有效性。QualityFlag.NONE只表示没有记录质量原因，不证明值的新鲜度。
+
+本模块只依赖标准库和共享核心模型，不读取日志、不调用旧解码器，也不提供
+旧求值点的采集接口。调用方构造这些对象不能证明真实旧生产者已经暴露求值
+过程；真实求值证据仍须由后续来源契约提供。值字典由调用方提供，本层复制
+并冻结它，不宣称该复制已有执行预算或IPC大小界限。
+"""
+
+# 只复用类型、时间及标量校验；原字段不经过表达式别名或CAN线协议转换。
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+
+from ..core.models import SourceRef
+from ..core.types import QualityFlag
+from ..core.validation import require_identifier, require_scalar
+from ..timebase.conversion import require_int64_ns
+
+
+def _require_nonnegative_int(value: int, field: str) -> int:
+    """校验原生非负整数身份，不把布尔或数值子类转成合法序号。
+
+    参数:
+        value: 原生int，表示通道、帧ID、来源序号或求值序号。
+        field: 错误消息使用的字段名称。
+    返回:
+        int: 输入的原整数；不重编号，也不设置额外的序号上限。
+    异常:
+        TypeError: 输入不是精确的原生int，包括bool和整数子类。
+        ValueError: 输入为负数。
+    """
+    # 身份整数的协议比共享时间的Integral协议严格，不能隐式接受数组标量。
+    if type(value) is not int:
+        raise TypeError(f"{field}必须为原生非布尔整数")
+    if value < 0:
+        raise ValueError(f"{field}必须非负")
+    return value
+
+
+@dataclass(frozen=True)
+class LegacyDecodedUpdate:
+    """冻结一次求值的原值快照，区分原帧序号与求值序号。
+
+    time_ns按共享int64纳秒协议规范化；sequence定位原帧，evaluation_index
+    定位求值点，同一帧可以有多次求值。四个原帧标志必须显式传入，不能由ID
+    或载荷猜测。source_ref保留原对象并核对source，不补造旧缓存或求值证据。
+    values只接收精确dict或MappingProxyType，复制后冻结；键与原生不可变
+    标量保持原样，空字典合法，非有限浮点不会被替换或自动附加质量原因。
+    """
+
+    time_ns: int  # 调用方已取得的时间；仅按共享时间协议规范为Python整数。
+    source: str  # 与SourceRef.source_name一致的来源标识。
+    channel: int  # 原生非负通道编号，不从其他帧信息推断。
+    frame_id: int  # 标准帧或扩展帧范围内的原CAN ID。
+    is_extended: bool  # 原扩展帧标志，决定ID的合法上限。
+    is_fd: bool  # 原CAN FD标志，不由数据长度推断。
+    is_remote: bool  # 原远程帧标志，必须由调用方明确提供。
+    is_error: bool  # 原错误帧标志，不由质量位推断。
+    source_ref: SourceRef  # 原来源引用；允许已有SourceRef子类。
+    sequence: int  # 原帧序号；不要求连续，也不等同于求值序号。
+    evaluation_index: int  # 旧求值顺序；跨帧及同帧均独立递增。
+    values: Mapping[str, int | float | bool | str | None]  # 原字段和值的独立冻结副本。
+    quality: QualityFlag = QualityFlag.NONE  # 只保留明确记录的原因位。
+
+    def __post_init__(self) -> None:
+        """校验显式身份并建立不受调用方字典后续修改影响的快照。
+
+        参数:
+            无额外参数；读取构造时传入的全部字段。
+        返回:
+            None: 成功后time_ns已规范，values为新MappingProxyType。
+        异常:
+            TypeError: 身份、标志、来源引用、质量位、字典或标量类型不符。
+            ValueError: 来源不匹配、负身份、ID越界或值字典含空键。
+            TimeOverflowError: time_ns超出共享int64纳秒范围。
+            MemoryError: 复制原值快照所需的分配失败；不返回部分模型。
+        """
+        # 时间沿已有协议允许Integral并精确规范；其余身份须为原生整数。
+        time_ns = require_int64_ns(self.time_ns)
+        # 无时间子类复用同一身份/数值校验，原入口仍在此严格要求真实时间。
+        self._freeze_fields()
+        object.__setattr__(self, "time_ns", time_ns)
+
+    def _freeze_fields(self) -> None:
+        """校验并冻结有时间与无时间更新共有的身份、质量和原值。
+
+        参数:
+            无额外参数；读取当前模型中除time_ns外的全部字段。
+        返回:
+            None: values被独立复制并冻结，其他身份及质量保持原值。
+        异常:
+            TypeError: 身份、标志、来源引用、质量或原值类型不合法。
+            ValueError: 来源不匹配、负身份、ID越界或值字典含空键。
+            MemoryError: 复制失败，调用方不能得到部分构造的模型。
+        副作用:
+            仅在当前待构造模型上安装冻结字典，不访问或伪造时间。
+        """
+        # 两种更新的区别仅为时间需求，不放宽原帧身份或原值契约。
+        require_identifier(self.source, "legacy_update.source")
+        _require_nonnegative_int(self.channel, "channel")
+        _require_nonnegative_int(self.frame_id, "frame_id")
+        _require_nonnegative_int(self.sequence, "sequence")
+        _require_nonnegative_int(self.evaluation_index, "evaluation_index")
+
+        # 四个标志各自来自原帧，不用Python真值转换补齐缺失或整数标志。
+        for field in ("is_extended", "is_fd", "is_remote", "is_error"):
+            if type(getattr(self, field)) is not bool:
+                raise TypeError(f"{field}必须为原生bool")
+        maximum_id = 0x1FFFFFFF if self.is_extended else 0x7FF
+        if self.frame_id > maximum_id:
+            raise ValueError("frame_id超出对应标准帧或扩展帧范围")
+
+        # 引用只核对已有类型和来源身份，不把手工引用当作真实旧求值的证明。
+        if not isinstance(self.source_ref, SourceRef):
+            raise TypeError("source_ref必须为SourceRef")
+        if self.source_ref.source_name != self.source:
+            raise ValueError("source_ref.source_name必须与source一致")
+        if not isinstance(self.quality, QualityFlag):
+            raise TypeError("quality必须为QualityFlag")
+
+        # 边遍历边校验并复制，避免先校验后再遍历时混入未经检查的新值。
+        if type(self.values) not in (dict, MappingProxyType):
+            raise TypeError("values仅接受精确dict或MappingProxyType")
+        copied = {}
+        for key, value in self.values.items():
+            if type(key) is not str:
+                raise TypeError("values的键必须为原生str")
+            if not key:
+                raise ValueError("values的键不能为空")
+            require_scalar(value)
+            copied[key] = value
+
+        # 值均为不可变原生标量，单层独立复制已足够；不深拷贝或改写数值。
+        frozen_values = MappingProxyType(copied)
+        object.__setattr__(self, "values", frozen_values)
+
+
+@dataclass(frozen=True)
+class LegacyUntimedUpdate(LegacyDecodedUpdate):
+    """保存无需时间的固定周期消息求值，复用原更新的完整身份和原值合同。
+
+    time_ns只能显式为None，表示未采集时间；不代表0时刻或无观测数据。
+    sequence与evaluation_index保留实际原序及求值序，其他字段与父类一致。
+    本模型仍是LegacyDecodedUpdate，可交由相同逐消息数值核求值；调用方
+    必须确保没有时间消费者，并且不从本模型构造带时间的贡献或观测范围。
+    """
+
+    time_ns: None  # 显式未采集；必填，禁止借默认0或其他占位满足时间模型。
+
+    def __post_init__(self) -> None:
+        """拒绝任何实数或占位时间，仅执行父类的共有字段校验。
+
+        参数:
+            无额外参数；读取构造字段，time_ns必须为None。
+        返回:
+            None: 原值冻结，身份和质量检查与LegacyDecodedUpdate完全相同。
+        异常:
+            TypeError: time_ns不是None，或共有字段类型不合法。
+            ValueError或MemoryError: 共有身份越界、来源冲突或复制失败。
+        副作用:
+            仅冻结当前模型，不构造虚假时间或修改调用方值字典。
+        """
+        # 调用方不能把带真实时间的输入误报为未采集时间。
+        if self.time_ns is not None:
+            raise TypeError("LegacyUntimedUpdate.time_ns必须为None")
+        self._freeze_fields()
+
+
+class LegacyUpdateOrder:
+    """校验同一会话和来源的逐次求值，不累计原值或维护旧信号缓存。
+
+    session_id和source固定；last_time_ns、last_sequence、
+    last_evaluation_index初始为None，count初始为0。时间和原帧序号不回退，
+    求值序号严格递增且允许间隙。首个更新固定是否带时间，之后禁止混用；
+    无时间模式的last_time_ns始终为None，仅按原序和求值序前进。
+    同一原帧序号还须保留完全相同的时间、
+    通道、ID和四个标志；值、质量及section引用可不同。最后事实保存在一个
+    当前状态tuple中，全部检查和新状态分配完成后才一次替换；拒绝不改状态。
+    """
+
+    def __init__(self, session_id: str, source: str) -> None:
+        """建立一个来源的空顺序状态，不接收或消费任何更新。
+
+        参数:
+            session_id: 沿共享模型规则校验的会话标识。
+            source: 沿共享模型规则校验的来源标识。
+        返回:
+            None: 创建只读身份及初始空状态。
+        异常:
+            TypeError: 会话或来源不是文本。
+            ValueError: 会话或来源不是合法的共享简单标识符。
+        """
+        # 身份只在构造时安装，公开属性不提供可绕过来源检查的赋值入口。
+        self._session_id = require_identifier(session_id, "session_id")
+        self._source = require_identifier(source, "source")
+        self._state = (None, None, None, 0, None)
+
+    @property
+    def session_id(self) -> str:
+        """返回固定会话标识；参数: 无；返回: 原str；异常: 无。"""
+        return self._session_id
+
+    @property
+    def source(self) -> str:
+        """返回固定来源标识；参数: 无；返回: 原str；异常: 无。"""
+        return self._source
+
+    @property
+    def last_time_ns(self) -> int | None:
+        """读取最后接受时间；参数: 无；返回: int或初始None；异常: 无。"""
+        return self._state[0]
+
+    @property
+    def last_sequence(self) -> int | None:
+        """读取最后原帧序号；参数: 无；返回: int或初始None；异常: 无。"""
+        return self._state[1]
+
+    @property
+    def last_evaluation_index(self) -> int | None:
+        """读取最后求值序号；参数: 无；返回: int或初始None；异常: 无。"""
+        return self._state[2]
+
+    @property
+    def count(self) -> int:
+        """读取已接受次数；参数: 无；返回: 非负int；异常: 无。"""
+        return self._state[3]
+
+    def accept(self, update: LegacyDecodedUpdate) -> None:
+        """接受一个完整更新，仅在全部身份及顺序检查成功后提交最后事实。
+
+        参数:
+            update: 已构造的LegacyDecodedUpdate或LegacyUntimedUpdate；
+                同帧可携带不同值快照，同一顺序器禁止混用时间模式。
+        返回:
+            None: 接受成功，count加一，最后事实切换到本次更新。
+        异常:
+            TypeError: update不是LegacyDecodedUpdate。
+            ValueError: 会话、来源不符，时间模式混用，时间或原帧序号回退，求值序号不递增，
+                或同一原帧序号的时间、通道、ID、四个标志出现冲突。
+            MemoryError: 新状态分配失败；旧状态仍保持不变。
+        """
+        # 只接受已验证的更新模型；序号关系不从其他帧对象或原值中猜测。
+        if not isinstance(update, LegacyDecodedUpdate):
+            raise TypeError("update必须为LegacyDecodedUpdate")
+        if update.source != self._source or update.source_ref.session_id != self._session_id:
+            raise ValueError("update必须属于本会话和来源")
+
+        # 当前帧身份不含值、质量或section引用，允许同帧多次真实求值。
+        frame = (
+            update.time_ns, update.channel, update.frame_id,
+            update.is_extended, update.is_fd, update.is_remote, update.is_error,
+        )
+        last_time, last_sequence, last_evaluation, count, last_frame = self._state
+        # count区分空状态和已接受无时间更新；保持原五元状态便于原子复制。
+        if count and (last_time is None) != (update.time_ns is None):
+            raise ValueError("同一顺序器不能混用有时间和无时间更新")
+        if last_time is not None and update.time_ns < last_time:
+            raise ValueError("time_ns不能回退")
+        if last_sequence is not None and update.sequence < last_sequence:
+            raise ValueError("sequence不能回退")
+        if last_evaluation is not None and update.evaluation_index <= last_evaluation:
+            raise ValueError("evaluation_index必须严格递增")
+        if update.sequence == last_sequence and frame != last_frame:
+            raise ValueError("同一sequence的原帧身份必须一致")
+
+        # 先完成计数和tuple分配，再以单一写入提交；拒绝路径不接触已有状态。
+        next_state = (
+            update.time_ns, update.sequence, update.evaluation_index, count + 1, frame,
+        )
+        self._state = next_state

chronaxis/legacy/vendor/sclicer_functions_v1/can_processor.py

@@ -0,0 +1,138 @@
+import ast
+import logging
+
+import can
+import cantools
+
+# 配置日志
+logger = logging.getLogger(__name__)
+
+
+def build_writer(out_path, out_fmt):
+    """
+    根据指定的输出格式和路径，创建对应的 CAN 数据写入器。
+
+    该函数支持三种输出格式：
+    - 'blf'：使用 can.BLFWriter 写入 BLF 格式文件
+    - 'asc'：使用 can.ASCWriter 写入 ASC 格式文件
+    - 'csv'：使用 can.CSVWriter 写入 CSV 格式文件
+
+    参数:
+    out_path (str): 输出文件的路径
+    out_fmt (str): 输出文件的格式，支持 'blf'、'asc'、'csv'
+
+    返回:
+    tuple: 一个包含写入器和路径的元组 (writer, out_path)
+    """
+    if out_fmt == "blf":
+        return can.BLFWriter(out_path), out_path
+    elif out_fmt == "asc":
+        return can.ASCWriter(out_path), out_path
+    elif out_fmt == "csv":
+        # 使用python-can官方的CSVWriter
+        return can.CSVWriter(out_path), out_path
+    else:
+        raise ValueError("format 必须是 blf/asc/csv")
+
+
+def eval_expr(expr, sig_dict):
+    """
+    解析并评估一个表达式，该表达式使用信号字典中的信号值。
+
+    该函数会先对输入的表达式进行语法检查，确保只包含允许的语法节点。
+    接着检查表达式中引用的信号是否都存在于信号字典中，如果有缺失则返回 False。
+    最后使用安全的方式评估表达式，若评估过程中出现异常也返回 False。
+    对于浮点数比较，使用近似比较来解决精度问题。
+
+    参数:
+    expr (str): 需要解析和评估的表达式字符串
+    sig_dict (dict): 信号字典，键为信号名，值为信号值
+
+    返回:
+    bool: 若表达式评估结果为真则返回 True；若表达式语法非法、引用缺失信号或评估出错，返回 False
+    """
+    try:
+        # 定义允许的语法节点集合，限制表达式使用的语法
+        allowed = {ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE,
+                   ast.And, ast.Or, ast.Module, ast.Expr, ast.Expression,
+                   ast.Compare, ast.BinOp, ast.Name, ast.Load, ast.Constant}
+        # 将表达式解析为抽象语法树节点
+        node = ast.parse(expr, mode='eval')
+        # 遍历语法树节点，检查是否存在非法语法
+        for n in ast.walk(node):
+            if type(n) not in allowed:
+                raise ValueError(f"非法语法：{type(n)}")
+        # 缺失信号直接返回 False
+        for name in ast.walk(node):
+            if isinstance(name, ast.Name) and name.id not in sig_dict:
+                return False
+        
+        # 处理浮点数精度问题：对信号字典中的浮点数进行四舍五入处理
+        # 保留足够的小数位数以保持精度，同时消除精度误差
+        processed_sig_dict = {}
+        for k, v in sig_dict.items():
+            if isinstance(v, float):
+                # 保留10位小数，足够精确且能消除大部分精度误差
+                processed_sig_dict[k] = round(v, 10)
+            else:
+                processed_sig_dict[k] = v
+        
+        # 筛选出信号字典中数值类型或布尔类型的值，构建评估环境
+        env = {k: v for k, v in processed_sig_dict.items() if isinstance(v, (int, float, bool))}
+        logger.debug(f"原始信号字典：{sig_dict}")
+        logger.debug(f"处理后信号字典：{processed_sig_dict}")
+        # 编译并评估表达式
+        return eval(compile(node, '<string>', 'eval'), {"__builtins__": {}}, env)
+    except Exception as e:
+        logger.debug("eval_expr 异常：%s", e)
+        return False
+
+
+def parse_frame(msg, db):
+    """
+    从单帧CAN报文解析出全部信号值。
+
+    该函数尝试使用提供的数据库对象解码CAN报文，
+    解析出报文中包含的所有信号及其对应的值。
+    如果解析失败，返回空字典。
+
+    参数:
+    msg (can.Message): CAN报文对象，包含报文ID和数据
+    db (can.Database): CAN数据库对象，用于信号解码
+
+    返回:
+    dict: 包含信号名和对应值的字典；如果解析失败，返回空字典
+
+    异常:
+    无显式异常抛出，所有异常都会被捕获并返回空字典
+    """
+    try:
+        vals = db.decode_message(msg.arbitration_id, msg.data, decode_choices=False, allow_truncated=True)
+        return vals
+    except Exception:
+        return {}
+
+
+def get_signals_for_message_id(db, message_id):
+    """
+    获取指定CAN报文ID包含的所有信号名称。
+
+    该函数从数据库中查找指定ID的CAN报文定义，
+    并返回该报文中包含的所有信号名称集合。
+    如果未找到对应报文，返回空集合。
+
+    参数:
+    db (can.Database): CAN数据库对象，包含报文和信号定义
+    message_id (int): CAN报文ID
+
+    返回:
+    set: 包含信号名称的集合；如果未找到报文，返回空集合
+
+    异常:
+    无显式异常抛出，所有异常都会被捕获并返回空集合
+    """
+    try:
+        message = db.get_message_by_frame_id(message_id)
+        return {signal.name for signal in message.signals}
+    except:
+        return set()

chronaxis/legacy/vendor/sclicer_functions_v1/file_processor.py

@@ -0,0 +1,218 @@
+import csv
+import logging
+import os
+from datetime import datetime, timedelta
+from natsort import natsorted
+
+import can
+from utils import ASCReaderForCANFD
+
+# 配置日志
+logger = logging.getLogger(__name__)
+
+def iter_frames(path):
+    """
+    该函数是一个统一的生成器，用于按时间顺序逐个生成 can.Message 对象。
+    支持处理单个文件或整个文件夹，具体功能如下：
+
+    1. 当输入为单个文件时：
+       - 检查文件扩展名，仅支持 .blf、.asc 和 .csv 格式
+       - 若为 .blf 文件，使用 can.BLFReader 读取并生成消息
+       - 若为 .asc 文件，使用 can.ASCReader 读取并生成消息
+       - 若为 .csv 文件，使用 can.CSVReader 读取并生成消息
+       - 若文件格式不支持，抛出 ValueError 异常
+
+    2. 当输入为文件夹时：
+       - 筛选出文件夹内所有 .blf、.asc 和 .csv 文件，并按自然排序
+       - 递归调用本函数处理每个文件，逐个生成消息
+
+    3. 若输入既不是文件也不是文件夹，抛出 FileNotFoundError 异常
+
+    参数:
+    path (str): 输入的文件路径或文件夹路径
+
+    返回:
+    generator: 按时间顺序生成 can.Message 对象的生成器
+
+    异常:
+    ValueError: 当输入文件的格式不是 .blf、.asc 或 .csv 时抛出
+    FileNotFoundError: 当输入路径既不是文件也不是文件夹时抛出
+    """
+    if os.path.isfile(path):
+        ext = os.path.splitext(path)[1].lower()
+        if ext == '.blf':
+            for m in can.BLFReader(path): yield m
+        elif ext == '.asc':
+            try:
+                for m in can.ASCReader(path,relative_timestamp=False): yield m
+            except Exception:
+                for m in ASCReaderForCANFD(path, relative_timestamp=False, format_hint='auto'): yield m
+        elif ext == '.csv':
+            # 使用python-can官方的CSVReader读取CSV文件
+            # data需为base64编码
+            for m in can.CSVReader(path): yield m
+        else:
+            raise ValueError("仅支持 blf/asc/csv(data列为base64编码)")
+    elif os.path.isdir(path):
+        files = natsorted([os.path.join(path, f) for f in os.listdir(path)
+                           if f.lower().endswith(('.blf', '.asc', '.csv'))])
+        for fp in files:
+            for m in iter_frames(fp): yield m
+    else:
+        raise FileNotFoundError("输入必须是文件或文件夹")
+
+
+def check_csv_header(file_path):
+    """
+    前置检查：csv必须含timestamp/arbitration_id/data三列，缺失则抛异常
+    参数:
+    file_path (str): csv文件路径
+    返回:
+    bool: 若文件头包含timestamp/arbitration_id/data三列则返回True
+    异常:
+    ValueError: 当文件头缺失timestamp/arbitration_id/data三列时抛出
+    """
+    with open(file_path, newline='', encoding='utf-8') as f:
+        reader = csv.reader(f)
+        header = [h.lower() for h in next(reader)]
+    required = {'timestamp', 'arbitration_id', 'data'}
+    miss = required - set(header)
+    if miss:
+        raise ValueError(f"CSV 缺失列 {miss}")
+    return True
+
+
+def merge_convert(inputs, out_base, out_fmt, db):
+    """
+    合并输入文件/文件夹→指定格式，csv前置检查
+    参数:
+    inputs (list): 输入文件/文件夹路径列表
+    out_base (str): 输出文件基础名（不含扩展名）
+    out_fmt (str): 输出格式，可选"blf"/"asc"/"csv"
+    db (can.Database): 数据库对象，用于解析报文
+    返回:
+    None
+    异常:
+    ValueError: 当输入文件为csv格式且缺失timestamp/id/data三列时抛出
+    FileNotFoundError: 当输入路径既不是文件也不是文件夹时抛出
+    """
+    from can_processor import build_writer
+    
+    ext = {"blf": ".blf", "asc": ".asc", "csv": ".csv"}[out_fmt]
+    out_path = out_base + ext
+    # CSV 前置检查（单文件也检查）
+    if out_fmt == "csv":
+        for fp in inputs:
+            if fp.lower().endswith('.csv'): check_csv_header(fp)
+
+    # 使用build_writer创建统一的写入器
+    writer, _ = build_writer(out_path, out_fmt)
+
+    for fp in inputs:
+        for msg in iter_frames(fp):
+            writer.on_message_received(msg)
+    
+    # 停止写入器
+    writer.stop()
+    logger.info(f"合并转换完成→{out_path}")
+
+
+def output_suffix(path):
+    """
+    生成带时间戳的输出基础名
+    参数:
+    path (str): 输入文件路径（不含扩展名）
+    返回:
+    str: 带时间戳的输出基础名（不含扩展名）
+    """
+    ts = datetime.now().strftime("%Y%m%d%H%M%S")
+    base, ext = os.path.splitext(path)
+    return base + f"_{ts}"
+
+
+def fix_asc_header(file_path, utc_offset=0):
+    """
+    修复ASC文件头部时间信息
+    将文件前4行从：
+    date Tue Oct 14 16:11:16.648 2025
+    base hex  timestamps absolute
+    internal events logged
+    Begin Triggerblock Tue Jun 10 22:35:34.949 2025
+    
+    变为：
+    date Tue Jun 10 22:35:34.949 2025
+    base hex  timestamps absolute
+    
+    参数:
+    file_path (str): ASC文件路径
+    utc_offset (int): UTC偏移量(小时)，如果为x，则从date时间减去x小时
+    
+    返回:
+    None
+    """
+    if not file_path.lower().endswith('.asc'):
+        logger.warning(f"{file_path} 不是ASC文件，跳过头部修复")
+        return
+        
+    try:
+        # 读取文件内容
+        with open(file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+            
+        # 查找首行date的时间信息
+        header_date_str = None
+        if len(lines) > 0 and lines[0].startswith('date '):
+            header_date_str = lines[0][len('date '):].strip()
+        
+        # 查找Begin Triggerblock行，提取时间信息
+        trigger_time_str = None
+        for line in lines:
+            if line.startswith('Begin Triggerblock '):
+                trigger_time_str = line[len('Begin Triggerblock '):].strip()
+                break
+                
+        if not trigger_time_str:
+            logger.warning(f"在文件{file_path}中未找到Begin Triggerblock行，跳过头部修复")
+            return
+            
+        # 解析时间字符串
+        # 时间格式：Tue Jun 10 22:35:34.949 2025
+        try:
+            trigger_time = datetime.strptime(trigger_time_str, '%a %b %d %H:%M:%S.%f %Y')
+            
+            # 只有当Begin Triggerblock的时间早于header的date时间时才执行修复
+            if header_date_str:
+                try:
+                    header_date = datetime.strptime(header_date_str, '%a %b %d %H:%M:%S.%f %Y')
+                    if trigger_time >= header_date:
+                        logger.info(f"Begin Triggerblock时间({trigger_time_str})不早于header的date时间({header_date_str})，无需修复")
+                        return
+                except ValueError:
+                    logger.warning(f"无法解析header的date时间字符串: {header_date_str}，继续修复")
+            
+            # 应用UTC偏移
+            if utc_offset != 0:
+                trigger_time = trigger_time - timedelta(hours=utc_offset)
+                # 重新格式化时间字符串
+                trigger_time_str = trigger_time.strftime('%a %b %d %H:%M:%S.%f')[:-3] + ' ' + str(trigger_time.year)
+        except ValueError:
+            logger.error(f"无法解析时间字符串: {trigger_time_str}")
+            return
+            
+        # 构建新的文件内容
+        new_lines = []
+        new_lines.append(f'date {trigger_time_str}\n')
+        new_lines.append('base hex  timestamps absolute\n')
+        
+        # 跳过原始文件的前4行，添加剩余内容
+        if len(lines) > 4:
+            new_lines.extend(lines[4:])
+            
+        # 写回文件
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.writelines(new_lines)
+            
+        logger.info(f"已修复文件头部时间: {file_path}")
+        
+    except Exception as e:
+        logger.error(f"修复ASC文件头部时出错: {str(e)}")