chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/execution/record_event_durations.py

@@ -0,0 +1,143 @@
+"""按需计算每段事件的持续时长，只为周期模式保存必要驱动时间。
+
+实际模式直接使用事件范围。固定/DBC需要知道事件两端落在哪对报文中，因而
+保存每条所选驱动的一个整数时间；按索引二分定位，只回读相关记录对。该文件
+没有数值、原帧或另一时间轴，未请求此类统计时不建立；关闭自动删除。
+"""
+
+import heapq
+from ..core.models import Interval
+from ..core.calculations import CalculationDefinition
+from ..core.numeric import ScalarValue
+from ..core.types import SignalDType as D,QualityFlag as Q
+from ..results.errors import ResultClosedError
+from ..results.spool import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+from .record_time_calculation import RecordTimeCalculation
+from .history import _metadata_bytes
+from ..planning.record_execution import is_event_duration
+
+
+class RecordEventDurations:
+    """拥有必要时点文件、尚缺右端的事件及一个短生命周期数值查询。"""
+
+    def __init__(self,plan,budget,work_dir,steps,consumer,*,indexes=None):
+        """预付有限索引状态，不为actual创建文件。参数: 计划/预算/目录/周期/回调；indexes借用共享必要时点，不在此重复保存。返回: owner。异常: 原构造错误。"""
+        self._plan,self._budget,self._path,self._steps,self._consumer=plan,budget,work_dir,steps,consumer
+        self._requests=tuple(item for item in plan.calculations if is_event_duration(item))
+        self._choices=dict(plan.intervals.resolved)
+        self._held_cost=self._fixed_cost=self._pending_cost=0
+        self._indexes=indexes
+        self._queue=[]
+        self._serial=0
+        self._calculation=None
+        self._closed=self._failed=False
+        try:
+            _reserve_owned_ram(self,131072+32768*len(self._requests)+32*_metadata_bytes(self._requests),'_fixed_cost')
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_event_duration_cleanup_owner','事件时长构造')
+            raise
+
+    def _open(self):
+        """拒绝关闭/失败实例。参数: 无。返回: None。异常: ResultClosedError。"""
+        if self._closed or self._failed:
+            raise ResultClosedError('事件时长已关闭或失败')
+
+    def observe_group(self,group):
+        """父已更新共享时点索引，尝试完成等待中的事件。参数: 完整组。返回: None。异常: 查询原错。"""
+        self._open()
+        self._flush_ready()
+
+    def observe_event(self,event):
+        """只为匹配事件建立必要查询，缺右端时暂存端点和ID。参数: 事件。返回: None。异常: 预算/求值原错。"""
+        self._open()
+        for request in self._requests:
+            if request.scope!='event:'+event.rule.rule_id:
+                continue
+            end=event.start_ns if event.end_ns is None else event.end_ns
+            # 快捷时长与一般事件计算使用同一选择范围；确认等于结束时保留空区间。
+            rule=next(item for item in self._plan.rules if item.rule_id==event.rule.rule_id)
+            start=event.confirmed_ns if rule.selection_origin=='confirmed' else event.start_ns
+            cost=8192+16*_metadata_bytes(event.event_id)
+            _reserve_owned_ram(self,cost,'_pending_cost')
+            heapq.heappush(self._queue,(end,self._serial,request,event.event_id,start,cost))
+            self._serial+=1
+        self._flush_ready()
+
+    def _calculate(self,request,event_id,start_ns,end_ns):
+        """只借取事件两侧及区间内的驱动点，复用原两后端时长核。
+
+        参数: 请求/父ID/真实端点。返回: None，结果交回调。异常: 构造/数值/发布原错。
+        """
+        step=self._steps[request.calculation_id]
+        spec=CalculationDefinition(request.calculation_id,'duration',Interval(start_ns,end_ns),request.partial_policy,
+                        request.unit,'event',request.minimum_coverage)
+        try:
+            self._calculation=RecordTimeCalculation(self._budget,spec,'1',D.BOOL,step,
+                backend=self._plan.execution.backend,batch_intervals=64)
+        except BaseException as error:
+            self._calculation=getattr(error,'record_time_cleanup_owner',None)
+            raise
+        value=ScalarValue(True,D.BOOL,True,Q.NONE)
+        if step is None:
+            if start_ns<end_ns:
+                self._calculation.consume(((start_ns,value),(end_ns,value)))
+        else:
+            driver=self._choices[request.calculation_id].driver
+            count=self._indexes.count(driver)
+            if count:
+                first=self._indexes.lower(driver,start_ns)
+                if first==count or first>0 and self._indexes.at(driver,first)>start_ns:
+                    first-=1
+                last=min(count-1,self._indexes.lower(driver,end_ns))
+                for index in range(first,last+1):
+                    self._calculation.consume(((self._indexes.at(driver,index),value),))
+        result=self._calculation.finish()
+        self._consumer(request,event_id,result)
+        self._calculation.close();self._calculation=None
+
+    def _flush_ready(self,final=False):
+        """保留仍缺右端的请求，其余按必要范围计算；EOF不补记录。
+
+        参数: final只在真实来源EOF后使用。返回: None。异常: 原查询错，费用留到close。
+        """
+        pending=[]
+        try:
+            while self._queue:
+                item=heapq.heappop(self._queue)
+                end,serial,request,event_id,start,cost=item
+                driver=self._choices[request.calculation_id].driver
+                last=None if self._indexes is None or driver is None else self._indexes.last(driver)
+                if not final and self._steps[request.calculation_id] is not None and (last is None or last<end):
+                    pending.append(item)
+                    continue
+                self._calculate(request,event_id,start,end)
+                item=None
+                _release_owned_ram(self,cost,'_pending_cost')
+        except BaseException:
+            self._failed=True
+            raise
+        finally:
+            for item in pending:
+                heapq.heappush(self._queue,item)
+
+    def finish(self):
+        """真实EOF后结算未完成范围，不假造周期尾段。参数: 无。返回: None。异常: 原计算错。"""
+        self._open()
+        self._flush_ready(final=True)
+
+    @property
+    def closed(self):
+        """返回关闭状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """只关闭自己的临时文件，成功后才撤销责任。参数: 无。返回: None。异常: 原关闭错可重试。"""
+        if self._closed:
+            return
+        if self._calculation is not None:
+            self._calculation.close();self._calculation=None
+        self._queue.clear()
+        self._plan=self._requests=self._consumer=self._choices=None
+        _release_owned_ram(self,self._pending_cost,'_pending_cost')
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost')
+        self._closed=True

chronaxis/execution/record_export_samples.py

@@ -0,0 +1,94 @@
+"""只在片段信号导出需要回看时保存所选样本；每行一个值和一个实际时间。
+
+别名、来源、单位和枚举标签留在有限声明中，行内用序号引用。
+定长数据按实际时间二分，不构造原文、输入指纹或逐条来源JSON。
+"""
+from struct import Struct
+from tempfile import TemporaryFile
+from ..core.models import SourceRef
+from ..core.numeric import ScalarValue
+from ..core.types import SignalDType as D,QualityFlag as Q
+from ..results.budget import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+from ..results.errors import ResultClosedError
+from .history import _metadata_bytes
+from .record_sample import RecordSample
+
+
+class RecordExportSamples:
+    """拥有一个惰性定长临时文件；范围查询期间只恢复一条所需样本。"""
+    def __init__(self,budget,path,definitions,session):
+        """只保有限定义和文件槽。参数: 预算/私有目录/所选定义/会话。返回: owner。异常: 原构造错。"""
+        self._budget,self._path=budget,path
+        self._held_cost=self._fixed_cost=0
+        self._file=None;self._count=0;self._last=None
+        self._closed=self._failed=False
+        self._definitions=self._names=self._refs=self._codes=self._labels=None
+        try:
+            _reserve_owned_ram(self,65536+32*_metadata_bytes(definitions),'_fixed_cost')
+            self._definitions=definitions
+            self._names={d.name:i for i,d in enumerate(definitions)}
+            self._refs=tuple(SourceRef(session,d.source,d.field) for d in definitions)
+            self._codes=tuple(Struct('>'+{D.FLOAT64:'d',D.INT64:'q',D.UINT64:'Q',D.BOOL:'q',D.ENUM:'q'}[d.dtype]) for d in definitions)
+            self._labels=tuple(tuple(dict.fromkeys(label for _,label in d.choices)) if d.dtype is D.ENUM else () for d in definitions)
+            self._codec=Struct('>IqQ8sI')
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_export_samples_cleanup_owner','片段导出样本');raise
+
+    def append(self,sample):
+        """保存一次所选真实更新，保同刻原序号。参数: HistorySample。返回: None。异常: 顺序/预算/短写。"""
+        if self._closed or self._failed:raise ResultClosedError('导出样本已关闭或失败')
+        try:
+            if self._last is not None and sample.time_ns<self._last:raise ValueError('导出样本时间回退')
+            index=self._names[sample.name]
+            value=sample.array_value if sample.value.valid else 0
+            if self._definitions[index].dtype is D.BOOL:value=int(value)
+            data=self._codec.pack(index,sample.time_ns,sample.sequence,self._codes[index].pack(value),int(sample.value.quality))
+            self._budget.reserve_spool(len(data))
+            if self._file is None:self._file=TemporaryFile(mode='w+b',dir=self._path,prefix='export-samples-')
+            self._file.seek(0,2)
+            if self._file.write(data)!=len(data):raise OSError('导出样本短写')
+            self._count+=1;self._last=sample.time_ns
+        except BaseException:
+            self._failed=True;raise
+
+    def _fields(self,index):
+        """只按已登记位置读取一条。参数: 行号。返回: 解包字段。异常: 越界/短读。"""
+        if self._closed or self._failed:raise ResultClosedError('导出样本已关闭或失败')
+        if not 0<=index<self._count:raise IndexError('导出样本行号越界')
+        self._file.seek(index*self._codec.size)
+        payload=self._file.read(self._codec.size)
+        if len(payload)!=self._codec.size:raise ValueError('导出样本短读')
+        return self._codec.unpack(payload)
+
+    def _lower(self,time_ns):
+        """二分首个不早于time_ns的行。参数: 实际时间。返回: 索引。异常: 原读取错。"""
+        lo,hi=0,self._count
+        while lo<hi:
+            mid=(lo+hi)//2
+            if self._fields(mid)[1]<time_ns:lo=mid+1
+            else:hi=mid
+        return lo
+
+    def rows(self,interval):
+        """只回读半开片段内所选样本，不全量核验或扫描。参数: Interval。返回: 迭代器。异常: 原读取/模型错。"""
+        for row in range(self._lower(interval.start_ns),self._lower(interval.end_ns)):
+            index,time,sequence,payload,quality=self._fields(row)
+            definition=self._definitions[index];dtype=definition.dtype
+            physical=self._codes[index].unpack(payload)[0]
+            if dtype is D.BOOL:physical=bool(physical)
+            value=self._labels[index][physical] if dtype is D.ENUM and quality==0 else physical
+            scalar=ScalarValue(value if quality==0 else None,dtype,quality==0,Q(quality),self._labels[index])
+            yield RecordSample(definition.name,time,sequence,scalar,definition.unit,self._refs[index],
+                physical if definition.dtype is D.ENUM else None)
+
+    @property
+    def closed(self):
+        """返回实际资源状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """关闭自有临时文件并释放定义；不碰原输入。参数: 无。返回: None。异常: 原关闭错，可重试。"""
+        if self._closed:return
+        if self._file is not None:self._file.close();self._file=None
+        self._definitions=self._names=self._refs=self._codes=self._labels=None
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost');self._closed=True

