chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/migration/publication.py

@@ -0,0 +1,230 @@
+"""在新目标旁发布导入原文与报告，成功转换的计划最后才安装。
+
+输入是LegacyImportResult和.json目标，可显式附INI/mapping源路径；输出固定
+LegacyImportFiles。三个文件先写入同父UUID临时文件，flush及实际close成功后，
+按原文、报告、计划顺序用Windows不覆盖rename安装。转换失败只安装前两件，
+报告status仍表示转换结果，不能据此宣称分析已运行或数据已经验证。
+
+目标、解析后的RefProjects边界和源路径冲突在创建目录前检查；安装仍以真实
+no-replace操作防竞态，不依赖预先exists检查或os.replace。只声明已验证的
+Windows文件安装语义，其他平台在写入前明确拒绝。目录本身不作跨文件原子
+事务，已安装sidecar在后续失败时保留；计划是最后的提交点。
+
+小owner仅持本次真实FD和已独占创建的三个UUID临时文件。失败不吞原取消、
+MemoryError或I/O异常；清理副错附note，异常上的
+legacy_import_publication_cleanup_owner.close()可重试关闭并移除自有临时文件。
+不递归删除，不删除已发布sidecar、用户目标或原配置，也不配置日志或运行旧链。
+"""
+
+from dataclasses import dataclass
+from hashlib import sha256
+import json
+import os
+from pathlib import Path
+from types import MappingProxyType
+from uuid import uuid4
+
+from ..planning import AnalysisPlan
+from .models import LegacyImportReport, LegacyImportResult
+
+
+@dataclass(frozen=True)
+class LegacyImportFiles:
+    """保存词法绝对发布路径；plan为None时只有原文和失败转换报告。"""
+
+    plan: Path | None
+    original: Path
+    report: Path
+
+
+def _mapping_json(value):
+    """仅展开计划固定MappingProxy，不反射任意对象或调用其序列化方法。
+
+    参数: value为JSON编码器遇到的对象。返回: 原生dict副本。
+    异常: TypeError为非MappingProxyType；MemoryError保持原生异常。
+    """
+    if type(value) is MappingProxyType:
+        return dict(value)
+    raise TypeError('导入计划JSON仅允许固定MappingProxyType扩展')
+
+
+def _require_result(result):
+    """核公开转换结果与原bytes/计划身份一致，拒绝失败结果携带部分计划。
+
+    参数: result为LegacyImportResult。返回: None。
+    异常: TypeError为非固定模型；ValueError为状态、原SHA或计划身份不一致。
+    """
+    if (type(result) is not LegacyImportResult or type(result.report) is not LegacyImportReport
+            or type(result.original_ini) is not bytes):
+        raise TypeError('发布需要LegacyImportResult、LegacyImportReport及原生INI bytes')
+    report = result.report
+    if report.source_sha256 != sha256(result.original_ini).hexdigest():
+        raise ValueError('发布原INI bytes与转换报告SHA不一致')
+    if result.plan is None:
+        if report.status != 'failed' or report.plan_identity is not None:
+            raise ValueError('无计划时只允许失败转换报告，plan_identity必须为None')
+    elif (type(result.plan) is not AnalysisPlan or report.status != 'success'
+            or report.plan_identity != result.plan.identity):
+        raise ValueError('成功转换报告必须关联同一完整AnalysisPlan')
+
+
+def _targets(output_path, source_paths):
+    """先核词法目标、实际保护边界及源冲突，不创建任何输出。
+
+    参数: output_path为.json文件Path/str；source_paths为INI及mapping的Path/str tuple。
+    返回: (计划、原文、报告)三个绝对Path，按计划路径派生固定后缀。
+    异常: TypeError为路径容器；ValueError为后缀/Ref/源冲突；FileExistsError为任一已有目标。
+    """
+    if not isinstance(output_path, (Path, str)) or type(source_paths) is not tuple:
+        raise TypeError('output_path需要Path/str，source_paths需要tuple')
+    if any(not isinstance(path, (Path, str)) for path in source_paths):
+        raise TypeError('source_paths每项需要Path/str')
+    target = Path(output_path).absolute()
+    if target.suffix != '.json':
+        raise ValueError('导入计划输出必须使用.json后缀')
+    targets = (target, target.with_name(target.stem + '.original.ini'),
+        target.with_name(target.stem + '.migration-report.json'))
+    # resolve仅用于真实位置核对；安装仍使用原词法路径，已有悬空symlink也必须拒绝。
+    project = Path(__file__).absolute().parents[3]
+    protected = (project / 'RefProjects').resolve()
+    resolved = tuple(path.resolve() for path in targets)
+    sources = tuple(Path(path).resolve() for path in source_paths)
+    for path, actual in zip(targets, resolved):
+        if actual.is_relative_to(protected) or any(part.casefold() == 'refprojects' for part in actual.parts):
+            raise ValueError('导入输出禁止位于RefProjects')
+        if actual in sources:
+            raise ValueError('导入输出不能与原INI或mapping配置同路径')
+        try:
+            path.lstat()
+        except FileNotFoundError:
+            continue
+        raise FileExistsError('导入目标已存在，禁止覆盖：' + str(path))
+    return targets
+
+
+class _PublicationOwner:
+    """仅持本次独占临时文件及一个真实FD，不接管源文件或已安装目标。"""
+
+    def __init__(self, targets):
+        """先安装全部实际责任槽，尚不创建临时文件。
+
+        参数: targets为三个已检查的绝对Path。返回: 新owner。异常: 原内存/UUID错误传播。
+        """
+        self._targets = targets
+        self._token = uuid4().hex
+        self._temporaries = [None, None, None]
+        self._handle = self._opening_path = self._opening_index = None
+        self.closed = False
+
+    def _close_handle(self):
+        """关闭当前真实FD，失败时保持同一对象及临时路径可恢复。
+
+        参数: 无。返回: None。异常: 原close错误；未真实关闭则OSError。
+        """
+        if self._handle is not None:
+            # FD已返回即证明本次独占创建，补齐open返回与临时槽安装之间的责任窗口。
+            if self._opening_path is not None:
+                self._temporaries[self._opening_index] = self._opening_path
+            self._handle.close()
+            if not self._handle.closed:
+                raise OSError('导入临时文件FD尚未关闭')
+            self._handle = None
+        self._opening_path = self._opening_index = None
+
+    def write(self, index, value, *, original=False):
+        """独占创建一个临时文件，写完flush且真实close后才允许安装。
+
+        参数: index选择原文/报告/计划槽；value为原bytes或固定JSON树；original选择二进制原文。
+        返回: None。异常: 原open/write/flush/close/JSON/内存或取消错误，不隐式重试写入。
+        """
+        target = self._targets[index]
+        temporary = target.parent / ('.' + target.name + '.import-' + self._token + '.tmp')
+        self._opening_path, self._opening_index = temporary, index
+        # 只在open成功返回真实FD后登记文件所有权；独占失败不能删除碰巧已有的UUID目标。
+        if original:
+            self._handle = temporary.open('xb')
+        else:
+            self._handle = temporary.open('x', encoding='utf-8', newline='\n')
+        self._temporaries[index] = temporary
+        if original:
+            if self._handle.write(value) != len(value):
+                raise OSError('原INI临时文件写入不完整')
+        else:
+            # 计划参数对象的声明顺序参与MessageDeclarations身份；不能为排版排序改写。
+            # 报告不承担该声明语义，仍沿原规范键序；公式AST和核心身份算法均不改。
+            json.dump(value, self._handle, ensure_ascii=False, allow_nan=False,
+                sort_keys=index != 0, indent=2, default=_mapping_json)
+            self._handle.write('\n')
+        self._handle.flush()
+        self._close_handle()
+
+    def install(self, index):
+        """用Windows真实不覆盖rename安装，成功后只撤本临时槽。
+
+        参数: index为已完整关闭的临时文件槽。返回: None。
+        异常: 原rename错误；不能用exists预检查取代最终no-replace。
+        """
+        os.rename(self._temporaries[index], self._targets[index])
+        # rename已是提交事实，之后不写状态文件、不触碰目标或执行额外文件清理。
+        self._temporaries[index] = None
+
+    def close(self):
+        """可重试关闭FD并逐个删除自有UUID临时文件，保留全部已安装sidecar。
+
+        参数: 无。返回: None，成功后幂等。异常: 原close/unlink错误附同一最高owner。
+        """
+        if self.closed:
+            return
+        try:
+            self._close_handle()
+            for index, temporary in enumerate(self._temporaries):
+                if temporary is not None:
+                    try:
+                        temporary.unlink()
+                    except FileNotFoundError:
+                        pass
+                    self._temporaries[index] = None
+            self.closed = True
+        except BaseException as error:
+            error.legacy_import_publication_cleanup_owner = self
+            raise
+
+
+def write_legacy_import(result: LegacyImportResult, output_path, *, source_paths=()) -> LegacyImportFiles:
+    """发布原配置及转换报告，只有完整成功转换才在最后安装计划。
+
+    参数: result为固定转换结果；output_path为新.json目标；source_paths可显式提供
+        原INI/mapping路径tuple供CLI防止同源别名冲突。
+    返回: LegacyImportFiles，均为绝对Path，转换失败时plan=None。
+    异常: 类型/配置错误、已有目标、Ref边界及系统I/O错误保持原异常；非Windows为
+        NotImplementedError。KI/MemoryError原样；清理副错仅附note，最高恢复owner留在原错上。
+    副作用: 只创建目标父目录和三个自有临时文件；失败可保已装sidecar，绝不覆盖或删用户文件。
+    """
+    _require_result(result)
+    targets = _targets(output_path, source_paths)
+    if os.name != 'nt':
+        raise NotImplementedError('导入文件发布目前只验证Windows不覆盖安装')
+    files = LegacyImportFiles(targets[0] if result.plan is not None else None, targets[1], targets[2])
+    owner = _PublicationOwner(targets)
+    try:
+        # 所有内容先写完并关闭；有计划时也只在两个sidecar安装成功之后提交计划。
+        targets[0].parent.mkdir(parents=True, exist_ok=True)
+        owner.write(1, result.original_ini, original=True)
+        owner.write(2, result.report.to_dict())
+        if result.plan is not None:
+            owner.write(0, result.plan.raw_config)
+        owner.install(1)
+        owner.install(2)
+        if result.plan is not None:
+            owner.install(0)
+        # 所有临时槽已由rename撤销，无需在提交点后再执行可能失败的I/O。
+        owner.closed = True
+        return files
+    except BaseException as error:
+        error.legacy_import_publication_cleanup_owner = owner
+        try:
+            owner.close()
+        except BaseException as cleanup:
+            error.add_note('导入发布清理附加失败：' + type(cleanup).__name__
+                + '；调用legacy_import_publication_cleanup_owner.close()恢复')
+        raise

