chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/results/rows.py

@@ -0,0 +1,57 @@
+"""为当前平坦结果确定所属表和稳定排序键，不构造额外结果包装。
+
+输入为已计算的冻结行；输出为固定表名和纯标量tuple，不读取来源或复制数值历史。
+每个表按会话、业务对象和真实顺序排序，父ID明确关联事件或片段。
+"""
+
+from .summary import SummaryCalculationRow, SummaryCoverageCalculationRow, SummaryEventRow, SummarySequenceRow, SummarySegmentRow, SummaryContributionRow, SummaryInputRow, SummarySelectionRow, SUMMARY_MODELS
+
+ResultRow = SummaryCalculationRow | SummaryEventRow | SummarySequenceRow | SummarySegmentRow | SummaryCoverageCalculationRow | SummaryContributionRow | SummaryInputRow | SummarySelectionRow
+
+
+def row_table(row: ResultRow) -> str:
+    """返回行所属表名，不依赖外部对象属性反射。
+
+    参数: row为已登记的结果行之一。返回: 当前固定表名。
+    异常: TypeError为未注册类型。
+    """
+    # 精确类型防止子类增加未经编解码登记的字段。
+    try:
+        if type(row) in SUMMARY_MODELS:
+            return SUMMARY_MODELS[type(row)][0]
+        raise TypeError('未注册结果行类型')
+    finally:
+        # 返回名已先求值；原错误/TB只保位置，不替抵费后的借入行继续持有完整refs。
+        row = None
+
+
+def row_sort_key(row: ResultRow) -> tuple:
+    """给出session、规则、起点、序号为主的确定排序键。
+
+    参数: row为typed结果行。返回: 不含浮点值或可变对象的tuple。
+    异常: TypeError为非法行；不在这里排序或重复原数据读取。
+    """
+    # 各表分别排序；序号为相同业务键提供稳定顺序。
+    try:
+        row_table(row)
+        if type(row) in SUMMARY_MODELS and SUMMARY_MODELS[type(row)][0]=='selections':
+            return (row.session_id,row.calculation_id,row.scope,row.parent_id or '',row.time_ns,
+                    row.sequence,row.dataset_id,row.entity_id)
+        if type(row) in SUMMARY_MODELS and SUMMARY_MODELS[type(row)][0]=='input_trace':
+            return (row.session_id,row.source,row.original_sequence,row.sequence,row.dataset_id,row.entity_id)
+        if type(row) in SUMMARY_MODELS and SUMMARY_MODELS[type(row)][0]=='contributions':
+            return (row.session_id,row.calculation_id,row.evaluation_index,row.original_sequence,
+                    row.sequence,row.dataset_id,row.entity_id)
+        if type(row) in SUMMARY_MODELS and SUMMARY_MODELS[type(row)][0]=='calculations':
+            return (row.session_id, row.calculation_id, row.scope, row.parent_id or '',
+                    0, row.sequence, row.dataset_id, row.entity_id)
+        if type(row) is SummarySegmentRow:
+            return (row.session_id,row.window_id,row.start_ns if row.start_ns is not None else -(1<<63),
+                    row.sequence,row.dataset_id,row.entity_id)
+        if type(row) in (SummaryEventRow, SummarySequenceRow):
+            time = row.start_ns if type(row) is SummaryEventRow else row.decided_ns
+            return (row.session_id,row.rule_id,time,row.sequence,row.dataset_id,row.entity_id)
+        raise TypeError('未注册结果排序类型')
+    finally:
+        # 正常key元组不变；取消保原TB，但本层不再借持行、事件或片段的完整实体树。
+        row = time = None

chronaxis/results/signal_exports.py

