chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/execution/raw_signal_groups.py

@@ -0,0 +1,192 @@
+"""把三格式共用的已解码更新交给实时完整同刻组消费者，不写历史文件。
+
+只归一化当前声明需要的字段；同刻组跨读取批/连续文件保持，看到下一个相关
+时间后才交付上一组，EOF显式finish交付末组。每条待交付样本预付有限预算，
+大同刻组超预算明确失败。跨来源调用方必须先按实际时间合并；本组件不重排
+原文件、不解码DBC、不查询完整性证明，不把单个来源EOF当整个会话EOF。
+"""
+
+from ..core.models import SourceRef
+from ..legacy.updates import LegacyDecodedUpdate
+from ..results.budget import ResourceBudget, _reserve_owned_ram, _release_owned_ram, _cleanup_owner
+from ..results.errors import ResultClosedError
+from ..sources.can_spec import can_field_from_key
+from ..sources.packing import pack_message_values
+from .groups import DecodedTimeGroup
+from .history import _metadata_bytes
+from .record_sample import RecordSample
+from .calculation_values import scalar_from_column
+from ..core.numeric import ScalarValue
+from ..core.types import QualityFlag as Q,SignalDType as D
+
+
+class RawSignalGroups:
+    """保存当前同刻的必要更新；组交付后立即释放，消费方另行承担最新值状态。"""
+
+    def __init__(self, budget, definitions, session_id, consumer, *, backend='numpy',clock_only=()):
+        """建立所需帧/信号索引和固定来源引用，不打开原始文件。
+
+        参数: budget共享账本；definitions仅本次所需信号tuple；session_id会话；
+            consumer同步借用完整DecodedTimeGroup；backend选择原归一化内核。
+            clock_only只使用对应报文的更新时间，共用无效占位而不逐帧归一化无关值。
+        返回: owner。异常: 配置、预算或取消；构造恢复句柄raw_groups_cleanup_owner。
+        """
+        if not isinstance(budget, ResourceBudget) or type(definitions) is not tuple or not callable(consumer):
+            raise TypeError('实时原始信号组需要预算、定义tuple及消费者')
+        if backend not in ('reference', 'numpy'):
+            raise ValueError('实时原始信号组后端错误')
+        self._budget, self._backend, self._session = budget, backend, session_id
+        self._held_cost = self._fixed_cost = self._group_cost = self._work_cost = 0
+        self._closed = self._closing = self._failed = self._finished = False
+        self._consumer = self._fields = self._samples = None
+        self._time = None
+        self._clock_values=None
+        self._clock_candidates={}
+        self._automatic_names=set()
+        try:
+            _reserve_owned_ram(self, 65536 + 32 * _metadata_bytes((definitions, session_id)), '_fixed_cost')
+            if len({item.name for item in definitions}) != len(definitions):
+                raise ValueError('实时原始信号组不能重复声明别名')
+            self._fields = {}
+            if not set(clock_only)<={item.name for item in definitions}:
+                raise ValueError('纯时钟字段必须属于当前组定义')
+            self._clock_values={item.name:ScalarValue(None,item.dtype,False,Q.MISSING,
+                tuple(dict.fromkeys(label for _,label in item.choices)) if item.dtype is D.ENUM else ())
+                for item in definitions if item.name in clock_only}
+            for definition in definitions:
+                field = can_field_from_key(definition.field)
+                # 自动类型需辨别“不是本帧字段”；显式类型的低层缺键仍表示缺值。
+                if field.is_extended is None or field.is_fd is None:
+                    self._automatic_names.add(definition.name)
+                key = (definition.source, field.channel, field.frame_id, field.is_extended, field.is_fd)
+                ref = SourceRef(session_id, definition.source, definition.field)
+                self._fields.setdefault(key, []).append((definition, field.signal, ref))
+            self._fields = {key: tuple(items) for key, items in self._fields.items()}
+            self._samples, self._consumer = [], consumer
+        except BaseException as exc:
+            _cleanup_owner(self, exc, 'raw_groups_cleanup_owner', '实时原始信号组')
+            raise
+        finally:
+            definitions = definition = field = ref = consumer = None
+
+    def _require_open(self):
+        """拒绝失败/关闭后的输入。参数: 无。返回: None。异常: ResultClosedError。"""
+        if self._closed or self._closing or self._failed:
+            raise ResultClosedError('实时原始信号组已失败或关闭')
+
+    def configure_metadata(self, facts):
+        """借用同次DBC候选识别纯时钟字段，不解码或读取额外记录。
+
+        参数: facts为已加载字段事实。返回: None。异常: 定位结构错误。
+        副作用: 仅保存当前纯时钟字段的有限候选，费用包含在定义固定预算中。
+        """
+        self._require_open()
+        from ..legacy.records import field_from_dict
+        # 同物理字段可能有多个时钟别名，按别名共享候选，不把后一别名覆盖掉。
+        by_field={field_from_dict(dict(fact['locator'])).key: fact['dbc_frames']
+                  for fact in facts if 'dbc_frames' in fact}
+        self._clock_candidates={definition.name: by_field[definition.field]
+            for items in self._fields.values() for definition, _, _ in items
+            if definition.name in self._clock_values and definition.field in by_field}
+
+    def consume(self, update):
+        """接收一条已投影更新，仅所需帧参与时间检查与同刻归组。
+
+        参数: update为LegacyDecodedUpdate；缺失的匹配字段仍生成无效更新覆盖旧值。
+        返回: None。异常: 身份/时间回退、预算、归一化或消费者错误；失败后禁止finish。
+        """
+        self._require_open()
+        if self._finished:
+            raise ResultClosedError('实时原始信号组已经结束')
+        column = sample = value = fields = None
+        primary = None
+        try:
+            if not isinstance(update, LegacyDecodedUpdate) or update.source_ref.session_id != self._session:
+                raise ValueError('更新不属于当前会话')
+            # 每种选择器只有一个键；最多查询四种明确/省略类型组合，不扫描全部信号。
+            prefix = (update.source, update.channel, update.frame_id)
+            fields = tuple(item for extended in (update.is_extended, None) for fd in (update.is_fd, None)
+                           for item in self._fields.get((*prefix, extended, fd), ()))
+            # 投影会为属于本帧但解码失败的字段保留None；未出现的键才是另一帧的字段。
+            # 纯时钟不要求解码值，使用初始化时已有的DBC候选判定所属帧。
+            fields = tuple(item for item in fields if
+                (item[0].name not in self._clock_values and
+                    (item[0].name not in self._automatic_names or item[1] in update.values))
+                or (item[0].name in self._clock_values and
+                    (item[0].name not in self._clock_candidates or any(
+                        extended == update.is_extended and (fd == update.is_fd or fd and not update.is_fd)
+                        for extended, fd in self._clock_candidates[item[0].name]))))
+            if not fields or update.is_remote or update.is_error:
+                return
+            if update.time_ns is None:
+                raise ValueError('驱动表达式需要相关报文的实际时间')
+            if self._time is not None and update.time_ns < self._time:
+                raise ValueError('相关报文回退；多来源须先按实际时间有界归并')
+            if self._time is not None and update.time_ns > self._time:
+                self._flush()
+            self._time = update.time_ns
+            _reserve_owned_ram(self, 16384 + 4096 * len(fields), '_work_cost')
+            for definition, name, ref in fields:
+                # 本条缺字段同样归一化为无效；不保原值副本或逐条原帧定位。
+                _reserve_owned_ram(self, 8192, '_group_cost')
+                if definition.name in self._clock_values:
+                    value=self._clock_values[definition.name]
+                    array_value=False if definition.dtype is D.BOOL else 0. if definition.dtype is D.FLOAT64 else 0
+                else:
+                    column = pack_message_values(definition, (update.values.get(name),), self._backend)
+                    value = scalar_from_column(column, 0)
+                    array_value=column.values[0].item() if definition.dtype is D.ENUM else None
+                sample = RecordSample(definition.name, update.time_ns, update.sequence,
+                    value, definition.unit, ref, array_value if definition.dtype is D.ENUM else None)
+                self._samples.append(sample)
+        except BaseException as exc:
+            primary = exc
+            self._failed = True
+            raise
+        finally:
+            column = sample = value = update = fields = None
+            try:
+                _release_owned_ram(self, self._work_cost, '_work_cost')
+            except BaseException as cleanup:
+                self._failed = True
+                if primary is None:
+                    raise
+                primary.add_note('实时原始信号组临时费用清理失败：' + type(cleanup).__name__)
+
+    def _flush(self):
+        """同步借出完整组后释放本组，不保输出副本。参数: 无。返回: None。异常: 消费/清理错误。"""
+        if not self._samples:
+            return
+        group = None
+        try:
+            group = DecodedTimeGroup(self._time, tuple(self._samples))
+            self._consumer(group)
+        finally:
+            group = None
+        self._samples.clear()
+        _release_owned_ram(self, self._group_cost, '_group_cost')
+
+    def finish(self):
+        """所有输入EOF并成功关闭后交付末组，不创建末尾周期。参数: 无。返回: None。异常: 消费/清理错误。"""
+        self._require_open()
+        if self._finished:
+            return
+        try:
+            self._flush()
+            self._finished = True
+        except BaseException:
+            self._failed = True
+            raise
+
+    def close(self):
+        """仅退自有费用，不替调用方完成剩余组。参数: 无。返回: None。异常: 释放失败可重试。"""
+        if self._closed:
+            return
+        self._closing = True
+        self._samples = self._fields = self._consumer = self._clock_values = None
+        self._clock_candidates={}
+        self._automatic_names.clear()
+        _release_owned_ram(self, self._work_cost, '_work_cost')
+        _release_owned_ram(self, self._group_cost, '_group_cost')
+        _release_owned_ram(self, self._fixed_cost, '_fixed_cost')
+        self._closed = True