chronaxis/migration/sclicer.py

@@ -0,0 +1,241 @@
+"""把受支持Sclicer段转换为新活动或固定窗口，完整报告边界差异。
+
+输入是已定位INI、显式mapping及本次独立分析字典；输出只修改该新字典的
+rules/windows并追加字段去向和警告。不执行旧触发器、eval或来源I/O。
+single的post只作为exit_delay，start_only的post不再次延长固定duration。
+显式sclicer_slope使用完整window_delta和触发点周围的pre/post窗口，差异写入报告。
+显式sclicer_start_end还要求mapping确认新开始/结束含义，旧post不附加。
+"""
+
+import ast
+from decimal import Decimal, InvalidOperation
+
+from ..timebase import parse_duration
+from .ini import field_path, locate, mark, problem
+from .models import LegacyImportIssue
+from .slope import slope_rule
+from .start_end import start_end_options
+
+
+def _ini_problem(fields, section, key, code, message, *, headers=None):
+    """附原字段行列后拒绝，缺失字段回退到原段头。
+
+    参数: fields/section/key为字段定位，code/message为原因；headers为可选原段行号。
+    返回: 无。异常: ImportProblem；不为缺失字段编造一个不存在的字段行。
+    """
+    line, column = locate(fields, section, key)
+    if line is None and headers is not None:
+        line, column = headers[section], 1
+    problem(code, 'ini', field_path(section, key), message, line, column)
+
+
+def _seconds(parser, fields, section, key, default, *, positive=False):
+    """把旧秒数转换为显式精确时长，不猜工程参数或接受NaN。
+
+    参数: parser/fields/section/key为原定位；default为已审旧默认；positive限定正值。
+    返回: 带s的时长文本。异常: ImportProblem为非法或不能精确表示的时长。
+    """
+    value = parser.get(section, key, fallback=default, raw=True)
+    try:
+        number = Decimal(value)
+        if not number.is_finite() or number < 0 or positive and number == 0:
+            raise ValueError('时长必须有限且非负，固定窗口须大于零')
+        # 保留紧凑指数表示；由有界时间解析器检查范围，不能先展开巨量零。
+        result = str(number) + 's'
+        parse_duration(result)
+    except (InvalidOperation, ValueError, OverflowError) as error:
+        _ini_problem(fields, section, key, 'invalid_duration', str(error))
+    return result
+
+
+def _boolean(parser, fields, section, key, default):
+    """沿ConfigParser旧布尔词表读取开关；参数: 原定位和默认；返回: bool；异常: ImportProblem。"""
+    try:
+        return parser.getboolean(section, key, fallback=default)
+    except ValueError as error:
+        _ini_problem(fields, section, key, 'invalid_boolean', str(error))
+
+
+class _AliasTransformer(ast.NodeTransformer):
+    """只替换AST Name，保字符串literal、原大小写和运算结合顺序。"""
+
+    def __init__(self, aliases, fields, section, key):
+        """保本次显式别名表；参数: 别名及原表达式定位；返回: None；异常: 无。"""
+        self.aliases, self.fields, self.section, self.key = aliases, fields, section, key
+
+    def visit_Name(self, node):
+        """替换一个字段引用；参数: Name节点；返回: 新Name；异常: ImportProblem为缺映射。"""
+        if node.id not in self.aliases:
+            _ini_problem(self.fields, self.section, self.key, 'missing_alias', '缺少原名称的显式alias：' + node.id)
+        return ast.copy_location(ast.Name(id=self.aliases[node.id], ctx=ast.Load()), node)
+
+    def visit_Call(self, node):
+        """仅保现有DSL注册函数，不把函数名当字段重写。
+
+        参数: Call节点。返回: 原节点和改写后的参数。异常: ImportProblem为任意调用。
+        """
+        if not isinstance(node.func, ast.Name) or node.func.id not in ('abs', 'isclose'):
+            _ini_problem(self.fields, self.section, self.key, 'unsafe_expression', '禁止任意调用或属性调用')
+        node.args = [self.visit(item) for item in node.args]
+        node.keywords = [self.visit(item) for item in node.keywords]
+        return node
+
+
+def _expression(text, aliases, fields, section, key):
+    """解析白名单AST并替换Name，最终类型/单位仍交公开计划检查。
+
+    参数: 原表达式、显式aliases和原位置。返回: 新DSL文本。
+    异常: ImportProblem为危险语法、旧slope或缺映射；取消和资源错误不吞。
+    """
+    if text.lstrip().startswith(('_slope_', '_slope2_')):
+        _ini_problem(fields, section, key, 'unsupported_slope', 'M2不支持slope/slope2配置')
+    try:
+        tree = ast.parse(text, mode='eval')
+    except SyntaxError as error:
+        _ini_problem(fields, section, key, 'invalid_expression', str(error))
+    allowed = (ast.Expression, ast.Constant, ast.Name, ast.Load, ast.BinOp, ast.UnaryOp,
+               ast.BoolOp, ast.Compare, ast.Call, ast.keyword, ast.Add, ast.Sub, ast.Mult,
+               ast.Div, ast.UAdd, ast.USub, ast.Not, ast.And, ast.Or, ast.Eq, ast.NotEq,
+               ast.Lt, ast.LtE, ast.Gt, ast.GtE)
+    for node in ast.walk(tree):
+        if not isinstance(node, allowed):
+            _ini_problem(fields, section, key, 'unsafe_expression', '不支持AST节点：' + type(node).__name__)
+    # 转换只作用本次新AST；字符串和包含另一名称的标识符不会误替换。
+    tree = _AliasTransformer(aliases, fields, section, key).visit(tree)
+    return ast.unparse(ast.fix_missing_locations(tree))
+
+
+def convert_sclicer(parser, headers, mapping, analysis, fields, issues, mode):
+    """整份转换显式选择的Sclicer模式，遇一项不支持便拒绝整个计划。
+
+    参数: 已解析INI/头部定位、mapping、新analysis、局部报告列表和公开mode。
+    返回: None；新rules/windows按原段序填充。异常: ImportProblem为语义问题。
+    """
+    triggers = [name for name in parser.sections() if name.startswith('TRIGGER_')]
+    for section in parser.sections():
+        if section not in ('INPUT', 'OUTPUT') and section not in triggers:
+            problem('unsupported_section', 'ini', '[' + section + ']', '未知或未支持的INI段', headers[section], 1)
+    if not triggers:
+        problem('missing_trigger', 'ini', '$', '至少需要一个TRIGGER_段')
+    if set(mapping['sections']) != set(triggers):
+        problem('section_mapping_mismatch', 'mapping', '$.sections', 'sections必须恰好映射全部原TRIGGER_段')
+    # I/O必须显式来自mapping；保原字段并报告ASC显示项与新输出的差异。
+    catalog = {'INPUT': ('msg_path', 'dbc_path'),
+               'OUTPUT': ('slice', 'log', 'format', 'merge', 'utc', 'msg_path')}
+    for section, keys in catalog.items():
+        if not parser.has_section(section):
+            continue
+        for key in parser.options(section):
+            if key not in keys:
+                _ini_problem(fields, section, key, 'unknown_option', '未知I/O字段')
+            mark(fields, section, key, '$.analysis.sources' if section == 'INPUT' else '$.analysis.outputs',
+                 'replaced', '旧I/O由explicit_mapping完整替代；原字段仅保审计，不执行旧输出')
+    if parser.has_section('OUTPUT'):
+        if not _boolean(parser, fields, 'OUTPUT', 'slice', True):
+            _ini_problem(fields, 'OUTPUT', 'slice', 'unsupported_slice_disabled', 'slice=false不能转换为分析窗口成功')
+        if _boolean(parser, fields, 'OUTPUT', 'merge', False):
+            _ini_problem(fields, 'OUTPUT', 'merge', 'unsupported_merge', '旧merge=true未支持')
+        _boolean(parser, fields, 'OUTPUT', 'log', True)
+        if parser.get('OUTPUT', 'format', fallback='asc').lower() not in ('asc', 'blf'):
+            _ini_problem(fields, 'OUTPUT', 'format', 'unsupported_output_format', '未知旧原始输出格式')
+        try:
+            parser.getint('OUTPUT', 'utc', fallback=0)
+        except ValueError as error:
+            _ini_problem(fields, 'OUTPUT', 'utc', 'invalid_utc', str(error))
+    issues.append(LegacyImportIssue('explicit_io_mapping', 'mapping', '$.analysis',
+        '来源与输出完全采用显式mapping；OUTPUT.utc仅是旧ASC显示参数，不转换来源时钟', level='warning'))
+    issues.append(LegacyImportIssue('unknown_ttl_difference', 'plan', '$.signals',
+        '新分析使用显式有限valid_for及UNKNOWN；旧逐帧缺值/缓存行为不据此宣称等价', level='warning'))
+    issues.append(LegacyImportIssue('comparison_rounding_difference', 'plan', '$.rules',
+        '旧eval_expr先对float值round(v,10)再比较；新条件使用原值和typed数值政策，不隐式复现该舍入', level='warning'))
+    issues.append(LegacyImportIssue('raw_trigger_duplicate_difference', 'plan', '$.outputs',
+        'LC02旧触发帧可能先随pre缓冲写出后再次写入；本导入不修改旧writer，不宣称原始输出帧唯一性等价或该缺陷已修复',
+        level='warning'))
+    slope_mode = mode == 'sclicer_slope'
+    start_end_mode = mode == 'sclicer_start_end'
+    expected_mode = 'single' if slope_mode else mode.removeprefix('sclicer_')
+    analysis['rules'], analysis['windows'] = [], []
+    for section in triggers:
+        old_mode = parser.get(section, 'mode', fallback=None)
+        if old_mode is None:
+            _ini_problem(fields, section, 'mode', 'missing_option', '缺少原mode字段', headers=headers)
+        if old_mode != expected_mode:
+            _ini_problem(fields, section, 'mode', 'unsupported_mode', '原模式必须全部为' + expected_mode + '；不跳过其他模式或混合段')
+        keys = ('mode', 'pre_sec', 'post_sec', 'expr') if old_mode == 'single' else (
+                'mode', 'pre_sec', 'post_sec', 'start_expr', 'duration_sec')
+        if start_end_mode:
+            keys += ('end_expr',)
+        for key in parser.options(section):
+            if key not in keys:
+                _ini_problem(fields, section, key, 'unknown_option', '此模式不支持该字段')
+        selected = mapping['sections'][section]
+        if not slope_mode and not start_end_mode and (type(selected) is not dict or set(selected) != {'name', 'window'}):
+            problem('invalid_section_mapping', 'mapping', '$.sections.' + section, '段映射必须恰含name/window')
+        if slope_mode:
+            # 专用解析器先核段映射，之后才能安全取id；普通single仍明确拒绝旧slope串。
+            if not parser.has_option(section, 'expr'):
+                _ini_problem(fields, section, 'expr', 'missing_option', '缺少原slope表达式', headers=headers)
+            slope = slope_rule(parser.get(section, 'expr', raw=True, fallback=''),
+                               mapping['aliases'], selected, fields, section, issues)
+        if start_end_mode:
+            options = start_end_options(parser, fields, section, selected, issues)
+        rule_id, window_id = selected['name'], selected['window']
+        pre = _seconds(parser, fields, section, 'pre_sec', '5')
+        post = _seconds(parser, fields, section, 'post_sec', '3')
+        missing_defaults = [key for key in ('pre_sec', 'post_sec') if not parser.has_option(section, key)]
+        if old_mode in ('start_only', 'start_end') and not parser.has_option(section, 'duration_sec'):
+            missing_defaults.append('duration_sec')
+        if missing_defaults:
+            issues.append(LegacyImportIssue('old_defaults_applied', 'ini', '[' + section + ']',
+                '沿已审旧默认：' + ', '.join(missing_defaults) + '；pre=5s/post=3s/start_only duration=10s/start_end duration=-1（不限时）',
+                headers[section], 1, 'warning'))
+        key = 'expr' if old_mode == 'single' else 'start_expr'
+        if not parser.has_option(section, key):
+            _ini_problem(fields, section, key, 'missing_option', '缺少原条件表达式', headers=headers)
+        condition = None if slope_mode else _expression(
+            parser.get(section, key, raw=True), mapping['aliases'], fields, section, key)
+        index = len(analysis['rules'])
+        rule_path, window_path = f'$.rules[{index}]', f'$.windows[{index}]'
+        if slope_mode:
+            rule = slope
+            window = {'name': window_id, 'rule': rule_id, 'anchor': 'point', 'pre': pre,
+                      'post': post, 'merge': 'none'}
+        elif start_end_mode:
+            if not parser.has_option(section, 'end_expr'):
+                _ini_problem(fields, section, 'end_expr', 'missing_option', '缺少原结束条件', headers=headers)
+            end_condition = _expression(parser.get(section, 'end_expr', raw=True), mapping['aliases'], fields, section, 'end_expr')
+            rule = dict(name=rule_id, rule_type='start_end', start_condition=condition, end_condition=end_condition, **options)
+            window = dict(name=window_id, rule=rule_id, anchor='activity', pre=pre, post='0s', merge='none')
+            mark(fields, section, 'end_expr', rule_path + '.end_condition')
+            mark(fields, section, 'duration_sec', rule_path + '.timeout')
+        elif old_mode == 'single':
+            rule = {'name': rule_id, 'rule_type': 'condition_duration', 'condition': condition, 'minimum_duration': '0s', 'selection_origin': 'onset'}
+            window = {'name': window_id, 'rule': rule_id, 'anchor': 'activity', 'pre': pre,
+                      'post': '0s', 'merge': 'exit_delay', 'exit_delay': post}
+            issues.append(LegacyImportIssue('single_deadline_difference', 'ini', '[' + section + ']',
+                '活动立即按FALSE/UNKNOWN结束；片段使用精确exit_delay，区别于旧等待下一帧且严格超过post关闭',
+                headers[section], 1, 'warning'))
+        else:
+            duration = _seconds(parser, fields, section, 'duration_sec', '10', positive=True)
+            rule = {'name': rule_id, 'rule_type': 'start_only', 'condition': condition,
+                    'window_duration': duration, 'emit_initial': True}
+            window = {'name': window_id, 'rule': rule_id, 'anchor': 'point', 'pre': pre,
+                      'post': duration, 'merge': 'none'}
+            mark(fields, section, 'duration_sec', rule_path + '.window_duration')
+            issues.append(LegacyImportIssue('start_only_edge_difference', 'ini', '[' + section + ']',
+                '采用真实边沿和固定抑制窗；emit_initial=true，旧post不叠加，不声称修复旧last_ts缺陷或重现逐帧锁存',
+                headers[section], 1, 'warning'))
+        analysis['rules'].append(rule)
+        analysis['windows'].append(window)
+        mark(fields, section, 'mode', rule_path + '.rule_type')
+        mark(fields, section, key, rule_path if slope_mode else rule_path + ('.start_condition' if start_end_mode else '.condition'))
+        mark(fields, section, 'pre_sec', window_path + '.pre')
+        if slope_mode:
+            mark(fields, section, 'post_sec', window_path + '.post', message='触发点后的固定长度，不模拟旧退出计时')
+            continue
+        if start_end_mode:
+            mark(fields, section, 'post_sec', None, 'replaced', '旧start_end未使用post，不延长新活动或片段')
+            continue
+        mark(fields, section, 'post_sec', window_path + '.exit_delay' if old_mode == 'single' else None,
+             'mapped' if old_mode == 'single' else 'replaced',
+             'single退出延迟，不再叠加post' if old_mode == 'single' else 'start_only使用duration_sec，原post不叠加')