@@ -0,0 +1,209 @@
+"""将指定信号的已解码历史写为原始采样及可选连续量网格CSV长表。
+
+输入为同次读取生成的HistorySample/HistoryProgress流及显式导出范围，不打开日志
+或DBC；输出original.csv及清单，启用线性时另写resampled.csv。异步信号分别
+一行，状态/计数不补点；显式连续量交给独立有界网格owner。
+值无效时留空并保质量原因和完整来源引用；原无效值以既有安全编码保存。
+逐行缓冲和编码先付预算，输入正常/失败/取消均关闭，整个目录最终独占发布。
+"""
+
+import csv
+from dataclasses import dataclass
+from io import StringIO
+import json
+
+from ..core.models import Interval
+from ..core.validation import require_identifier
+from ..execution.record_sample import RecordSample
+from ..execution.history_records import HistorySample, HistoryProgress, estimate_record_bytes
+from ..execution.history import _metadata_bytes
+from .budget import _reserve_owned_ram, _release_owned_ram, _cleanup_owner
+from .codec import _pack
+from .export_files import ExportFiles
+from .signal_grid import SignalGridSpec, SignalGrid
+
+
+@dataclass(frozen=True)
+class SignalCSVExportSpec:
+    """指定待导出的已绑定别名；字段含义和单位沿用原绑定，不由文件名推断。"""
+
+    signals: tuple[str,...]  # 唯一非空别名，最多4096，保持配置顺序。
+    resampling: SignalGridSpec | None = None  # 默认原始采样，显式连续量才进入线性网格。
+
+    def __post_init__(self):
+        """只核静态选择。参数: 无。返回: None。异常: 类型/数量/重复或非法别名。
+        """
+        if type(self.signals) is not tuple or not 1 <= len(self.signals) <= 4096:
+            raise ValueError('信号CSV需要1到4096个显式别名')
+        for name in self.signals:
+            require_identifier(name,'signal_csv_export.signal')
+        if len(set(self.signals)) != len(self.signals):
+            raise ValueError('信号CSV别名重复')
+        if self.resampling is not None and (type(self.resampling) is not SignalGridSpec
+                or any(name not in self.signals for name in self.resampling.continuous)):
+            raise ValueError('重采样必须是所选信号的明确子集')
+
+
+_COLUMNS = ('time_ns','source','signal','field','value','unit','valid','quality','status',
+            'sequence','source_ref_json','original_value_json')
+
+
+def _csv_bytes(values):
+    """编码一个有界CSV行。参数: values有限标量列表。返回: UTF8 bytes。异常: CSV/Unicode/内存错。
+    """
+    # newline交由CSV处理，引号、逗号和换行按标准转义，不拼接未经转义的来源文字。
+    stream = StringIO(newline='')
+    csv.writer(stream,lineterminator='\n').writerow(values)
+    return stream.getvalue().encode('utf-8')
+
+
+def _sample_row(sample, compact=False):
+    """提取原样本可读列及完整证据。参数: sample已校验HistorySample，compact关闭原文/来源列。返回: 行tuple。异常: 安全编码错。
+    """
+    value = sample.value
+    if compact:
+        return (sample.time_ns,sample.name,value.value if value.valid else '',sample.unit,int(value.quality))
+    return (sample.time_ns,sample.source_ref.source_name,sample.name,sample.source_ref.field,
+            value.value if value.valid else '',sample.unit,value.valid,int(value.quality),
+            'observed' if value.valid else 'invalid',sample.sequence,
+            json.dumps(_pack(sample.source_ref),ensure_ascii=False,allow_nan=False,separators=(',',':')),
+            json.dumps(_pack(sample.original_value),ensure_ascii=False,allow_nan=False,separators=(',',':'))
+                if sample.original_present else '')
+
+
+def _reference_json(sample):
+    """编码实际端点引用。参数: sample或None。返回: JSON文本或空字符串。异常: 安全编码错。
+    """
+    return '' if sample is None else json.dumps(_pack(sample.source_ref),ensure_ascii=False,
+                                                allow_nan=False,separators=(',',':'))
+
+
+def _write_grid(owner, rows, counts, compact=False):
+    """有界编码网格行及两端引用。参数: owner/rows/固定计数字典及compact引用开关。返回: None。异常: 编码/预算/I/O/取消错。
+    """
+    owner.select_file('resampled.csv')
+    for row in rows:
+        _reserve_owned_ram(owner,8192+_metadata_bytes(row)*16,'_row_cost')
+        try:
+            # 左右时间和引用均来自实际采样，目标时间不伪装成原行记录。
+            left,right=row.left,row.right
+            values=(row.time_ns,row.name,'' if row.value is None else row.value,row.unit,
+                row.status,row.reason,row.quality)
+            if not compact:
+                values+=('' if left is None else left.time_ns,'' if right is None else right.time_ns,
+                    _reference_json(left),_reference_json(right))
+            owner.append(_csv_bytes(values))
+            counts[row.status]+=1
+        finally:
+            _release_owned_ram(owner,owner._row_cost,'_row_cost')
+
+
+class SignalCSVWriter(ExportFiles):
+    """复用原写文件和线性网格，支持逐样本推进而不强制暂存整份输入。"""
+
+    def __init__(self,spec,interval,destination,budget,*,device_label,check_cancel=None,
+                 definitions=(),backend='numpy',compact=False,integrity=True):
+        """预付输出状态并建立所需表。参数: 导出规格/范围/目标/预算与后端。返回: owner。异常: 原构造错。"""
+        if type(compact) is not bool:
+            raise TypeError('compact必须为bool')
+        if type(spec) is not SignalCSVExportSpec or type(interval) is not Interval:
+            raise TypeError('信号导出需要选择及明确Interval')
+        if (device_label not in ('home','work') or backend not in ('reference','numpy')
+                or check_cancel is not None and not callable(check_cancel)):
+            raise ValueError('导出需要实际设备标签及可选取消回调')
+        super().__init__(destination,budget,integrity=integrity)
+        self.spec,self.interval,self.definitions=spec,interval,definitions
+        self.device_label,self.backend,self.compact=device_label,backend,compact
+        self._check_cancel=check_cancel
+        self._count=self._invalid=0
+        self._grid_counts={'observed':0,'estimated':0,'missing':0}
+        self._selected=None
+        try:
+            _reserve_owned_ram(self,4096+sum(len(n.encode('utf-8'))*16+256 for n in spec.signals),'_fixed_cost')
+            self._selected=set(spec.signals)
+            if spec.resampling is not None:
+                try:
+                    self.worker=SignalGrid(spec.resampling,definitions,interval,budget,
+                        backend=backend,check_cancel=check_cancel)
+                except BaseException as error:
+                    self.worker=getattr(error,'signal_grid_cleanup_owner',None);raise
+                self.open_file('resampled.csv')
+                self.append(_csv_bytes(('time_ns','signal','value','unit','status','reason','quality')+
+                    (() if compact else ('left_time_ns','right_time_ns','left_ref_json','right_ref_json'))))
+            if not compact or spec.resampling is None or self._selected-set(spec.resampling.continuous):
+                self.select_file('original.csv')
+                self.append(_csv_bytes(('time_ns','signal','value','unit','quality') if compact else _COLUMNS))
+        except BaseException as error:
+            _cleanup_owner(self,error,'export_cleanup_owner','信号CSV构造');raise
+
+    def push(self,sample):
+        """写一个已验证样本或推进原网格。参数: HistorySample/Progress。返回: None。异常: 原输入/写入错。"""
+        if self._closed:
+            raise ValueError('信号导出已关闭')
+        if self._check_cancel is not None: self._check_cancel()
+        if type(sample) is HistoryProgress: return
+        if type(sample) not in (HistorySample,RecordSample):
+            raise TypeError('信号导出只接受已解码历史记录')
+        if sample.name not in self._selected or not self.interval.start_ns<=sample.time_ns<self.interval.end_ns:
+            return
+        if self.worker is not None and sample.name in self.spec.resampling.continuous:
+            _write_grid(self,self.worker.push(sample),self._grid_counts,self.compact)
+            return
+        _reserve_owned_ram(self,estimate_record_bytes(sample)*2,'_row_cost')
+        try:
+            self.select_file('original.csv')
+            self.append(_csv_bytes(_sample_row(sample,self.compact)))
+        finally:
+            _release_owned_ram(self,self._row_cost,'_row_cost')
+        self._count+=1;self._invalid+=not sample.value.valid
+
+    def observed_end(self,end_ns):
+        """在线调用方在末组交付前收紧EOF；不能用它改已经写出的记录。
+
+        参数: 实际末端，须在初始范围中。返回: None。异常: 越界。
+        """
+        if not self.interval.start_ns<=end_ns<=self.interval.end_ns:
+            raise ValueError('导出末端超出声明范围')
+        self.interval=Interval(self.interval.start_ns,end_ns)
+        if self.worker is not None: self.worker.interval=self.interval
+
+    def complete(self):
+        """结束网格、写一次必要清单并原子发布。参数: 无。返回: 输出Path。异常: 原完成错。"""
+        interval,spec=self.interval,self.spec
+        metadata={'export_type':'signal_csv','device_label':self.device_label,'signals':spec.signals,
+            'range_ns':(interval.start_ns,interval.end_ns),'resampling':False,
+            'rows':self._count,'observed':self._count-self._invalid,'invalid':self._invalid}
+        if self.worker is not None:
+            _write_grid(self,self.worker.finish(),self._grid_counts,self.compact)
+            grid=spec.resampling
+            metadata.update(resampling={'mode':'linear','continuous':grid.continuous,
+                'period_ns':grid.period_ns,'origin_ns':grid.origin_ns,'max_gap_ns':grid.max_gap_ns,
+                'causal':False,'numeric':'float64_estimate','ordering':'per_signal_monotonic'},
+                resampled_counts=self._grid_counts,backend=self.backend,
+                bindings=tuple({'name':d.name,'source':d.source,'field':d.field,'unit':d.unit,
+                    'dtype':d.dtype.value,'same_time_policy':d.same_time_policy}
+                    for d in self.definitions if d.name in grid.continuous))
+        if self.compact: metadata['row_format']='compact-v2'
+        return self.finish(metadata)
+
+
+def export_signal_csv(records,spec,interval,destination,budget,*,device_label,check_cancel=None,
+                      definitions=(),backend='numpy',compact=False,integrity=True,file_consumer=None):
+    """消费既有记录流并复用在线写出器，保原公开调用与关闭责任。
+
+    参数: 可关闭记录流、规格/范围/目标/预算；设备、取消、绑定、后端、精简开关。
+    integrity只在请求时计算文件摘要；file_consumer接收写入时取得的有限文件身份，供内部登记复用。
+    返回: 已完成输出目录。异常: 原格式/输入/预算/取消错；清理失败附真实owner。
+    """
+    if file_consumer is not None and not callable(file_consumer):
+        raise TypeError('file_consumer须为回调')
+    owner=SignalCSVWriter(spec,interval,destination,budget,device_label=device_label,
+        check_cancel=check_cancel,definitions=definitions,backend=backend,compact=compact,integrity=integrity)
+    try:
+        owner.reader=iter(records)
+        for sample in owner.reader: owner.push(sample)
+        output=owner.complete()
+        if file_consumer is not None: file_consumer(tuple(owner.files))
+        return output
+    except BaseException as error:
+        _cleanup_owner(owner,error,'export_cleanup_owner','信号CSV导出');raise