chronaxis/execution/record_alarm_duration.py

@@ -0,0 +1,114 @@
+"""仅在请求报警累计时，按实际有效区间折算所选周期。
+
+状态变化可能发生在两个驱动报文之间，例如温度在中途过期。每对报文只保
+实际已知/报警长度，收到右端后按该对完整跨度折算，不保存逐点轨迹。没有
+右端的末段不补固定周期；实际模式则累计已经确认存在的连续观测区间。
+"""
+
+from ..core.types import Truth as T
+from ..core.integral_sum_reference import ReferenceIntegralSum
+from ..core.integral_sum_numpy import NumpyIntegralSum
+from ..results.errors import ResultClosedError,AnalysisError
+from ..results.spool import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+
+
+class RecordAlarmDuration:
+    """拥有一个待完成记录对和有限求和状态，不读取来源或构造明细。"""
+
+    def __init__(self,budget,step_ns,backend,window):
+        """预付统计费用。参数: 共享预算、实际None/正周期、后端。返回: owner。异常: 构造原错附owner。"""
+        self._budget,self._step=budget,step_ns
+        self._backend=backend
+        self._window=window
+        self._held_cost=self._fixed_cost=0
+        self._last=self._driver=None
+        self._state=T.UNKNOWN
+        self._pair_known=self._pair_active=0
+        self._known=self._observed=0
+        self._active_ns=0
+        self._sum=None
+        self._closed=self._finished=False
+        try:
+            _reserve_owned_ram(self,65536+(4096*256 if step_ns is not None else 0),'_fixed_cost')
+            if step_ns is not None:
+                self._sum=(ReferenceIntegralSum if backend=='reference' else NumpyIntegralSum)(4096)
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_alarm_cleanup_owner','报警时长构造')
+            raise
+
+    def consume(self,time_ns,state,driver=False):
+        """先结算前态，再记当前态；中途未知只裁剪本对有效部分。
+
+        参数: 实际时间、已确认报警三态、是否真实驱动更新。返回: None。异常: 顺序/数值/关闭错误。
+        """
+        if self._closed or self._finished:
+            raise ResultClosedError('报警累计已结束')
+        if self._last is not None:
+            if time_ns<self._last:
+                raise ValueError('报警累计时间不能回退')
+            length=max(0,min(time_ns,self._window.end_ns)-max(self._last,self._window.start_ns))
+            known=length if self._state is not T.UNKNOWN else 0
+            active=length if self._state is T.TRUE else 0
+            if self._step is None:
+                self._observed+=length
+                self._known+=known
+                self._active_ns+=active
+            elif self._driver is not None:
+                self._pair_known+=known
+                self._pair_active+=active
+        if self._step is not None and driver:
+            if self._driver is not None:
+                span=time_ns-self._driver
+                overlap=max(0,min(time_ns,self._window.end_ns)-max(self._driver,self._window.start_ns))
+                self._observed+=overlap
+                self._known+=self._pair_known
+                seconds=(self._step*self._pair_active)/(span*1_000_000_000)
+                if self._backend=='reference':
+                    self._sum.push_values((seconds,),(True,))
+                else:
+                    import numpy as np
+                    values=np.array([seconds],dtype=np.float64)
+                    valid=np.array([True],dtype=np.bool_)
+                    values.setflags(write=False);valid.setflags(write=False)
+                    self._sum.push_values(values,valid)
+            self._driver=time_ns
+            self._pair_known=self._pair_active=0
+        self._last,self._state=time_ns,state
+
+    def driver(self,time_ns):
+        """接收原始驱动端点，包括请求域两侧用于比例的点。参数: 实际时间。返回: None。异常: 顺序错误。"""
+        if self._step is None or self._driver is not None and self._driver>=self._window.end_ns:
+            return
+        self.consume(time_ns,self._state,True)
+
+    def finish(self):
+        """返回单一秒数及完整性；不结算没有右端的周期。
+
+        参数: 无。返回: (可核实报警秒数或None,状态)。异常: 求和失败/关闭错误。
+        """
+        if self._closed:
+            raise ResultClosedError('报警累计已关闭')
+        if self._sum is None:
+            active=self._active_ns/1e9
+        else:
+            result=self._sum.finish('s')
+            if result.calculation_failed:
+                raise AnalysisError('报警累计数值溢出')
+            active=0. if result.value is None else result.value
+        status=('no_observation' if not self._observed else 'indeterminate' if not self._known
+                else 'partial' if self._known<self._observed else 'complete')
+        self._finished=True
+        return (active if status in ('complete','partial') else None),status
+
+    @property
+    def closed(self):
+        """返回关闭状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """丢弃统计状态并归还自己的费用。参数: 无。返回: None。异常: 释放原错可重试。"""
+        if self._closed:
+            return
+        self._sum=None
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost')
+        self._closed=True

chronaxis/execution/record_delta_condition.py

@@ -0,0 +1,167 @@
+"""在当前窗口内保留必要数值片段，输出窗口变化量的三值条件。
+
+实际模式在旧边界移出窗口时继续求值；固定/DBC只在选定驱动到达时移动窗口，
+其他更新只处理失效。原实际坐标和TTL不改变，变化量仍交原独立两后端核计算。
+"""
+from collections import deque
+from dataclasses import replace
+from fractions import Fraction
+from ..core.numeric import ScalarValue
+from ..core.types import SignalDType as D,QualityFlag as Q,Truth as T
+from ..core.window_delta import DeltaSpan
+from ..core.window_delta_reference import window_delta_reference
+from ..core.window_delta_numpy import window_delta_numpy
+from ..results.errors import ResultClosedError
+from ..results.spool import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+
+
+class RecordDeltaCondition:
+    """拥有当前窗口片段和有限驱动时刻；不创建整段历史或对照时间轴。"""
+
+    def __init__(self,budget,spec,dtype,backend,step_ns):
+        """预付有限状态，动态窗口按实际容量收费。参数: 预算/配置/数值类型/后端/周期。返回: owner。异常: 原构造错。"""
+        self._budget,self._spec,self._dtype,self._step=budget,spec,dtype,step_ns
+        self._held_cost=self._fixed_cost=self._span_cost=self._clock_cost=self._work_cost=0
+        self._spans,self._clocks=deque(),deque()
+        self._held_number=self._held_right=None
+        self._held_deadline=None
+        self._point=self._right=ScalarValue(None,D.BOOL,False,Q.MISSING)
+        self._last_time=None
+        self.next_deadline=None
+        self._closed=self._failed=False
+        try:
+            _reserve_owned_ram(self,65536,'_fixed_cost')
+            self._kernel=window_delta_reference if backend=='reference' else window_delta_numpy
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_delta_cleanup_owner','窗口变化条件构造')
+            raise
+
+    @staticmethod
+    def _condition(result):
+        """转换既有数值核的三值结果，不把未知变False。参数: 结果。返回: ScalarValue。异常: 原类型错。"""
+        valid=result.condition is not T.UNKNOWN
+        return ScalarValue(result.condition is T.TRUE if valid else None,D.BOOL,valid,result.quality)
+
+    def _append(self,time_ns,point,right):
+        """只保存值或质量真正变化的边界，查询末点临时构造。
+
+        参数: 实际时刻、点值/右侧值。返回: None。异常: 预算/时间回退。
+        """
+        value=point.value if point.valid else None
+        pq=Q.NONE if point.valid else point.quality
+        cq=Q.NONE if right.valid else right.quality
+        if self._spans:
+            last=self._spans[-1]
+            if last.start_ns==time_ns:
+                self._spans[-1]=DeltaSpan(time_ns,time_ns,value,cq,pq)
+                return
+            self._spans[-1]=replace(last,end_ns=time_ns)
+            if last.value==value and last.quality==cq==pq:
+                return
+        _reserve_owned_ram(self,2048,'_span_cost')
+        self._spans.append(DeltaSpan(time_ns,time_ns,value,cq,pq))
+
+    def _left(self,time_ns):
+        """只根据当前窗口需要的驱动记录确定左端。参数: 实际时刻。返回: 左端或不足时None。异常: 无。"""
+        if self._step is None:
+            return time_ns-self._spec.window_ns
+        count=len(self._clocks)
+        offset=Fraction(self._spec.window_ns,self._step)
+        target=Fraction(count-1)-offset
+        if target<0:
+            return None
+        index=target.numerator//target.denominator
+        if target==index:
+            return self._clocks[index]
+        return round(Fraction(self._clocks[index])+(target-index)*(self._clocks[index+1]-self._clocks[index]))
+
+    def update(self,time_ns,point,right,expires_at_ns,*,driver=False):
+        """推进真实值和当前窗口，返回点/右侧条件；不输出变化值副本。
+
+        参数: 实际时刻、求值点/右侧值、实际TTL截止及是否选定驱动。
+        返回: 两个BOOL ScalarValue。异常: 倒序、预算或原数值错误；失败只能清理。
+        """
+        if self._closed or self._failed:
+            raise ResultClosedError('窗口变化条件已关闭或失败')
+        spans=point_result=right_result=None
+        try:
+            if self._last_time is not None and time_ns<self._last_time:
+                raise ValueError('窗口变化时间回退')
+            self._last_time=time_ns
+            if self._step is not None:
+                if driver:
+                    if not self._clocks or self._clocks[-1]!=time_ns:
+                        _reserve_owned_ram(self,128,'_clock_cost')
+                        self._clocks.append(time_ns)
+                    limit=(self._spec.window_ns+self._step-1)//self._step+1
+                    while len(self._clocks)>limit:
+                        self._clocks.popleft()
+                        _release_owned_ram(self,128,'_clock_cost')
+                    self._held_number,self._held_right,self._held_deadline=point,right,expires_at_ns
+                else:
+                    unknown=ScalarValue(None,self._dtype,False,Q.MISSING)
+                    if self._held_number is None:
+                        point=right=unknown
+                    else:
+                        expired=self._held_deadline is not None and time_ns>=self._held_deadline
+                        if expired:
+                            point=right=ScalarValue(None,self._dtype,False,Q.STALE)
+                        else:
+                            point=self._held_number if point.valid else point
+                            right=self._held_right if right.valid else right
+                        if not point.valid or not right.valid:
+                            self._held_number,self._held_right=point,right
+                self.next_deadline=(self._held_deadline if self._held_deadline is not None and self._held_deadline>time_ns else None)
+            self._append(time_ns,point,right)
+            if self._step is not None and not driver:
+                if not point.valid:
+                    self._point=ScalarValue(None,D.BOOL,False,point.quality)
+                if not right.valid:
+                    self._right=ScalarValue(None,D.BOOL,False,right.quality)
+                return self._point,self._right
+            left=self._left(time_ns)
+            if left is None or left>=time_ns:
+                self._point=self._right=ScalarValue(None,D.BOOL,False,Q.MISSING)
+                return self._point,self._right
+            while len(self._spans)>1 and self._spans[0].end_ns<=left and self._spans[0].start_ns<left:
+                self._spans.popleft()
+                _release_owned_ram(self,2048,'_span_cost')
+            _reserve_owned_ram(self,65536+4096*(len(self._spans)+1),'_work_cost')
+            tail=DeltaSpan(time_ns,time_ns,point.value if point.valid else None,
+                Q.NONE if right.valid else right.quality,Q.NONE if point.valid else point.quality)
+            spans=tuple(self._spans)
+            spans=spans if spans[-1].start_ns==time_ns else spans+(tail,)
+            spec=self._spec if self._step is None else replace(self._spec,window_ns=time_ns-left)
+            point_result=self._kernel(spec,spans,time_ns,self._dtype)
+            right_result=point_result
+            if tail.point_quality!=tail.quality:
+                right_result=self._kernel(spec,spans[:-1]+(replace(tail,point_quality=tail.quality),),time_ns,self._dtype)
+            self._point,self._right=self._condition(point_result),self._condition(right_result)
+            if self._step is None:
+                candidates=[span.start_ns+self._spec.window_ns for span in self._spans
+                            if time_ns<span.start_ns+self._spec.window_ns<(1<<63)]
+                if expires_at_ns is not None and expires_at_ns>time_ns:
+                    candidates.append(expires_at_ns)
+                self.next_deadline=min(candidates) if candidates else None
+            return self._point,self._right
+        except BaseException:
+            self._failed=True
+            raise
+        finally:
+            spans=point_result=right_result=None
+            _release_owned_ram(self,self._work_cost,'_work_cost')
+
+    @property
+    def closed(self):
+        """返回资源关闭状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """释放有界片段与驱动记录，不写文件。参数: 无。返回: None。异常: 原预算关闭错，可重试。"""
+        if self._closed:
+            return
+        self._spans.clear();self._clocks.clear()
+        self._held_number=self._held_right=None
+        for slot in ('_span_cost','_clock_cost','_work_cost','_fixed_cost'):
+            _release_owned_ram(self,getattr(self,slot),slot)
+        self._closed=True