chronaxis/migration/slope.py

@@ -0,0 +1,78 @@
+"""把旧 slope 字符串拆为明确的完整窗口规则，不执行旧配置。
+
+输入为一个原表达式、显式名称映射和该段的迁移选择；输出 window_delta
+字段及可定位的差异报告。先识别固定前缀，再从右侧取阈值，剩余原信号名
+必须完整命中 aliases，因此信号名可以包含下划线。此模块不读数据或 DBC，
+不修复旧构造器，也不把完整窗口计算声称为旧样本口径的逐帧等价实现。
+"""
+
+from decimal import Decimal, InvalidOperation
+import math
+import re
+
+from ..timebase import parse_duration
+from .ini import field_path, locate, problem
+from .models import LegacyImportIssue
+
+
+def slope_rule(text, aliases, selected, fields, section, issues):
+    """按显式迁移选择生成一个完整窗口规则。
+
+    参数: text 为原 expr；aliases 为完整旧名称到新别名的映射；selected 为
+    段映射；fields/section 定位原字段；issues 接收兼容差异。
+    返回: 可交给 AnalysisPlan 的规则字典。异常: ImportProblem 表示有定位的
+    配置问题；内存错误及取消原样传播。阈值沿用信号单位，不除以窗口时长。
+    """
+    path, (line, column) = field_path(section, 'expr'), locate(fields, section, 'expr')
+    mapping_path = '$.sections.' + section
+    expected = {'name', 'window', 'coverage_policy', 'emit_initial', 'retrigger'}
+    if type(selected) is not dict or set(selected) != expected:
+        problem('invalid_section_mapping', 'mapping', mapping_path,
+                'slope段映射必须包含name/window/coverage_policy/emit_initial/retrigger')
+    # 初始化和重复触发不能从旧锁存器猜测，要求调用方逐段作出明确选择。
+    if selected['coverage_policy'] != 'full':
+        problem('unsupported_slope_coverage', 'mapping', mapping_path + '.coverage_policy',
+                '当前仅支持full完整窗口；legacy_samples尚未实现，不能默默替换')
+    if type(selected['emit_initial']) is not bool:
+        problem('invalid_slope_initial', 'mapping', mapping_path + '.emit_initial', '必须明确填写布尔值')
+    if selected['retrigger'] not in ('edge', 'once'):
+        problem('invalid_slope_retrigger', 'mapping', mapping_path + '.retrigger', '必须选择edge或once')
+    match = re.fullmatch(r'_(slope2?)_(rise|fall|any)_([^_]+)_(.+)', text.strip())
+    if match is None:
+        problem('invalid_slope_syntax', 'ini', path,
+                '需要_slope或_slope2、rise/fall/any、秒窗口、完整信号名及非负阈值', line, column)
+    legacy_operator, direction, window, remainder = match.groups()
+    # 最右分隔符属于阈值；信号名本身不按下划线拆开，也不接受旧未使用的尾字段。
+    signal, separator, threshold_text = remainder.rpartition('_')
+    if not separator or not signal or signal not in aliases:
+        problem('missing_slope_alias', 'ini', path,
+                '无法把完整信号名映射到aliases：' + signal + '；请明确名称，不会丢弃额外尾字段', line, column)
+    if re.fullmatch(r'(?:\d+(?:\.\d*)?|\.\d+)s', window) is None:
+        problem('invalid_slope_window', 'ini', path, '窗口必须为正的十进制秒数并以s结束', line, column)
+    try:
+        if parse_duration(window).time_ns <= 0:
+            raise ValueError('窗口必须大于零')
+    except (ValueError, OverflowError) as error:
+        problem('invalid_slope_window', 'ini', path, str(error), line, column)
+    try:
+        if re.fullmatch(r'[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?', threshold_text) is None:
+            raise ValueError('阈值须为十进制数值')
+        threshold = Decimal(threshold_text)
+        if not threshold.is_finite() or threshold < 0:
+            raise ValueError('阈值必须有限且非负')
+        floating = float(threshold)
+        if not math.isfinite(floating) or threshold != 0 and floating == 0:
+            raise ValueError('阈值超出可表示的数值范围')
+        # 整数保留精度；小数遵循配置已有的float64数值契约。
+        number = int(threshold) if threshold == threshold.to_integral_value() else floating
+    except (InvalidOperation, ValueError, OverflowError) as error:
+        problem('invalid_slope_threshold', 'ini', path, str(error), line, column)
+    issues.append(LegacyImportIssue('slope_semantic_differences', 'ini', path,
+        '按文档字符串意图迁移，不宣称旧构造器可运行：旧代码误要求7段且忽略尾字段。'
+        '新规则要求完整窗口与有效覆盖；旧规则至少两点即可。slope要求整窗单调，'
+        '修正旧any的单调检查恒真；slope2不要求单调。初始化和重触发使用显式mapping，'
+        '不复制旧触发后返回False的锁存。pre/post生成触发点周围的固定窗口，'
+        '不复制旧single逐帧退出计时或缓冲重复写出。', line, column, 'warning'))
+    return dict(name=selected['name'], rule_type='window_delta', signal=aliases[signal], window=window,
+                direction=direction, threshold=number, monotonic=legacy_operator == 'slope',
+                coverage_policy='full', emit_initial=selected['emit_initial'], retrigger=selected['retrigger'])