chronaxis/results/signal_grid.py

@@ -0,0 +1,219 @@
+"""从有序信号历史生成离线线性网格，每个别名只保留相邻两组真实样本。
+
+目标网格origin+k*period贯穿文件和批次，限制在明确半开导出范围。先收齐同刻
+更新，按原绑定的last_by_sequence或冲突政策确定候选；缺两侧、无效更新或
+间隔过大均产出空值及原因。其他状态信号由原始CSV路径保留，不进入本计算。
+所有保留样本及有限网格块计费，失败/取消由上层文件owner接管关闭。
+"""
+
+from dataclasses import dataclass
+from math import isnan
+from ..core.binding import SignalDefinition
+from ..core.models import Interval
+from ..core.types import SignalDType
+from ..core.validation import require_identifier
+from ..core.export_interpolation import linear_reference, linear_numpy
+from ..timebase.conversion import require_int64_ns
+from ..execution.record_sample import RecordSample
+from ..execution.history_records import HistorySample, estimate_record_bytes
+from .budget import _reserve_owned_ram, _release_owned_ram, _cleanup_owner
+from .errors import ResultClosedError
+
+
+@dataclass(frozen=True)
+class SignalGridSpec:
+    """显式连续信号及统一网格；不从DBC名字、dtype或消息周期推断类别/间隔。"""
+
+    continuous: tuple[str,...]
+    period_ns: int | None  # None仅用于尚未解析的DBC声明；运行网格必须已解析。
+    origin_ns: int
+    max_gap_ns: int
+
+    def __post_init__(self):
+        """核静态网格。参数: 无。返回: None。异常: 类型/数量/时间或名称非法。
+        """
+        if type(self.continuous) is not tuple or not 1 <= len(self.continuous) <= 4096:
+            raise ValueError('连续信号需要有限非空tuple')
+        for name in self.continuous:
+            require_identifier(name,'signal_grid.continuous')
+        if len(set(self.continuous))!=len(self.continuous):
+            raise ValueError('连续信号重复')
+        for key in ('period_ns','origin_ns','max_gap_ns'):
+            value=getattr(self,key)
+            if key=='period_ns' and value is None:continue
+            if type(value) is not int:
+                raise TypeError('网格时间需要原生int纳秒')
+            require_int64_ns(value,key)
+        if self.period_ns is not None and self.period_ns<=0 or self.max_gap_ns<=0:
+            raise ValueError('网格周期和最大间隔必须为正')
+
+
+@dataclass(frozen=True)
+class GridRow:
+    """一个目标点的估计或缺失；左右引用是实际样本，不能伪造为目标点观测。"""
+
+    time_ns: int
+    name: str
+    unit: str
+    value: int | float | None
+    status: str
+    reason: str
+    quality: int
+    left: HistorySample | None
+    right: HistorySample | None
+
+
+def _same_fact(left,right):
+    """沿既有同刻事实比较，包括无效NaN。参数: 两HistorySample。返回: bool。异常: 模型属性错误。
+    """
+    a,b=left.value,right.value
+    return (a.valid==b.valid and a.quality==b.quality and type(a.value) is type(b.value)
+            and (a.value==b.value or type(a.value) is float and isnan(a.value) and isnan(b.value)))
+
+
+class SignalGrid:
+    """拥有每信号两个有界样本与单调目标游标；push/finish产出必须在下一次push前耗尽。"""
+
+    def __init__(self,spec,definitions,interval,budget,*,backend='numpy',check_cancel=None):
+        """核声明并预付有限状态。参数: spec/definitions/interval/budget、backend和取消回调。
+
+        返回: owner。异常: 声明/预算错；持续释放失败附signal_grid_cleanup_owner。
+        """
+        if type(spec) is not SignalGridSpec or spec.period_ns is None or type(interval) is not Interval or backend not in ('reference','numpy'):
+            raise TypeError('线性导出需要明确网格、范围和后端')
+        if type(definitions) is not tuple or any(type(d) is not SignalDefinition for d in definitions):
+            raise TypeError('线性导出需要原绑定定义tuple')
+        # 类型声明必须在读取之前核对，空文件也不能让状态/枚举误入连续插值。
+        for name in spec.continuous:
+            matches=tuple(d for d in definitions if d.name==name)
+            if len(matches)!=1 or matches[0].dtype not in (SignalDType.FLOAT64,SignalDType.INT64,SignalDType.UINT64):
+                raise ValueError('连续信号需要唯一数值绑定: '+name)
+        self.spec,self.interval,self.backend,self._check_cancel=spec,interval,backend,check_cancel
+        self._budget=budget
+        self._held_cost=self._fixed_cost=self._sample_cost=0
+        self._closed=self._finished=False
+        self.states=None
+        try:
+            _reserve_owned_ram(self,262144+len(spec.continuous)*4096,'_fixed_cost')
+            # ceil除法保证负时间、非零origin及跨文件都落在同一网格，不重置到首个样本。
+            first=spec.origin_ns+(-((spec.origin_ns-interval.start_ns)//spec.period_ns))*spec.period_ns
+            self.states={name:{'definition':next(d for d in definitions if d.name==name),'next':first,
+                'left':None,'pending':None,'left_conflict':False,'pending_conflict':False,
+                'left_cost':0,'pending_cost':0} for name in spec.continuous}
+        except BaseException as error:
+            _cleanup_owner(self,error,'signal_grid_cleanup_owner','线性网格构造')
+            raise
+
+    def _row(self,state,time_ns,value,status,reason,left,right):
+        """构造单个有限结果。参数: state/目标/值/状态/原因/两端。返回: GridRow。异常: 无。
+        """
+        definition=state['definition']
+        quality=(0 if left is None else int(left.value.quality)) | (0 if right is None else int(right.value.quality))
+        return GridRow(time_ns,definition.name,definition.unit,value,status,reason,quality,left,right)
+
+    def _until(self,state,limit_ns,right,conflict):
+        """输出limit_ns之前的完整有限块。参数: state、独占limit_ns、右端/冲突。返回: GridRow迭代。异常: 数值/取消错误。
+        """
+        left=state['left']; end=min(limit_ns,self.interval.end_ns)
+        if left is None and right is None:
+            reason='no_observation'
+        elif left is None:
+            reason='missing_left'
+        elif right is None:
+            reason='missing_right'
+        elif state['left_conflict'] or conflict:
+            reason='same_time_conflict'
+        elif not left.value.valid or not right.value.valid:
+            reason='invalid_neighbor'
+        elif right.time_ns-left.time_ns>self.spec.max_gap_ns:
+            reason='gap_too_large'
+        else:
+            reason=''
+        while state['next']<end:
+            if self._check_cancel is not None:
+                self._check_cancel()
+            # 每块最多256个点，内存费用已在构造预付；很长范围不会建立整段网格数组。
+            count=min(256,(end-1-state['next'])//self.spec.period_ns+1)
+            times=tuple(state['next']+i*self.spec.period_ns for i in range(count))
+            if reason:
+                values=(None,)*count
+            else:
+                kernel=linear_reference if self.backend=='reference' else linear_numpy
+                values=kernel(times,left.time_ns,right.time_ns,left.value.value,right.value.value)
+            for time,value in zip(times,values):
+                yield self._row(state,time,None if value is None else float(value),
+                                'missing' if reason else 'estimated',reason,left,right)
+                state['next']=time+self.spec.period_ns
+
+    def _resolve(self,state):
+        """结算已收齐的同刻更新。参数: state。返回: GridRow迭代。异常: 数值/预算/取消错误。
+        """
+        right=state['pending']
+        if right is None:
+            return
+        conflict=state['pending_conflict']
+        yield from self._until(state,right.time_ns,right,conflict)
+        # 命中真实点直接使用该点，即使前一端缺失/无效/间隔太大也不阻止真实观测。
+        if state['next']==right.time_ns and state['next']<self.interval.end_ns:
+            reason='same_time_conflict' if conflict else '' if right.value.valid else 'invalid_update'
+            yield self._row(state,right.time_ns,None if reason else right.value.value,
+                            'missing' if reason else 'observed',reason,right,right)
+            state['next']+=self.spec.period_ns
+        _release_owned_ram(self,state['left_cost'],'_sample_cost')
+        state.update(left=right,left_cost=state['pending_cost'],left_conflict=conflict,
+                     pending=None,pending_cost=0,pending_conflict=False)
+
+    def push(self,sample):
+        """处理一个连续信号更新，不跨范围借样本。参数: sample历史记录。返回: 已确定网格行迭代。异常: 声明/顺序/资源错。
+        """
+        if self._closed or self._finished:
+            raise ResultClosedError('网格已关闭或完成')
+        if type(sample) not in (HistorySample,RecordSample) or sample.name not in self.states:
+            raise TypeError('网格需要所选连续信号历史')
+        state=self.states[sample.name]; definition=state['definition']
+        if (sample.value.dtype is not definition.dtype or sample.unit!=definition.unit
+                or sample.source_ref.source_name!=definition.source or sample.source_ref.field!=definition.field):
+            raise ValueError('网格样本与原绑定不一致')
+        if not self.interval.start_ns<=sample.time_ns<self.interval.end_ns:
+            return
+        pending=state['pending']
+        if pending is not None and sample.time_ns<pending.time_ns:
+            raise ValueError('网格输入同信号时间回退')
+        if pending is not None and sample.time_ns==pending.time_ns:
+            # 默认冲突产生明确缺值；last_by_sequence只按稳定原序号选定，不按到达次序。
+            if sample.sequence==pending.sequence:
+                raise ValueError('网格同刻原序号重复')
+            conflict=state['pending_conflict'] or not _same_fact(pending,sample) and definition.same_time_policy=='error'
+            if sample.sequence<pending.sequence:
+                state['pending_conflict']=conflict
+                return
+            cost=estimate_record_bytes(sample)
+            _reserve_owned_ram(self,cost,'_sample_cost')
+            old=state['pending_cost']
+            state.update(pending=sample,pending_cost=cost,pending_conflict=conflict)
+            _release_owned_ram(self,old,'_sample_cost')
+        else:
+            yield from self._resolve(state)
+            cost=estimate_record_bytes(sample)
+            _reserve_owned_ram(self,cost,'_sample_cost')
+            state.update(pending=sample,pending_cost=cost,pending_conflict=False)
+
+    def finish(self):
+        """完整EOF后输出剩余真实点及缺后侧网格。参数: 无。返回: GridRow迭代。异常: 资源/取消错。
+        """
+        if self._closed or self._finished:
+            raise ResultClosedError('网格不可再次完成')
+        for state in self.states.values():
+            yield from self._resolve(state)
+            yield from self._until(state,self.interval.end_ns,None,False)
+        self._finished=True
+
+    def close(self):
+        """释放保留样本与有限状态，可重试。参数: 无。返回: None。异常: 原预算释放错误。
+        """
+        if self._closed:
+            return
+        self.states=None
+        _release_owned_ram(self,self._sample_cost,'_sample_cost')
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost')
+        self._closed=True