chronaxis/execution/record_exports.py

@@ -0,0 +1,155 @@
+"""只为显式导出接同次读取的帧或样本；复用既有writer和结果发布。
+
+会话范围在真实EOF后确定；片段由窗口消费者直接交付，不复制片段表。
+不再次读原日志或解码，默认精简导出不产生逐帧旁表。
+"""
+from ..core.models import Interval
+from .record_signal_export import RecordSignalExport
+from .legacy_frame_samples import LegacyFrameSamples
+from ..results.frame_rebuild import FrameRebuildRead
+from ..results.artifact_exports import ArtifactExportStore
+from ..results.frame_exports import export_can_frames
+from ..results.errors import ResultClosedError
+from ..results.budget import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+
+
+class RecordExports:
+    """拥有导出索引、在线信号写出与当前帧游标；原帧仓由来源游标所有。"""
+    def __init__(self,plan,budget,path,cursors):
+        """建立仅显式请求的索引。参数: 计划/预算/新路径/借用来源。返回: owner。异常: 原构造错。"""
+        self._plan,self._budget,self._cursors=plan,budget,cursors
+        self._held_cost=self._fixed_cost=0
+        self._exports=self._reader=self._export_owner=self._signal=self._rebuild=None
+        self._closed=self._failed=self._finished=False
+        self._option=plan.outputs.can_frames
+        try:
+            _reserve_owned_ram(self,65536,'_fixed_cost')
+            self._require_clock()
+            try:
+                self._exports=ArtifactExportStore(budget,path,plan.dataset.session_id,plan.metadata.get('device_label','pending'),integrity=plan.diagnostics.integrity)
+            except BaseException as error:
+                self._exports=getattr(error,'artifact_export_store_cleanup_owner',None);raise
+            if plan.outputs.signal_csv is not None:
+                try:
+                    self._signal=RecordSignalExport(plan,budget,cursors,self._exports,path)
+                except BaseException as error:
+                    self._signal=getattr(error,'record_signal_export_cleanup_owner',None);raise
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_exports_cleanup_owner','记录流原帧导出');raise
+
+    def _require_clock(self):
+        """多来源片段须有可比时钟；单来源不强求映射。参数: 无。返回: None。异常: 缺同步依据。"""
+        plan=self._plan
+        options=[]
+        if self._option is not None:
+            options.append((self._option,{self._option.source}))
+        if plan.outputs.signal_csv is not None:
+            option=plan.outputs.signal_csv
+            options.append((option,{plan.bindings.resolve(n).source for n in option.spec.signals}))
+        for option,sources in options:
+            if option.scope!='segments':continue
+            for window in (w for w in plan.windows if option.window is None or w.window_id==option.window):
+                checked_sources=set(sources)
+                rule=next(r for r in plan.rules if r.rule_id==window.event)
+                names=set(rule.dependencies)
+                choice=dict(plan.intervals.resolved)[window.window_id]
+                if choice.driver:names.add(choice.driver)
+                checked_sources.update(plan.bindings.resolve(n).source for n in names)
+                if not names:checked_sources.update(s.name for s in plan.sources)
+                evidenced={item.source for item in plan.bindings.synchronization}
+                keys=set()
+                for source in plan.bindings.sources:
+                    if source.name not in checked_sources:continue
+                    clock=source.timebase
+                    if source.name in evidenced or clock==plan.dataset.timebase or clock.time_type.value=='absolute' and plan.dataset.timebase.time_type.value=='absolute':
+                        keys.add(('dataset',))
+                    else:
+                        keys.add(('utc',) if clock.time_type.value=='absolute' else ('relative',clock.timebase_id,clock.origin))
+                if len(keys)>1:raise ValueError('导出与片段缺少共同时间基准')
+
+    def _export(self,actual,segment_id=None):
+        """借同次封口原帧写一份所需输出。参数: 实际范围/父片段。返回: None。异常: 原消费/发布错。"""
+        option=self._option
+        cursor=next(c for c in self._cursors if c.source_name==option.source)
+        store=cursor._raw_store
+        if store is None or store.closed or store.state!='sealed':
+            raise ValueError('原帧导出缺少同次封口输入')
+        interval=actual or Interval(self._plan.dataset.domain.start_ns,self._plan.dataset.domain.start_ns)
+        try:
+            if option.resampling is None:
+                self._reader=store.iter_frames()
+            else:
+                context=cursor._dbc_context
+                if context is None:raise ValueError('报文重采样缺同次编码定义')
+                if cursor.source_kind=='can_blf':
+                    source=next(s for s in self._plan.sources if s.name==option.source)
+                    try:
+                        self._reader=LegacyFrameSamples(store,cursor._message_store,context,self._budget,
+                            read_identity=cursor._read_identity,session_id=self._plan.dataset.session_id,channel=source.config.channel,trace=False)
+                    except BaseException as error:
+                        self._reader=getattr(error,'legacy_frame_samples_cleanup_owner',None);raise
+                else:
+                    self._reader=store.iter_samples()
+                try:
+                    self._rebuild=FrameRebuildRead(self._reader,option.resampling,interval,context.pairs(),self._budget,
+                        self._exports.path/f'rebuild-{self._exports.count:08d}',backend=self._plan.execution.backend,
+                        periods=context.periods,integrity=self._plan.diagnostics.integrity,trace=False)
+                except BaseException as error:
+                    self._rebuild=getattr(error,'frame_rebuild_cleanup_owner',None);raise
+                self._reader=None
+            files=[]
+            export_can_frames(self._rebuild or self._reader,option.spec,interval,self._exports.next_path(),self._budget,
+                source=option.source,device_label=self._plan.metadata.get('device_label','pending'),compact=True,
+                integrity=self._plan.diagnostics.integrity,file_consumer=files.extend)
+            if self._rebuild is not None:self._rebuild.close();self._rebuild=None
+            if self._reader is not None:self._reader.close();self._reader=None
+            self._exports.append('can_frames',option.scope,actual,segment_id=segment_id,completed_files=files)
+        except BaseException as error:
+            self._export_owner=getattr(error,'export_cleanup_owner',None)
+            self._failed=True;error.record_exports_cleanup_owner=self;raise
+
+    def session(self):
+        """EOF后裁实际会话范围，空输入保持空输出。参数: 无。返回: None。异常: 原导出错。"""
+        if self._signal is not None:self._signal.finish()
+        if self._option is None or self._option.scope!='session': return
+        cursor=next(c for c in self._cursors if c.source_name==self._option.source)
+        actual=None
+        if cursor.observed_start is not None and cursor.observed_end is not None:
+            domain=self._plan.dataset.domain
+            start,end=max(domain.start_ns,cursor.observed_start),min(domain.end_ns,cursor.observed_end)
+            if start<=end: actual=Interval(start,end)
+        self._export(actual)
+
+    def segment(self,segment):
+        """直接接最终片段，不保存第二份片段历史。参数: CompactSegment。返回: None。异常: 原导出错。"""
+        if self._signal is not None:self._signal.segment(segment)
+        if self._option is not None and self._option.scope=='segments' and (self._option.window is None or segment.window_id==self._option.window):
+            self._export(segment.actual,segment.segment_id)
+
+    def seal(self):
+        """全部请求完成后封索引。参数: 无。返回: None。异常: 原封口错。"""
+        self._exports.seal();self._finished=True
+
+    def take_exports(self,receiver):
+        """唯一移交已完成结果；失败前责任仍可达。参数: 同预算父owner。返回: None。异常: 状态错。"""
+        if not self._finished or self._closed or receiver._budget is not self._budget or receiver._artifact_exports is not None:
+            raise ResultClosedError('原帧输出尚不可移交')
+        owner=self._exports
+        try:
+            receiver._artifact_exports=owner
+        finally:
+            if receiver._artifact_exports is owner: self._exports=None
+
+    @property
+    def closed(self):
+        """返回实际关闭状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """先关当前输出及索引，再释放自有状态；不关闭借用原帧。参数: 无。返回: None。异常: 原关闭错。"""
+        if self._closed:return
+        for slot in ('_signal','_export_owner','_rebuild','_reader','_exports'):
+            owner=getattr(self,slot)
+            if owner is not None: owner.close();setattr(self,slot,None)
+        self._plan=self._cursors=self._option=None
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost');self._closed=True

chronaxis/execution/record_integral.py

@@ -0,0 +1,196 @@
+"""在有限内存内累计已求值的驱动记录对，保留实际端点直到比例裁剪完成。
+
+输入为已归一化并按驱动同刻政策归组的(time_ns, ScalarValue[, valid_until_ns])有限批；输出仅含
+积分值、单位、完成状态和质量的内部结果。复用原两后端面积及原序误差求和，
+一次只持当前批和一条跨批前值，不创建历史文件、原帧副本、贡献或未知范围列表。
+调用方负责绑定/表达式/有效期判定，并在输入确实结束后调用finish；本组件不
+读取文件或证明来源EOF。实际间隔使用必要更新间的真实差，固定/DBC使用
+所选驱动记录对；有效期都按实际截止裁剪，没有完整记录对时不虚构尾段。
+"""
+
+from dataclasses import dataclass
+
+from ..core.integral_sum import require_partial_limit
+from ..core.integral_sum_reference import ReferenceIntegralSum
+from ..core.integral_sum_numpy import NumpyIntegralSum
+from ..core.integral_terms_reference import compute_integral_terms_reference
+from ..core.integral_terms_numpy import compute_integral_terms_numpy
+from ..core.conditional_integral_terms_reference import compute_conditional_integral_terms_reference
+from ..core.conditional_integral_terms_numpy import compute_conditional_integral_terms_numpy
+from ..core.calculations import CalculationDefinition, CalculationSeries, calculation_unit, classify_calculation_value
+from ..core.calculations import classify_coverage
+from ..core.models import Interval
+from ..core.numeric import ScalarValue
+from ..core.record_intervals import require_record_step
+from ..core.types import SignalDType as D, QualityFlag as Q
+from ..results.budget import ResourceBudget, _reserve_owned_ram, _release_owned_ram, _cleanup_owner
+from ..results.errors import ResultClosedError
+from .record_point_buffer import RecordPointBuffer
+from .history import _metadata_bytes
+
+
+@dataclass(frozen=True)
+class RecordIntegralResult:
+    """内部积分结果，不附逐条输入、时间对照或默认贡献记录；不充当公开发布清单。"""
+
+    value: float | None  # 已换到请求单位；未知与有效零分开。
+    unit: str  # 输出单位，仅最终转换一次。
+    status: str  # 沿既有complete/partial/indeterminate政策。
+    reason: str  # 正常、观测不足或数值失败等必要原因。
+    quality: Q  # 输入和数值计算质量，不包含逐条副本。
+    coverage_status: str | None = None
+
+
+class RecordIntegral(RecordPointBuffer):
+    """拥有有限驱动点缓冲和累计状态；失败后只能关闭，完成后只读结果。
+
+    consume借用外部有限批；留下的点只含整数时间和冻结数值，费用归本实例。
+    同刻冲突须由上游既有同刻政策解决，不能在此任意覆盖或累计零跨度记录。
+    """
+
+    def __init__(self, budget, spec, input_unit, dtype, step_ns, *, backend='numpy',
+                 batch_intervals=64, partial_limit=4096, conditioned=False):
+        """预付有界状态及点缓冲，数值临时数组在每次归约前另预约。
+
+        参数: budget共享账本，spec为integral请求；input_unit/dtype为已
+            求值列单位/类型；step_ns为None（实际差）或固定/已核实DBC正周期；后端独立选择；
+            batch_intervals为1—4096区间数，partial_limit为误差项容量；conditioned指定显式BOOL条件。
+        返回: 新owner。异常: 配置/预算/取消错误；构造清理失败通过异常的
+            record_integral_cleanup_owner提供重试入口。
+        """
+        if not isinstance(budget, ResourceBudget) or not isinstance(spec, CalculationDefinition):
+            raise TypeError('记录流积分需要共享预算和CalculationDefinition')
+        if spec.operation != 'integral':
+            raise ValueError('记录流积分需要integral')
+        if backend not in ('reference', 'numpy') or dtype not in (D.INT64, D.UINT64, D.FLOAT64):
+            raise ValueError('记录流积分需要明确后端和数值dtype')
+        if type(batch_intervals) is not int or not 1 <= batch_intervals <= 4096:
+            raise ValueError('记录流区间批上限需要1到4096')
+        if type(conditioned) is not bool:
+            raise TypeError('条件选择需要bool')
+        require_record_step(step_ns, ())
+        limit = require_partial_limit(partial_limit)
+        self._unit, self._factor = calculation_unit(spec, input_unit)
+        self._budget, self._spec, self._input_unit, self._dtype = budget, spec, input_unit, dtype
+        self._step_ns, self._limit = step_ns, batch_intervals
+        self._conditioned = conditioned
+        self._held_cost = self._fixed_cost = self._workspace_cost = 0
+        self._closed = self._closing = self._failed = self._finished = False
+        self._rows = self._sum = self._result = None
+        self._last_time = None
+        self._covered_ns = 0
+        self._known_ns = self._selected_ns = self._selected_unknown_ns = self._false_ns = 0
+        self._quality = Q.NONE
+        self._coverage_value_ns=0 if spec.minimum_coverage>0 else None
+        try:
+            # 固定费覆盖误差求和的有限候选及点缓冲，不按总记录数扩大。
+            _reserve_owned_ram(self, 65536 + limit * 256 + (batch_intervals + 1) * 1024
+                               + 16 * _metadata_bytes((spec, input_unit)), '_fixed_cost')
+            self._rows = []
+            self._sum = (ReferenceIntegralSum if backend == 'reference' else NumpyIntegralSum)(limit)
+            self._compute = compute_integral_terms_reference if backend == 'reference' else compute_integral_terms_numpy
+            if conditioned:
+                self._compute = (compute_conditional_integral_terms_reference if backend == 'reference'
+                                 else compute_conditional_integral_terms_numpy)
+        except BaseException as exc:
+            _cleanup_owner(self, exc, 'record_integral_cleanup_owner', '记录流积分')
+            raise
+
+    def _flush(self):
+        """消费当前完整记录对并留下一个共享端点，首条/末条不凭空增加周期。
+
+        参数: 无，使用当前自有缓冲。返回: None。异常: 数值结构/预算/取消；
+            清理异常不覆盖原错误，临时申请保留在owner供close重试。
+        """
+        if len(self._rows) < 2:
+            return
+        series = terms = None
+        primary = None
+        try:
+            _reserve_owned_ram(self, 65536 + len(self._rows) * 8192, '_workspace_cost')
+            times = tuple(item[0] for item in self._rows)
+            values = tuple(item[1] for item in self._rows)
+            # 截止仅为本批计算所需；不保存来源副本或另一列累计时钟。
+            deadlines = (tuple(item[2] for item in self._rows)
+                         if any(item[2] is not None for item in self._rows) else None)
+            conditions = tuple(item[3] for item in self._rows) if self._conditioned else None
+            condition_deadlines = (tuple(item[4] for item in self._rows)
+                if self._conditioned and any(item[4] is not None for item in self._rows) else None)
+            series = CalculationSeries(Interval(times[0], times[-1]), times, values,
+                                  (True,) * len(times), self._input_unit, conditions=conditions)
+            # 窗口仍由原spec裁剪，分母保留完整记录对。按请求省去未知范围对象。
+            options = {'condition_valid_until_ns': condition_deadlines} if self._conditioned else {}
+            terms = self._compute(series, self._spec, step_ns=self._step_ns,
+                                  retain_unknown_ranges=False, valid_until_ns=deadlines, **options)
+            self._sum.push_values(terms.areas, terms.valid)
+            facts = terms.facts
+            if self._coverage_value_ns is not None:
+                self._coverage_value_ns+=facts.value_valid_duration_ns
+            if facts.actual_window is not None:
+                span = facts.actual_window.end_ns - facts.actual_window.start_ns
+                self._covered_ns += span
+                self._known_ns += facts.condition_known_duration_ns if self._conditioned else span
+                self._selected_ns += facts.selected_duration_ns if self._conditioned else facts.value_valid_duration_ns
+                self._selected_unknown_ns += (facts.selected_value_unknown_duration_ns if self._conditioned
+                                              else span - facts.value_valid_duration_ns)
+                if self._conditioned:
+                    self._false_ns += facts.false_duration_ns
+            self._quality |= facts.quality
+            self._rows[:] = self._rows[-1:]
+        except BaseException as exc:
+            primary = exc
+            self._failed = True
+            raise
+        finally:
+            # 断开有限临时列后再退款；释放失败不允许调用方取得成功结果。
+            series = terms = times = values = facts = deadlines = conditions = condition_deadlines = options = None
+            try:
+                _release_owned_ram(self, self._workspace_cost, '_workspace_cost')
+            except BaseException as cleanup:
+                self._failed = True
+                if primary is None:
+                    raise
+                primary.add_note('记录流积分临时费用清理失败：' + type(cleanup).__name__)
+
+    def finish(self):
+        """输入调用方确认结束后结算最后完整记录对，返回精简内部结果。
+
+        参数: 无；不能代替读取器EOF/关闭成功的确认。返回: RecordIntegralResult，
+            重复调用返回同一结果。异常: 预算/数值结构/取消错误，不发布前缀。
+        """
+        self._require_open()
+        if self._finished:
+            return self._result
+        try:
+            self._flush()
+            number = self._sum.finish(self._unit, self._factor)
+            value, status, reason = classify_calculation_value(self._spec, number.value, self._covered_ns,
+                self._known_ns, self._selected_ns, self._selected_unknown_ns,
+                calculation_failed=number.calculation_failed,
+                all_false=self._conditioned and self._covered_ns > 0 and self._false_ns == self._covered_ns)
+            coverage=None if self._coverage_value_ns is None else classify_coverage(
+                self._spec,self._covered_ns,self._coverage_value_ns,self._known_ns)
+            self._result = RecordIntegralResult(value, self._unit, status, reason, self._quality | number.quality,coverage)
+            self._finished = True
+            return self._result
+        except BaseException:
+            self._failed = True
+            raise
+
+    @property
+    def closed(self):
+        """读取自有费用完全释放状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """释放自有缓冲/数值状态及费用，不操作外部输入和目录。
+
+        参数: 无。返回: None；重复关闭安全。异常: 预算释放失败可重试，不假报已关闭。
+        """
+        if self._closed:
+            return
+        self._closing = True
+        self._rows = self._sum = self._result = None
+        _release_owned_ram(self, self._workspace_cost, '_workspace_cost')
+        _release_owned_ram(self, self._fixed_cost, '_fixed_cost')
+        self._closed = True