chronaxis/migration/start_end.py

@@ -0,0 +1,48 @@
+"""核对旧start_end的显式业务选择及等待时限。
+
+输入为已定位INI和用户映射，输出新开始/结束规则的初始化及时限字段。
+旧模式先准备再确认切片，新模式从start记录到end；mapping必须声明
+start_end_timeout-v1。本模块不执行条件、读取日志或修复旧入口。
+"""
+
+from decimal import Decimal, InvalidOperation
+from ..timebase import parse_duration
+from .ini import problem, field_path, locate
+from .models import LegacyImportIssue
+
+
+def start_end_options(parser, fields, section, selected, issues):
+    """检查显式新语义，按已审旧字段解释正时限和不限时。
+
+    参数: parser/fields/section为原配置及定位；selected为段映射；issues接收差异。
+    返回: timeout/emit_initial字典。异常: ImportProblem为配置非法；取消和内存错误原样传播。
+    """
+    path = '$.sections.' + section
+    if type(selected) is not dict or set(selected) != {'name', 'window', 'semantics', 'emit_initial'}:
+        problem('invalid_section_mapping', 'mapping', path,
+                'start_end段映射必须含name/window/semantics/emit_initial')
+    if selected['semantics'] != 'start_end_timeout-v1':
+        problem('unconfirmed_start_end_semantics', 'mapping', path + '.semantics',
+                '请明确选择start_end_timeout-v1：start开始、end结束、时限从start计')
+    if type(selected['emit_initial']) is not bool:
+        problem('invalid_start_end_initial', 'mapping', path + '.emit_initial', '必须明确填写布尔值')
+    raw = parser.get(section, 'duration_sec', fallback='-1', raw=True)
+    line, column = locate(fields, section, 'duration_sec')
+    try:
+        value = Decimal(raw)
+        if not value.is_finite():
+            raise ValueError('duration_sec必须有限')
+        # 非正值是旧模式的不限时，不偷偷选择工程默认时长。
+        # 正值保留紧凑指数表示，让时间解析器在分配定点字符串之前拒绝越界。
+        timeout = None if value <= 0 else str(value) + 's'
+        if timeout is not None and parse_duration(timeout).time_ns <= 0:
+            raise ValueError('正时限不能小于可表示的纳秒')
+    except (InvalidOperation, ValueError, OverflowError) as error:
+        problem('invalid_duration', 'ini', field_path(section, 'duration_sec'), str(error), line, column)
+    line, column = locate(fields, section, 'mode')
+    issues.append(LegacyImportIssue('start_end_semantic_change', 'ini', field_path(section, 'mode'),
+        '显式采用start开始/end结束/从start计时，改变旧start仅准备、end才开始切片。'
+        '新时限精确推进，同刻已知end正常结束；可判断却未结束标timeout，缺数据另标中断或截断。'
+        '开始采用新上升沿及映射的首次策略，活动中不排队；旧post不附加，非正duration为不限时。'
+        '不宣称修复旧last_ts缺陷或旧逐帧等价。', line, column, 'warning'))
+    return dict(timeout=timeout, emit_initial=selected['emit_initial'])