chronaxis/execution/record_diagnostics.py

@@ -0,0 +1,87 @@
+"""仅在请求追溯或完整性诊断时观察同次输入，不增加来源扫描。
+
+trace逐条保存所需输入值和来源序号；integrity随这些记录计算摘要，两者独立。
+来源配置只在清单保存一次。借入值在调用结束释放，固定哈希状态按来源付费；
+最终明细使用已有结果仓的有界外排和生命周期，不建立第二份历史。
+"""
+import hashlib
+import json
+from math import isfinite
+from ..results.input_diagnostics import InputDiagnostic
+from ..results.budget import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+from ..results.errors import ResultClosedError
+from .history import _metadata_bytes
+
+
+class RecordDiagnostics:
+    """保存每来源一个计数及可选摘要；逐条明细同步交给最终结果消费者。"""
+    def __init__(self,plan,requirements,budget,consumer):
+        """预约实际来源状态。参数: 计划/需求/预算/追溯回调。返回: owner。异常: 预算错误。"""
+        self._plan,self._requirements,self._budget=plan,requirements,budget
+        self._consumer=consumer if plan.diagnostics.trace else None
+        self._held_cost=self._fixed_cost=self._row_cost=0
+        self._counts=self._hashes=None
+        self._closed=False
+        try:
+            names=tuple(s.source for s in requirements.sources if s.active)
+            _reserve_owned_ram(self,65536+4096*len(names),'_fixed_cost')
+            # 来源清单只计路径/需求，不遍历memory来源的全部数据；覆盖最终清单交接副本。
+            extra=32*_metadata_bytes(requirements)
+            for source in plan.sources:
+                if source.name not in names:continue
+                config=source.config
+                paths=(config.input_paths if source.source_type=='can_blf' else
+                    (item.path for item in config.inputs) if source.source_type in ('can_asc','asc_or_blf','raw_can_csv') else
+                    config.paths if source.source_type=='signal_csv' else ())
+                extra+=sum(4096+256*len(str(path)) for path in paths)
+            _reserve_owned_ram(self,extra,'_fixed_cost')
+            self._counts=dict.fromkeys(names,0)
+            self._hashes={name:hashlib.sha256() for name in names} if plan.diagnostics.integrity else {}
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_diagnostics_cleanup_owner','输入诊断');raise
+
+    def consume(self,source,sequence,time_ns,record_type,locator,values,quality):
+        """借入必要输入，按请求追溯/取摘要。参数: 定位/类型/值/质量。返回: None。异常: 编码/预算/取消。"""
+        if self._closed:raise ResultClosedError('输入诊断已关闭')
+        payload=normalized=text=None
+        try:
+            # 先覆盖编码及非有限标签空间，非法值不偷偷转成有效0。
+            _reserve_owned_ram(self,16384+64*_metadata_bytes(values),'_row_cost')
+            normalized={name:({'nonfinite':'nan' if value!=value else 'inf' if value>0 else '-inf'}
+                if type(value) is float and not isfinite(value) else value) for name,value in values.items()}
+            text=json.dumps(normalized,ensure_ascii=False,allow_nan=False,sort_keys=True,separators=(',',':'))
+            if source in self._hashes:
+                payload=json.dumps((sequence,time_ns,record_type,locator,int(quality),text),ensure_ascii=False,
+                    allow_nan=False,separators=(',',':')).encode('utf-8')
+                self._hashes[source].update(len(payload).to_bytes(8,'big'))
+                self._hashes[source].update(payload)
+            if self._consumer is not None:
+                self._consumer(source,sequence,time_ns,record_type,locator,text,quality)
+            self._counts[source]+=1
+        finally:
+            payload=normalized=values=text=None
+            _release_owned_ram(self,self._row_cost,'_row_cost')
+
+    def summaries(self,cursors):
+        """仅EOF后交付有限来源清单。参数: 实际游标。返回: InputDiagnostic tuple。异常: 不完整来源。"""
+        result=[]
+        for cursor in cursors:
+            source=next(s for s in self._plan.sources if s.name==cursor.source_name)
+            config=source.config
+            paths=(tuple(str(p) for p in config.input_paths) if source.source_type=='can_blf' else
+                tuple(str(i.path) for i in config.inputs) if source.source_type in ('can_asc','asc_or_blf','raw_can_csv') else
+                tuple(str(path) for path in config.paths) if source.source_type=='signal_csv' else ())
+            req=self._requirements.for_source(source.name)
+            result.append(InputDiagnostic(source.name,source.source_type,paths,req.required_aliases,
+                tuple((name,self._plan.bindings.resolve(name).field) for name in req.required_aliases),
+                req.input_check,req.time_scope,self._counts[source.name],cursor._finished,
+                self._hashes[source.name].hexdigest() if source.name in self._hashes else None))
+        return tuple(result)
+
+    def close(self):
+        """断开哈希/回调后归还本owner费用。参数: 无。返回: None。异常: 预算释放错误。"""
+        if self._closed:return
+        self._counts=self._hashes=self._consumer=None
+        _release_owned_ram(self,self._row_cost,'_row_cost')
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost')
+        self._closed=True