chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/planning/signal_groups.py

@@ -0,0 +1,61 @@
+"""把同一报文的集中声明展开为既有信号绑定，不增加运行时分组或重复读取。"""
+from .checks import array_at, object_at, choice_at, text_at, model_at, PlanValidationError
+
+
+SHARED = ('period', 'valid_for', 'same_time_policy')
+LOCATOR = ('frame_id', 'channel', 'is_extended', 'is_fd')
+
+
+def signal_entries(value):
+    """按原顺序提供信号副本和声明路径。参数: signals数组。返回: 迭代器。异常: 结构错误。
+
+    集中项只允许声明一套报文定位；子项可覆盖周期、有效期和同刻策略，
+    不能把另一个报文塞进本组。没有额外组名、引用或运行时对象。
+    """
+    for index, raw in enumerate(array_at(value, '$.signals')):
+        path = f'$.signals[{index}]'
+        if type(raw) is not dict or 'signals' not in raw:
+            yield raw, path
+            continue
+        group = object_at(raw, path, ('frame_id', 'signals'),
+                          ('source', 'channel', 'is_extended', 'is_fd') + SHARED)
+        children = array_at(group['signals'], path + '.signals')
+        if not children:
+            raise PlanValidationError(path + '.signals', '报文组至少需要一个信号')
+        # 即使所有子项都覆盖共享参数，也不能把填写错误当成未提供。
+        from .signal_validity import declared_valid_for
+        declared_valid_for(group, path, dbc_available=True)
+        if 'same_time_policy' in group:
+            choice_at(group['same_time_policy'], ('error', 'last_by_sequence'), path + '.same_time_policy')
+        common = {key: group[key] for key in SHARED if key in group}
+        if 'source' in group:
+            common['source'] = group['source']
+        locator = {key: group[key] for key in LOCATOR if key in group}
+        from ..legacy.records import field_from_dict
+        # 预检使用转换后的副本；展开给子项的locator仍保留用户1基编号。
+        from .channels import channel_index
+        checked = dict(locator, signal='_group_check')
+        checked['channel'] = channel_index(locator['channel'], path + '.channel') if 'channel' in locator else 0
+        model_at(field_from_dict, path, checked)
+        for child_index, child in enumerate(children):
+            child_path = f'{path}.signals[{child_index}]'
+            if type(child) is not dict:
+                raise PlanValidationError(child_path, '信号必须为对象')
+            forbidden = set(child) & ({'field', 'source', 'signals'} | set(LOCATOR))
+            if forbidden:
+                raise PlanValidationError(child_path, '组内信号不能重复声明报文定位：' + ', '.join(sorted(forbidden)))
+            if 'signal' not in child:
+                raise PlanValidationError(child_path + '.signal', '需要DBC信号名称')
+            text_at(child['signal'], child_path + '.signal')
+            expanded = dict(common, **child)
+            expanded['field'] = dict(locator, signal=expanded.pop('signal'))
+            yield expanded, child_path
+
+
+def declared_signals(value):
+    """遍历原声明的叶信号供默认展开使用。参数: 已校验数组。返回: 原字典迭代器。异常: 无。"""
+    for item in value:
+        if 'signals' in item:
+            yield from item['signals']
+        else:
+            yield item

chronaxis/planning/signal_validity.py

@@ -0,0 +1,46 @@
+"""确定信号的有效期声明，不读取DBC或日志。
+
+显式valid_for优先；否则使用本信号period的三倍。原始报文未填period时
+保留None，执行启动再从本次已有DBC元数据取得周期。已解码数据不能借用
+别的信号或计算驱动的周期。所有数值以正int64纳秒表示，无I/O或全局缓存。
+"""
+
+from .checks import PlanValidationError, duration_at
+from ..timebase.conversion import require_int64_ns
+
+
+def triple_period(period_ns, path):
+    """将周期乘三并检查溢出，避免产生无限或负有效期。
+
+    参数: period_ns为正整数纳秒；path为配置错误位置。
+    返回: 正int64纳秒有效期。异常: PlanValidationError为非法周期或乘积超界。
+    副作用: 无，不读取文件。
+    """
+    try:
+        # bool不表示一个纳秒；先核周期，再核乘积，保持精确整数运算。
+        if type(period_ns) is not int or period_ns <= 0:
+            raise ValueError('信号周期必须是正整数纳秒')
+        return require_int64_ns(period_ns * 3, 'valid_for_ns')
+    except (TypeError, ValueError, OverflowError) as error:
+        raise PlanValidationError(path, '周期的3倍不能作为有效期：' + str(error)) from error
+
+
+def declared_valid_for(raw, path, *, dbc_available):
+    """按显式有效期、信号周期、待查DBC的优先顺序解析声明。
+
+    参数: raw为单信号配置；path为其配置位置；dbc_available说明原始来源有DBC。
+    返回: 正int纳秒或None（只用于尚待DBC的声明）。
+    异常: PlanValidationError为显式空值、周期/有效期错误或没有周期依据。
+    副作用: 无；validate/explain不会因此打开DBC。
+    """
+    # 即使有效期已覆盖默认值，用户填写的周期也必须合法，不能静默忽略错误。
+    period = duration_at(raw['period'], path + '.period', positive=True) if 'period' in raw else None
+    if 'valid_for' in raw:
+        return duration_at(raw['valid_for'], path + '.valid_for', positive=True)
+    if period is not None:
+        return triple_period(period, path + '.valid_for')
+    # 原始报文可在运行启动借用同次DBC；静态阶段不为默认值提前读文件。
+    if dbc_available:
+        return None
+    raise PlanValidationError(path + '.valid_for',
+        '未填写valid_for且无法取得信号周期；请填写本信号period或valid_for')