chronaxis/planning/__init__.py

@@ -0,0 +1,19 @@
+"""公开配置构建、静态检查和计划解释入口。
+
+AnalysisPlan.from_dict接收版本3配置字典，load_analysis_plan读取JSON配置后构建
+不可变计划。validate_analysis_plan报告声明检查和能力限制，explain_analysis_plan说明依赖、
+历史需求和资源预算。只有load_analysis_plan读取指定配置文件，静态检查不打开CSV或DBC。
+预设已按角色契约展开；实际执行和发布由根包AnalysisRunner及结果层负责，计划合法不表示已执行分析。
+旧来源能力按静态报告保留限制，不因公共入口存在而自动放行。
+当前配置使用同一套记录间隔与诊断声明，不提供旧版本解析或迁移入口。
+"""
+
+# 公开具体已实现入口，而非无类型占位类。
+from .checks import PlanValidationError
+from .plan import AnalysisPlan, load_analysis_plan
+from .reports import ExplainReport, ValidationReport, explain_analysis_plan, validate_analysis_plan
+from .sequences import SequencePlan
+from .intervals import IntervalChoice, IntervalPlan, DiagnosticPlan
+
+# 此包仅导出配置和静态报告；公共AnalysisRunner从chronaxis根包取得。
+__all__ = ['AnalysisPlan', 'SequencePlan', 'PlanValidationError', 'load_analysis_plan', 'ValidationReport', 'ExplainReport', 'validate_analysis_plan', 'explain_analysis_plan', 'IntervalChoice', 'IntervalPlan', 'DiagnosticPlan']