chronaxis/planning/text_inputs.py

@@ -0,0 +1,110 @@
+"""静态解释新的ASC和原始CAN表配置，不打开输入或DBC。
+
+来源使用既有name/time/dbc_by_channel及path或有序paths；parser明确ASC版本
+或CSV布局/时间模式。offsets可逐文件声明相对于共同time.offset的额外平移，
+不自动猜跨日、设备同步或日期。返回CANTextSpec及规范来源身份供公共AnalysisRunner。
+"""
+
+from hashlib import sha256
+
+from ..core.models import TimebaseSpec
+from ..core.types import TimeType
+from ..sources.asc import ASCSpec
+from ..sources.blf import BLFSpec
+from ..sources.raw_csv import CANCSVSpec,CSVTimeSpec
+from ..sources.raw_csv_layout import CANCSVLayout
+from ..sources.text_can_spec import CANTextSpec
+from ..timebase.conversion import checked_add_ns
+from .checks import (PlanValidationError,absolute_path,array_at,canonical,choice_at,coordinate_at,
+    duration_at,metadata_at,model_at,object_at,text_at,timezone_at)
+
+
+def parse_text_source(raw,base,path):
+    """建立一个明确的新文本CAN来源。参数: raw原对象、base配置目录、path错误位置。
+    返回: SourcePlan。异常: PlanValidationError定位配置问题；不发生原始输入I/O。
+    """
+    from .models import SourcePlan
+    raw=object_at(raw,path,('name','source_type','time','dbc_by_channel'),('path','paths','parser','offsets','metadata','input_check') + (('reader_options',)))
+    source_type=choice_at(raw['source_type'],('can_asc','asc_or_blf','raw_can_csv'),path+'.source_type')
+    name=text_at(raw['name'],path+'.name',identifier=True)
+    clock=object_at(raw['time'],path+'.time',('time_type','unit'),('origin','offset','timezone'))
+    time_type=choice_at(clock['time_type'],('relative','absolute'),path+'.time.time_type')
+    unit=choice_at(clock['unit'],('s','ms','us','ns','ISO8601'),path+'.time.unit')
+    if time_type=='relative':
+        if 'origin' not in clock or 'timezone' in clock or unit=='ISO8601':
+            raise PlanValidationError(path+'.time','relative必须声明共同origin，且不补日历时区')
+        origin=text_at(clock['origin'],path+'.time.origin')
+        clock_id='relative_'+sha256(origin.encode('utf-8')).hexdigest()[:16]
+    else:
+        if 'origin' in clock:
+            raise PlanValidationError(path+'.time.origin','absolute不接受relative origin')
+        origin=None; clock_id='utc'
+    timebase=model_at(TimebaseSpec,path+'.time',clock_id,TimeType(time_type),origin)
+    offset=coordinate_at(clock.get('offset','0s'),path+'.time.offset')
+    zone=None
+    if 'timezone' in clock:
+        tz=timezone_at(clock['timezone'],path+'.time.timezone')
+        delta=None if tz is None else tz.utcoffset(None)
+        if delta is None or delta.total_seconds()%60:
+            raise PlanValidationError(path+'.time.timezone','此原始报文读取器需要固定时区：UTC或±HH:MM')
+        zone=int(delta.total_seconds()//60)
+    if ('path' in raw)==('paths' in raw):
+        raise PlanValidationError(path,'path和paths必须且只能提供一种')
+    names=[raw['path']] if 'path' in raw else array_at(raw['paths'],path+'.paths')
+    if not 1<=len(names)<=4096:
+        raise PlanValidationError(path+'.paths','需要1至4096个有序文件')
+    paths=tuple(absolute_path(item,base,f'{path}.paths[{i}]') for i,item in enumerate(names))
+    if source_type=='asc_or_blf' and any(p.suffix.lower() not in {'.asc','.blf'} for p in paths):
+        raise PlanValidationError(path+'.paths','自动读取只支持ASC/BLF后缀')
+    offsets=array_at(raw.get('offsets',['0s']*len(paths)),path+'.offsets')
+    if len(offsets)!=len(paths):
+        raise PlanValidationError(path+'.offsets','逐文件偏移数量必须与paths相同')
+    shifted=tuple(model_at(checked_add_ns,f'{path}.offsets[{i}]',offset,coordinate_at(value,f'{path}.offsets[{i}]'))
+        for i,value in enumerate(offsets))
+    dbc=raw['dbc_by_channel']
+    if type(dbc) is not dict or len(dbc)!=1:
+        raise PlanValidationError(path+'.dbc_by_channel','当前文本CAN需要一个明确通道到DBC路径')
+    channel=next(iter(dbc))
+    from .channels import channel_index
+    channel_number=channel_index(channel,path+'.dbc_by_channel',key=True)
+    dbc_path=absolute_path(dbc[channel],base,path+'.dbc_by_channel.'+channel)
+    parser=raw.get('parser',{})
+    if source_type in ('can_asc','asc_or_blf'):
+        parser=object_at(parser,path+'.parser',(),('version','encoding'))
+        if unit!='s':
+            raise PlanValidationError(path+'.time.unit','ASC原文字以秒表示')
+        inputs=tuple(model_at(BLFSpec,path+'.parser',p,shift) if source_type=='asc_or_blf' and p.suffix.lower()=='.blf' else
+            model_at(ASCSpec,path+'.parser',p,parser.get('version','vector-asc-v1'),
+            parser.get('encoding','utf-8-sig'),'epoch' if time_type=='absolute' else 'relative',zone,shift)
+            for p,shift in zip(paths,shifted))
+    else:
+        parser=object_at(parser,path+'.parser',('layout','time_format'),
+            ('id_base','length_base','channel_origin','payload_style','rollover_min_drop'))
+        layout_raw=parser['layout']
+        if type(layout_raw) is dict and type(layout_raw.get('fields')) is dict:
+            fields=dict(layout_raw['fields'])
+            # 通道列缺省时继承当前来源唯一通道；先还原输入起点，reader只减一次。
+            origin=parser.get('channel_origin',0)
+            if type(origin) is not int or origin not in (0,1):
+                raise PlanValidationError(path+'.parser.channel_origin','通道起点须为0或1')
+            fields.setdefault('channel',{'fixed':channel_number+origin})
+            layout_raw=dict(layout_raw,fields=fields)
+        layout=model_at(CANCSVLayout.from_dict,path+'.parser.layout',layout_raw)
+        time_format=choice_at(parser['time_format'],('numeric','clock','clock-ms-us-v1','iso8601'),path+'.parser.time_format')
+        if ((time_format in ('clock','clock-ms-us-v1') and (time_type!='relative' or unit!='s'))
+                or time_format=='iso8601' and (time_type!='absolute' or unit!='ISO8601')
+                or time_format=='numeric' and (unit=='ISO8601' or zone is not None)):
+            raise PlanValidationError(path+'.time','时间种类/单位/时区与原表解析模式不符')
+        rollover=duration_at(parser['rollover_min_drop'],path+'.parser.rollover_min_drop',positive=True) if 'rollover_min_drop' in parser else None
+        inputs=tuple(model_at(CANCSVSpec,path+'.parser',p,layout,
+            model_at(CSVTimeSpec,path+'.parser',time_format,unit if time_format=='numeric' else 's',shift,zone,rollover),
+            parser.get('id_base','auto'),parser.get('length_base',10),parser.get('channel_origin',0),parser.get('payload_style','spaced'))
+            for p,shift in zip(paths,shifted))
+    options=object_at(raw.get('reader_options',{}),path+'.reader_options',(),('decode_policy',))
+    policy=choice_at(options.get('decode_policy','strict'),
+        ('strict','partial','legacy'),path+'.reader_options.decode_policy')
+    input_check=choice_at(raw.get('input_check','auto'),('auto','full'),path+'.input_check')
+    spec=model_at(CANTextSpec,path,name,inputs,dbc_path,channel_number,timebase,policy,input_check)
+    identity=dict(raw,paths=tuple(str(p) for p in paths),dbc_by_channel={channel:str(dbc_path)})
+    identity.pop('path',None)
+    return SourcePlan(name,source_type,spec,unit,clock.get('timezone'),canonical(identity),metadata_at(raw.get('metadata',{}),path+'.metadata'))

chronaxis/presets.py

@@ -0,0 +1,270 @@
+"""校验领域预设v1的角色契约，展开为可序列化的类型化公共声明。
+
+输入PresetSpec与当前SignalDefinition tuple，输出PlanFragment；不读取来源或执行分析。
+先严格校验参数，再显式优先解析角色/检查转换后契约，最后生成简单别名表达式和节点。
+候选语义名只属于本模块的版本化契约，不是通用核心领域目录或行业标准。
+声明会交给AnalysisPlan正常编译；不使用eval、不推断方向/位置/阈值或补造真实数据。
+输入/输出均不可变；JSON序列化返回独立副本。执行、资源预算和报文导出由执行层负责。
+"""
+
+# 算法与公开声明模型分开，避免AnalysisPlan/构建器循环。
+from .core.binding import SignalDefinition
+from .core.expression import DerivedDefinition
+from .core.types import SignalDType as D
+from .core.windows import WindowSpec
+from .planning.checks import (PlanValidationError, choice_at, duration_at, json_value,
+                              array_at, number_at, object_at, text_at)
+from .planning.preset_models import (RoleContract, RoleBinding, PresetSpec, PresetRule,
+                                    PresetCalculation, PlanFragment, CHARGE_ROLES, FAULT_ROLES, COMMAND_ROLES)
+from .planning.sequences import SequencePlan
+from .timebase.conversion import INT64_MIN, INT64_MAX
+
+
+def _parameters(spec, signals=()):
+    """按kind检查工程参数，保持原数值并将时长转换为整数ns。
+
+    参数: spec为PresetSpec；参数值来自独立JSON快照。
+    返回: 新dict，仅内部使用已校验参数，不作为公开无类型片段。
+    异常: PlanValidationError为缺项、未知参数、bool伪数值、非有限或错误范围。
+    """
+    # 将不可变快照还原为局部原生对象，严格拒绝未声明参数。
+    path = '$.preset.parameters'
+    if spec.preset_type == 'charge_session':
+        raw = object_at(json_value(spec.parameters), path, ('mode_value', 'current_min', 'minimum_duration'),
+                        ('compute_energy', 'compute_charge', 'minimum_coverage', 'partial_policy'))
+        result = {'mode_value': number_at(raw['mode_value'], path + '.mode_value', integer=True),
+                  'current_min': number_at(raw['current_min'], path + '.current_min'),
+                  'minimum_duration': duration_at(raw['minimum_duration'], path + '.minimum_duration'),
+                  'compute_energy': choice_at(raw.get('compute_energy', False), (False, True), path + '.compute_energy'),
+                  'compute_charge': choice_at(raw.get('compute_charge', False), (False, True), path + '.compute_charge'),
+                  'minimum_coverage': number_at(raw.get('minimum_coverage', 0), path + '.minimum_coverage', minimum=0, maximum=1),
+                  'partial_policy': choice_at(raw['partial_policy'], ('report', 'strict'), path + '.partial_policy') if 'partial_policy' in raw else None}
+    elif spec.preset_type == 'fault_context':
+        raw = object_at(json_value(spec.parameters), path, (), ('pre', 'post', 'emit_initial'))
+        result = {'pre': duration_at(raw.get('pre', '0s'), path + '.pre'), 'post': duration_at(raw.get('post', '0s'), path + '.post'),
+                  'emit_initial': choice_at(raw.get('emit_initial', False), (False, True), path + '.emit_initial')}
+        if result['pre'] == result['post'] == 0:
+            raise PlanValidationError(path, 'fault_context至少一个pre/post为正')
+    elif spec.preset_type == 'threshold_excursion':
+        # v1明确高阈值进入、低阈值退出；拒绝重叠，不能在阈值相等时猜优先级。
+        raw = object_at(json_value(spec.parameters), path, ('enter_threshold', 'exit_threshold'),
+                        ('unit', 'enter_delay', 'exit_delay'))
+        if 'unit' in raw:
+            unit = text_at(raw['unit'], path + '.unit')
+        else:
+            alias = spec.role_bindings.get('signal')
+            candidates = [item for item in signals if item.name == alias]
+            if len(candidates) != 1:
+                raise PlanValidationError('$.preset.role_bindings.signal', '请指定唯一的已绑定信号以继承单位')
+            unit = candidates[0].unit
+        result = dict(unit=unit,
+            enter_threshold=number_at(raw['enter_threshold'], path + '.enter_threshold'),
+            exit_threshold=number_at(raw['exit_threshold'], path + '.exit_threshold'),
+            enter_delay=duration_at(raw.get('enter_delay', '0ns'), path + '.enter_delay'),
+            exit_delay=duration_at(raw.get('exit_delay', '0ns'), path + '.exit_delay'))
+        if result['enter_threshold'] <= result['exit_threshold']:
+            raise PlanValidationError(path, '进入阈值必须大于退出阈值；v1高于进入、低于退出，均含等号')
+    else:
+        raw = object_at(json_value(spec.parameters), path, ('max_delay',), ('min_delay', 'emit_initial', 'max_pending'))
+        result = dict(min_delay=duration_at(raw.get('min_delay', '0s'), path + '.min_delay'),
+            max_delay=duration_at(raw['max_delay'], path + '.max_delay'),
+            emit_initial=choice_at(raw.get('emit_initial', False), (False, True), path + '.emit_initial'),
+            max_pending=number_at(raw.get('max_pending', 65536), path + '.max_pending', integer=True, minimum=1))
+        if result['min_delay'] > result['max_delay']:
+            raise PlanValidationError(path, 'min_delay不能大于max_delay')
+    return result
+
+
+def _mismatches(definition, contract, *, generic_unit=False):
+    """列出转换后声明未满足的角色字段，不能用自由metadata放宽质量。
+
+    参数: definition为SignalDefinition；contract为本v1角色；generic_unit允许明确同名无转换的自定义单位。
+    返回: tuple[str, ...]，空表示字段契约通过，不证明真实数据正确。
+    异常: 无主动异常；输入类型由公共解析入口证明。
+    """
+    # 逐字段诊断方便缺项/歧义时列出候选不满足原因。
+    errors = []
+    if definition.dtype not in contract.dtypes:
+        errors.append('dtype须为' + '/'.join(item.value for item in contract.dtypes))
+    identity_unit = (generic_unit and definition.input_unit == definition.unit
+                     and definition.scale == 1 and definition.offset == 0 and definition.direction_factor == 1)
+    if definition.unit != contract.unit or definition.unit_status != 'verified' and not identity_unit:
+        errors.append(f'目标unit须为{contract.unit}且关系verified')
+    if contract.sign_convention is not None and definition.sign_convention != contract.sign_convention:
+        errors.append('sign_convention须为' + contract.sign_convention)
+    if contract.measurement_location is not None and definition.measurement_location != contract.measurement_location:
+        errors.append('measurement_location须为' + contract.measurement_location)
+    # DBC默认有效期在运行启动时核实；声明阶段不为角色校验额外加载DBC。
+    if (definition.valid_for_ns is not None and definition.valid_for_ns <= 0
+            or definition.sample_policy != 'backward_hold' or definition.identity()[-1] != contract.forbidden_quality):
+        errors.append('正valid_for/backward_hold/固定基础质量策略未满足')
+    return tuple(errors)
+
+
+def resolve_preset_roles(spec: PresetSpec, signals: tuple[SignalDefinition, ...]) -> tuple[RoleBinding, ...]:
+    """显式优先解析本次实际角色，否则按版本化语义契约寻找唯一合格候选。
+
+    参数: spec为公开不可变预设；signals为当前计划SignalDefinition tuple。
+    返回: RoleBinding tuple，保留原定义与explicit/semantic_unique路径。
+    异常: PlanValidationError为类型、重复别名、未知角色、缺项、候选歧义或契约冲突。
+    边界: 显式别名无需semantic_id，仍检查类型/单位/方向/位置/质量；不选第一个候选。
+    """
+    if not isinstance(spec, PresetSpec) or not isinstance(signals, tuple) or any(not isinstance(item, SignalDefinition) for item in signals):
+        raise PlanValidationError('$.preset', '需要PresetSpec与SignalDefinition tuple')
+    parameters = _parameters(spec, signals)
+    if spec.preset_type == 'threshold_excursion':
+        # 任意物理量显式绑定；未填单位则继承该信号，不猜温度等领域名称。
+        if 'signal' not in spec.role_bindings:
+            raise PlanValidationError('$.preset.role_bindings.signal', 'threshold_excursion必须显式指定signal角色')
+        from .planning.preset_models import RoleContract
+        contracts = (RoleContract('signal', (D.INT64, D.UINT64, D.FLOAT64), parameters['unit'], 'threshold.signal'),)
+    else:
+        contracts = {'charge_session': CHARGE_ROLES, 'fault_context': FAULT_ROLES,
+                     'command_response': COMMAND_ROLES}[spec.preset_type]
+    catalog = {item.name: item for item in signals}
+    if len(catalog) != len(signals):
+        raise PlanValidationError('$.signals', 'signal别名重复')
+    unknown = set(spec.role_bindings) - {item.role for item in contracts}
+    if unknown:
+        raise PlanValidationError('$.preset.role_bindings', '未知角色：' + ', '.join(sorted(unknown)))
+    result = []
+    for contract in contracts:
+        # voltage只在请求能量或明确提供该可选绑定时检查，不强迫无能量任务配置电压。
+        if contract.role == 'voltage' and not parameters['compute_energy'] and contract.role not in spec.role_bindings:
+            continue
+        path = '$.preset.role_bindings.' + contract.role
+        if contract.role in spec.role_bindings:
+            alias = spec.role_bindings[contract.role]
+            if alias not in catalog:
+                raise PlanValidationError(path, f'未知别名：{alias}；可用：{", ".join(catalog)}')
+            definition = catalog[alias]
+            errors = _mismatches(definition, contract, generic_unit=spec.preset_type == 'threshold_excursion')
+            if errors:
+                raise PlanValidationError(path, f'{alias}契约不满足：{"; ".join(errors)}')
+            result.append(RoleBinding(contract, definition, 'explicit'))
+        else:
+            # 只取本模块公开候选标识/版本，所有合格候选统计完才决定。
+            candidates = [item for item in signals if item.semantic_id == contract.semantic_id]
+            valid = [item for item in candidates if item.semantic_contract_version == contract.version and not _mismatches(item, contract)]
+            if len(valid) != 1:
+                details = '; '.join(item.name + ': ' + ', '.join(_mismatches(item, contract) +
+                           (() if item.semantic_contract_version == contract.version else ('semantic_contract_version须为1',))) for item in candidates)
+                reason = '歧义候选：' + ', '.join(item.name for item in valid) if valid else '缺少符合契约的候选'
+                raise PlanValidationError(path, reason + f'（{contract.semantic_id} v1）；' + details)
+            result.append(RoleBinding(contract, valid[0], 'semantic_unique'))
+    return tuple(result)
+
+
+def build_preset(spec: PresetSpec, signals: tuple[SignalDefinition, ...]) -> PlanFragment:
+    """校验v1预设并展开公共声明，不执行I/O或数值分析。
+
+    参数: spec为PresetSpec，保存id/preset_type/version/显式角色及参数；signals为当前类型化信号tuple。
+    返回: PlanFragment，生成请求的功率/Wh/Ah、报警、阈值迟滞/逐段时长或响应配对。
+    异常: PlanValidationError为参数/角色契约、模式编码范围及生成ID与信号冲突。
+    流程: 检查角色→生成简单别名DSL→构造类型化节点→拒绝当前可见ID冲突。
+        用户其他节点/多个预设的冲突由AnalysisPlan合入时继续检查。
+    """
+    resolved = resolve_preset_roles(spec, signals)
+    roles = {item.contract.role: item.definition for item in resolved}
+    parameters = _parameters(spec, signals)
+    if spec.preset_type == 'charge_session':
+        mode, current = roles['mode'], roles['current']
+        minimum, maximum = (INT64_MIN, INT64_MAX) if mode.dtype is D.INT64 else (0, 2**64-1)
+        code = parameters['mode_value']
+        if not minimum <= code <= maximum or mode.valid_range is not None and not mode.valid_range[0] <= code <= mode.valid_range[1]:
+            raise PlanValidationError('$.preset.parameters.mode_value', '模式编码超出已声明dtype/valid_range')
+        # 只拼接已验证别名与原生有限数值字面量，不能注入属性或任意函数。
+        condition = f'{mode.name} == {code!r} and {current.name} > {parameters["current_min"]!r}'
+        rule = PresetRule(spec.id + '_activity', 'condition_duration', condition, parameters['minimum_duration'], 'onset')
+        derived, calculations = [], []
+        for requested, suffix, signal, unit in (
+                (parameters['compute_energy'], 'energy', spec.id + '_power', 'Wh'),
+                (parameters['compute_charge'], 'charge', current.name, 'Ah')):
+            if requested:
+                calculations.append(PresetCalculation(spec.id + '_' + suffix, 'event:' + rule.id, signal, unit,
+                                           parameters['minimum_coverage'], parameters['partial_policy']))
+        if parameters['compute_energy']:
+            derived.append(DerivedDefinition(spec.id + '_power', roles['voltage'].name + ' * ' + current.name, 'W'))
+        fragment = PlanFragment(tuple(derived), (rule,), (), tuple(calculations))
+    elif spec.preset_type == 'fault_context':
+        rule = PresetRule(spec.id + '_alarm', 'rising_edge', roles['alarm'].name, emit_initial=parameters['emit_initial'])
+        window = WindowSpec(spec.id + '_context', rule.id, 'point', parameters['pre'], parameters['post'])
+        fragment = PlanFragment((), (rule,), (window,), ())
+    elif spec.preset_type == 'threshold_excursion':
+        # 普通迟滞规则负责全部状态，逐段时长复用原duration核；总计由同一次状态推进保存。
+        alias = roles['signal'].name
+        rule = PresetRule(spec.id + '_activity', 'hysteresis', None,
+            enter_condition=f'{alias} >= {parameters["enter_threshold"]!r}',
+            exit_condition=f'{alias} <= {parameters["exit_threshold"]!r}',
+            enter_delay_ns=parameters['enter_delay'], exit_delay_ns=parameters['exit_delay'])
+        calculation = PresetCalculation(spec.id + '_duration', 'event:' + rule.id, None, 's',
+                              operation='duration', condition='True')
+        fragment = PlanFragment(rules=(rule,), calculations=(calculation,))
+    else:
+        # 布尔角色变为两条普通rising_edge规则，配对仍走公开SequencePlan，没有隐藏计算器。
+        request = PresetRule(spec.id + '_request', 'rising_edge', roles['request'].name, emit_initial=parameters['emit_initial'])
+        response = PresetRule(spec.id + '_response', 'rising_edge', roles['response'].name, emit_initial=parameters['emit_initial'])
+        sequence = SequencePlan(spec.id + '_pair', request.id, response.id,
+            parameters['min_delay'], parameters['max_delay'], parameters['max_pending'])
+        fragment = PlanFragment(rules=(request, response), sequences=(sequence,))
+    # 不自动改生成名称，当前signal碰撞在公共构建器立即拒绝。
+    generated = [item.name for item in fragment.derived] + [item.id for item in fragment.rules] + [item.window_id for item in fragment.windows] + [item.id for item in fragment.calculations]
+    generated.extend(item.sequence_id for item in fragment.sequences)
+    conflicts = set(generated) & {item.name for item in signals}
+    if conflicts:
+        raise PlanValidationError('$.preset.name', '生成ID冲突：' + ', '.join(sorted(conflicts)))
+    return fragment
+
+
+def expand_presets(config, signals):
+    """在独立配置副本中合入预设片段，保留用户节点并拒绝全部生成ID冲突。
+
+    参数: config为dict，是调用方复制后的配置映射；本函数原地合入生成节点。
+        signals为tuple[SignalDefinition, ...]，提供当前信号定义和预设角色匹配依据。
+    返回: (PresetSpec tuple, 各预设RoleBinding tuple)，供计划保留原声明及角色追溯。
+    异常: PlanValidationError为预设/用户结构或生成ID与用户/其他预设重名。
+    副作用: 仅修改传入的局部derived/rules/windows/calculations/sequences；不修改raw_config快照或来源。
+    """
+    raw_derived = config.get('derived', {})
+    if type(raw_derived) is not dict:
+        raise PlanValidationError('$.derived', 'derived必须为别名对象')
+    # 全部当前用户名称及节点ID都保留，生成项不得隐藏覆盖。
+    occupied = {item.name for item in signals} | set(raw_derived)
+    arrays = {}
+    for key in ('rules', 'windows', 'calculations', 'sequences'):
+        arrays[key] = array_at(config.get(key, []), '$.' + key)
+        for index, row in enumerate(arrays[key]):
+            if type(row) is dict and 'id' in row:
+                raise PlanValidationError(f'$.{key}[{index}].id', '名称字段已统一为name，请替换id', 'unknown_field')
+            if type(row) is not dict or 'name' not in row:
+                raise PlanValidationError(f'$.{key}[{index}]', '节点必须包含name')
+            occupied.add(text_at(row['name'], f'$.{key}[{index}].name', identifier=True))
+    specs, bindings, preset_ids = [], [], set()
+    for index, raw in enumerate(array_at(config.get('presets', []), '$.presets')):
+        path = f'$.presets[{index}]'
+        try:
+            spec = PresetSpec.from_dict(raw)
+            if spec.id in preset_ids:
+                raise PlanValidationError('$.preset.name', 'preset id重复：' + spec.id)
+            fragment = build_preset(spec, signals)
+            bound = resolve_preset_roles(spec, signals)
+            # to_dict承诺可直接合入用户配置；内部展开再转换到同一解析器形式。
+            from .planning.config_groups import normalize_configuration
+            serialized = normalize_configuration({'sources': [], 'signals': [], **fragment.to_dict()})
+            generated = set(serialized['derived']) | {item['name'] for key in arrays for item in serialized.get(key, ())}
+            if generated & occupied:
+                raise PlanValidationError('$.preset.name', '生成ID冲突：' + ', '.join(sorted(generated & occupied)))
+        except PlanValidationError as error:
+            # 外层配置位置替换统一公共spec路径，不丢角色/参数诊断。
+            raise PlanValidationError(error.path.replace('$.preset', path, 1), error.message, error.code) from error
+        # 校验整个片段后再合入，失败不发布半个公开计划。
+        raw_derived.update(serialized['derived'])
+        for key in arrays:
+            arrays[key].extend(serialized.get(key, ()))
+        occupied.update(generated)
+        preset_ids.add(spec.id)
+        specs.append(spec)
+        bindings.append(bound)
+    config['derived'] = raw_derived
+    config.update(arrays)
+    return tuple(specs), tuple(bindings)

chronaxis/results/__init__.py

@@ -0,0 +1,34 @@
+"""提供typed结果行、共享预算、有限暂存、流式读取与发布协议。
+
+导入不启动运行或打开文件；基础行模型和预算不加载NumPy、CAN或DBC。
+实际请求ResultSpool或AnalysisResult时才导入暂存与发布模块及其依赖。
+输入读取由执行层负责；本模块预算跟踪已登记资源，不保证整个进程的RSS上限。
+"""
+
+# 导出结果层异常。
+from .errors import (AnalysisError, BudgetExceededError, ResultClosedError, ResultFormatError,
+                     ContributionsUnavailableError)
+from .budget import ResourceBudget
+from .manifest import RunMetadata, OutputManifest
+
+__all__ = ['AnalysisError', 'BudgetExceededError', 'ResultClosedError', 'ResultFormatError', 'ContributionsUnavailableError', 'SummaryCalculationRow', 'SummaryCoverageCalculationRow', 'SummaryEventRow', 'SummarySequenceRow', 'SummarySegmentRow', 'SummaryContributionRow', 'SummaryInputRow', 'SummarySelectionRow', 'ResultRow', 'ResourceBudget', 'ResultSpool', 'RunMetadata', 'OutputManifest', 'AnalysisResult']
+
+
+def __getattr__(name):
+    """按需提供行模型、暂存和发布类，让纯预算与参考累计不形成依赖环。
+
+    参数: name为请求的公开属性名称。返回: 对应原实现类，不创建实例。
+    异常: AttributeError为未知名称；实际模块导入错误原样传播。
+    副作用: 访问对应类才加载实现及其依赖，不读取输入或启动分析。
+    """
+    # 延迟加载结果模型，纯预算消费者导入时不建立执行层依赖。
+    if name in ('SummaryCalculationRow', 'SummaryCoverageCalculationRow', 'SummaryEventRow', 'SummarySequenceRow', 'SummarySegmentRow', 'SummaryContributionRow', 'SummaryInputRow', 'SummarySelectionRow', 'ResultRow'):
+        from . import rows
+        return getattr(rows, name)
+    if name == 'ResultSpool':
+        from .spool import ResultSpool
+        return ResultSpool
+    if name == 'AnalysisResult':
+        from .result import AnalysisResult
+        return AnalysisResult
+    raise AttributeError(f'chronaxis.results没有公开属性{name!r}')

chronaxis/results/analysis_outcome.py

@@ -0,0 +1,67 @@
+"""说明一次执行为何有或没有业务结果，不保存逐条输入或重复时间记录。
+
+执行层在原有规则推进、指标写出时累计少量状态；本模块只冻结并校验这些事实，
+供清单和CLI共用。事件存在与指标是否完整分别表示，不能以completed代替业务有效性。
+"""
+from dataclasses import dataclass, asdict
+
+from ..core.validation import require_identifier
+
+
+@dataclass(frozen=True)
+class RuleOutcome:
+    """一条规则的结果概况；未知可与已生成事件并存。"""
+
+    rule_id: str
+    status: str
+    event_count: int
+    has_unknown: bool
+    unobserved_signals: tuple[str, ...] = ()
+
+    def __post_init__(self):
+        """参数: 无。返回: None。异常: TypeError/ValueError，状态或计数不合法。"""
+        require_identifier(self.rule_id, 'rule_id')
+        if self.status not in ('no_observation', 'insufficient_data', 'events_found',
+                              'duration_not_met', 'condition_not_met', 'no_event'):
+            raise ValueError('规则结果状态无效')
+        if type(self.event_count) is not int or self.event_count < 0 or type(self.has_unknown) is not bool:
+            raise TypeError('规则结果需要非负事件计数和布尔未知标记')
+        if type(self.unobserved_signals) is not tuple or len(set(self.unobserved_signals)) != len(self.unobserved_signals):
+            raise TypeError('未观测信号需要无重复tuple')
+        for name in self.unobserved_signals:
+            require_identifier(name, 'unobserved_signal')
+        if (self.status == 'events_found') != (self.event_count > 0):
+            raise ValueError('规则结果状态与事件计数不一致')
+
+    def to_dict(self):
+        """参数: 无。返回: 小型JSON对象。异常: 无；不读取结果或输入。"""
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class AnalysisOutcome:
+    """规则状态与指标行计数；不根据事件数推断能量正确或数据完整。"""
+
+    rules: tuple[RuleOutcome, ...] = ()
+    complete: int = 0
+    partial: int = 0
+    indeterminate: int = 0
+    no_observation: int = 0
+
+    def __post_init__(self):
+        """参数: 无。返回: None。异常: TypeError/ValueError，重复规则或错误计数。"""
+        if type(self.rules) is not tuple or any(type(item) is not RuleOutcome for item in self.rules):
+            raise TypeError('分析概况需要RuleOutcome tuple')
+        if len({item.rule_id for item in self.rules}) != len(self.rules):
+            raise ValueError('分析概况规则重复')
+        for value in (self.complete, self.partial, self.indeterminate, self.no_observation):
+            if type(value) is not int or value < 0:
+                raise ValueError('指标概况计数需要非负整数')
+        if self.no_observation > self.complete + self.partial + self.indeterminate:
+            raise ValueError('无观测指标数不能超过指标总数')
+
+    def to_dict(self):
+        """参数: 无。返回: 清单/CLI同用的JSON对象。异常: 无。"""
+        return dict(rules=[item.to_dict() for item in self.rules], calculations=dict(
+            complete=self.complete, partial=self.partial, indeterminate=self.indeterminate,
+            no_observation=self.no_observation))