chronaxis/planning/channels.py

@@ -0,0 +1,30 @@
+"""把用户配置的 CAN 通道转换为内部编号，不读取报文或修改原始数据。
+
+公共配置统一从1开始，底层模型从0开始。只在构造模型前调用；配置展开、
+序列化与路径解析保留公共编号，避免往返时反复减1。CSV文件列的channel_origin
+描述原始文件格式，不经过此转换。
+"""
+import re
+
+from .checks import PlanValidationError
+
+
+def channel_index(value, path, *, key=False):
+    """校验公共通道并返回0基编号。
+
+    参数: value为正整数；key=True时为DBC映射的规范十进制字符串；path为配置位置。
+    返回: int，用户1对应内部0。异常: PlanValidationError，非法或旧0基声明。
+    """
+    # 映射键不能靠int接受空格、符号、前导零或其他进制；bool也不是通道整数。
+    if key:
+        if type(value) is not str or re.fullmatch(r'[1-9][0-9]*', value) is None:
+            raise PlanValidationError(path, '配置CAN通道从1开始，DBC通道键须为无前导零的正整数文本',
+                hint='第一路填写\'1\'；旧0基配置的通道编号整体加1，原始文件通道列不修改')
+        try:
+            value = int(value)
+        except ValueError as error:
+            raise PlanValidationError(path, '通道键超过当前整数能力') from error
+    elif type(value) is not int or value < 1:
+        raise PlanValidationError(path, '配置CAN通道须为从1开始的整数',
+            hint='第一路填写1；省略时继承来源唯一通道，旧0基配置整体加1')
+    return value - 1