chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/execution/record_scope_calculations.py

@@ -0,0 +1,290 @@
+"""只对明确的事件指标保存必要计算值，并按事件真实范围回读。
+
+同表达式、条件和驱动共享一份紧凑历史；每次查询复用已验证的记录积分/统计核。
+窗口尚未确定前只接事件，默认会话统计不创建这个所有者。
+"""
+import heapq
+from functools import partial as bind_consumer
+from dataclasses import replace
+from ..core.models import Interval
+from ..core.calculations import CalculationDefinition
+from ..results.errors import ResultClosedError
+from ..results.spool import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+from .history import _metadata_bytes
+from .driver_expression import DriverExpression
+from .record_value_history import RecordValueHistory
+from .record_integral import RecordIntegral
+from .record_time_calculation import RecordTimeCalculation
+from .record_selection import RecordSelection
+
+
+class RecordScopeCalculations:
+    """拥有必要表达式历史、等待右端的查询及当前统计器；计划/状态为借用。"""
+
+    def __init__(self,plan,state,budget,path,steps,requests,ends,consumer,*,selection_consumer=None):
+        """建立已请求的有限表达式分组。参数: 原计划/状态/预算/路径/周期/请求/EOF/回调。返回: owner。异常: 原构造错。"""
+        self._plan,self._budget,self._path,self._consumer=plan,budget,path,consumer
+        self._selection_consumer=selection_consumer
+        self._requests,self._steps=requests,steps
+        self._held_cost=self._fixed_cost=self._queue_cost=0
+        self._streams,self._request_stream={},{}
+        self._queue=[]
+        self._serial=0
+        self._pending=self._calculation=None
+        self._calculators=[]
+        self._closed=self._failed=False
+        try:
+            _reserve_owned_ram(self,131072+64*_metadata_bytes(requests),'_fixed_cost')
+            choices=dict(plan.intervals.resolved)
+            from ..planning.intervals import IntervalChoice
+            sample_ops=('sample_minimum','sample_maximum','sample_mean','select')
+            for request in requests:
+                if request.operation in sample_ops:choices[request.calculation_id]=IntervalChoice('actual')
+            sample_keys={(r.signal.identity,None if r.condition is None else r.condition.identity,None)
+                         for r in requests if r.operation in sample_ops}
+            for request in requests:
+                expression=request.signal if request.signal is not None else request.condition
+                condition=request.condition if request.signal is not None else None
+                driver=choices[request.calculation_id].driver
+                key=(expression.identity,None if condition is None else condition.identity,driver)
+                self._request_stream[request.calculation_id]=key
+                if key in self._streams:
+                    continue
+                self._streams[key]=[None,None,None,expression,condition,
+                    driver is None and not expression.dependencies and (condition is None or not condition.dependencies)]
+                stream=self._streams[key]
+                for index,static in enumerate((expression,condition)):
+                    if static is not None:
+                        stream[index]=self._new(DriverExpression,'driver_expression_cleanup_owner',static,state,driver,
+                            backend=plan.execution.backend,derived=tuple(item.definition for item in plan.derived),observation_ends=ends)
+                stream[2]=self._new(RecordValueHistory,'record_value_history_cleanup_owner',
+                    budget,path,expression.root.dtype,condition is not None,sample_updates=key in sample_keys,
+                    labels=expression.root.labels)
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_scope_calculations_cleanup_owner','事件指标构造')
+            raise
+
+    def _new(self,factory,recovery,*args,**kwargs):
+        """接住未返回的实际子owner。参数: 工厂/恢复字段/构造参数。返回: owner。异常: 原错。"""
+        try:
+            return factory(*args,**kwargs)
+        except BaseException as error:
+            self._pending=getattr(error,recovery,None)
+            raise
+
+    def _open(self):
+        """拒绝已失败/关闭的执行。参数: 无。返回: None。异常: ResultClosedError。"""
+        if self._closed or self._failed:
+            raise ResultClosedError('事件指标已关闭或失败')
+
+    def observe_group(self):
+        """完整组已原子提交，更新各必要表达式一次。参数: 无。返回: None。异常: 求值/写入/预算原错。"""
+        self._open()
+        for value,condition,history,_,__,constant in self._streams.values():
+            if constant:
+                continue
+            row=value.evaluate()
+            selected=None if condition is None else condition.evaluate()
+            if value.invalidated_at is not None:
+                history.expire_at(value.invalidated_at)
+            if condition is not None and condition.invalidated_at is not None:
+                history.expire_at(condition.invalidated_at,condition=True)
+            if row is not None:
+                if condition is not None and (selected is None or selected[0]!=row[0]):
+                    raise ValueError('事件值和条件必须共用驱动')
+                actual=history._sample_updates and any((sample:=value._state.get(name)) is not None
+                    and sample.time_ns==row[0] for name in value._static.dependencies)
+                history.append(row,selected,actual_update=actual)
+        self._flush()
+
+    def observe_event(self,event):
+        """仅保等待计算需要的父ID和真实端点，不复制事件全文。参数: 事件。返回: None。异常: 预算/计算原错。"""
+        self._open()
+        requests=tuple(request for request in self._requests if request.scope=='event:'+event.rule.rule_id)
+        if requests:
+            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)+128*len(requests)
+            _reserve_owned_ram(self,cost,'_queue_cost')
+            heapq.heappush(self._queue,(end,self._serial,requests,event.event_id,start,cost))
+            self._serial+=1
+        self._flush()
+
+    def observe_segment(self,segment):
+        """EOF后按实际片段范围计算，缺失扩展不伪装完整。
+
+        参数: 精简核心片段。返回: None。异常: 原查询错；空片段只返回无观测值。
+        """
+        self._open()
+        requests=tuple(request for request in self._requests if request.scope=='segment:'+segment.window_id)
+        if not requests:
+            return
+        actual=segment.actual
+        start=self._plan.dataset.domain.start_ns if actual is None else actual.start_ns
+        end=start if actual is None else actual.end_ns
+        self._calculate(requests,segment.segment_id,start,end,partial=segment.status!='complete',
+            parent_coverage=segment.coverage)
+
+    def _calculate(self,requests,parent,start_ns,end_ns,*,partial=False,parent_coverage=None):
+        """同范围、同表达式的相邻指标共读一次；预算余量不足时缩为单项。
+
+        参数: 原声明顺序的请求tuple/父ID/实际范围及覆盖。返回: None。异常: 原查询、预算或输出错误。
+        不缓存整个范围；每次借一行同时交给有限计算器，仍按声明顺序发布。
+        """
+        from itertools import groupby
+        for key,group in groupby(requests,key=lambda request:self._request_stream[request.calculation_id]):
+            items=tuple(group)
+            # 留出每项计算器和批数组的余量；所有真实分配仍由共享预算检查。
+            available=self._budget.memory_budget_bytes-self._budget.ram_bytes
+            width=max(1,min(8,available//(32*1024*1024)))
+            for offset in range(0,len(items),width):
+                chunk=items[offset:offset+width]
+                self._calculate_chunk(key,chunk,parent,start_ns,end_ns,partial,parent_coverage)
+
+    def _calculate_chunk(self,key,requests,parent,start_ns,end_ns,partial,parent_coverage):
+        """建立有限计算器组并共享一次回读。参数: 流key/请求/范围/质量。返回: None。异常: 原错误保留owner。
+        """
+        history,expression,condition=self._streams[key][2:5]
+        for request in requests:
+            spec=CalculationDefinition(request.calculation_id,request.operation,Interval(start_ns,end_ns),request.partial_policy,
+                            request.unit,request.scope.split(':',1)[0],request.minimum_coverage)
+            factory=RecordIntegral if request.operation=='integral' else RecordTimeCalculation
+            recovery='record_integral_cleanup_owner' if request.operation=='integral' else 'record_time_cleanup_owner'
+            extra={'work_dir':self._path} if request.operation=='time_weighted_mean' else {}
+            if request.operation=='select':
+                factory,recovery=RecordSelection,'record_selection_cleanup_owner'
+                extra={'consumer':bind_consumer(self._selection_consumer,request,parent)}
+            self._calculation=self._new(factory,recovery,self._budget,spec,expression.root.unit,expression.root.dtype,
+                self._steps[request.calculation_id],backend=self._plan.execution.backend,
+                batch_intervals=min(self._plan.execution.batch_rows,4096),conditioned=condition is not None,
+                **extra)
+            self._calculators.append(self._calculation);self._calculation=None
+        for point in history.rows(start_ns,end_ns):
+            time,value,deadline,selected,selected_end=point[:5]
+            for calculation in self._calculators:
+                calculation.consume(((time,value,deadline),),**({} if condition is None else
+                    {'conditions':(selected,),'condition_valid_until_ns':(selected_end,)}),
+                    **({'actual_value_updates':(point[5],)} if getattr(calculation,'_samples',False) else {}))
+        for request,calculation in zip(requests,self._calculators):
+            self._finish_observation_tail(key,calculation,end_ns)
+            result=calculation.finish()
+            if request.operation=='select':
+                calculation.close()
+                continue
+            if partial and result.value is not None:
+                result=replace(result,value=None if request.partial_policy=='strict' else result.value,
+                    status='indeterminate' if request.partial_policy=='strict' else 'partial',reason='partial_input')
+            if request.scope.startswith('segment:') and request.minimum_coverage>0 and (
+                    parent_coverage is None or parent_coverage<request.minimum_coverage):
+                result=replace(result,coverage_status='indeterminate')
+            self._consumer(request,parent,result)
+            calculation.close()
+        self._calculators.clear()
+
+    def _finish_observation_tail(self,key,calculation,end_ns):
+        """用真实来源终点补查询尾段，既不补固定周期也不增加真实样本。
+
+        参数: key为共享表达式流，calculation为本次范围统计器，end_ns为查询右端。
+        返回: None。异常: 表达式、预算或累计错误沿查询清理路径传播。
+        只处理整个历史的最后一点；旧范围已有右邻点时绝不借用当前状态重新求值。
+        """
+        samples=getattr(calculation,'_samples',False)
+        value,condition,history=self._streams[key][:3]
+        if (not calculation._rows or not samples and calculation._step_ns is not None
+                or calculation._last_time!=history.last_time or calculation._last_time>=end_ns):
+            return
+        sources={definition.source for expression in (value,condition) if expression is not None
+                 for _,definition in expression._definitions}
+        ends=value._observation_ends
+        if not sources or ends is None or any(source not in ends for source in sources):
+            return
+        start=calculation._last_time
+        end=min(end_ns,max(ends[source] for source in sources))
+        if end<=start:
+            return
+        # 此点是整个流的最新相关更新；EOF已知后重新核对右侧保持，保留TTL及短路条件含义。
+        current,deadline=value.evaluate_at(start)
+        selected,condition_deadline=(None,None) if condition is None else condition.evaluate_at(start)
+        if samples:
+            previous=calculation._rows[-1]
+            value_ends=tuple(t for t in (previous[2],deadline,start if not current.valid else None) if t is not None)
+            condition_ends=tuple(t for t in (previous[4],condition_deadline,
+                start if selected is not None and not selected.valid else None) if t is not None)
+            calculation._rows[-1]=(start,previous[1],min(value_ends) if value_ends else None,
+                previous[3],min(condition_ends) if condition_ends else None)+previous[5:]
+        else:
+            calculation._rows[-1]=(start,current,deadline,selected,condition_deadline)
+        calculation.consume(((end,current,deadline),),
+            **({'actual_value_updates':(False,)} if samples else {}),
+            **({} if condition is None else
+               {'conditions':(selected,),'condition_valid_until_ns':(condition_deadline,)}))
+
+    def _flush(self,final=False):
+        """右侧实际驱动到达才结算；EOF直接按已有点计算，不补周期。
+
+        参数: final只在真实EOF时为True。返回: None。异常: 原查询错，未退费用由close清理。
+        """
+        pending=[]
+        try:
+            while self._queue:
+                item=heapq.heappop(self._queue)
+                end,_,requests,parent,start,cost=item
+                histories=(self._streams[self._request_stream[request.calculation_id]][2] for request in requests)
+                if not final and any(history.last_time is None or history.last_time<end for history in histories):
+                    pending.append(item)
+                    continue
+                self._calculate(requests,parent,start,end)
+                item=None
+                _release_owned_ram(self,cost,'_queue_cost')
+        except BaseException:
+            self._failed=True
+            raise
+        finally:
+            for item in pending:
+                heapq.heappush(self._queue,item)
+
+    def finish(self,cursors):
+        """来源全部完成后处理常量和剩余事件。参数: 实际来源游标。返回: None。异常: 原求值/计算错。"""
+        self._open()
+        starts=[c.observed_start for c in cursors if c.observed_start is not None]
+        ends=[c.observed_end for c in cursors if c.observed_start is not None and c.observed_end is not None]
+        if starts and ends:
+            first,last=min(starts),max(ends)
+            for value,condition,history,_,__,constant in self._streams.values():
+                if constant:
+                    result,_=value.evaluate_at(last)
+                    selected=None if condition is None else condition.evaluate_at(last)[0]
+                    for time in dict.fromkeys((first,last)):
+                        history.append((time,result,None),None if condition is None else (time,selected,None))
+        self._flush(final=True)
+
+    @property
+    def closed(self):
+        """返回关闭事实。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """按责任关闭子资源，失败时保槽供重试。参数: 无。返回: None。异常: 原关闭错。"""
+        if self._closed:
+            return
+        for slot in ('_pending','_calculation'):
+            owner=getattr(self,slot)
+            if owner is not None:
+                owner.close()
+                setattr(self,slot,None)
+        for owner in self._calculators:
+            owner.close()
+        self._calculators.clear()
+        for stream in self._streams.values():
+            for index in range(3):
+                if stream[index] is not None:
+                    stream[index].close()
+                    stream[index]=None
+        self._streams.clear()
+        self._queue.clear()
+        self._requests=self._plan=self._consumer=self._request_stream=None
+        _release_owned_ram(self,self._queue_cost,'_queue_cost')
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost')
+        self._closed=True

chronaxis/execution/record_selection.py

@@ -0,0 +1,62 @@
+"""把真实样本更新有界地交给原select核，并直接写最终选择表。
+
+条件独自变化、TTL和裁剪边界不输出行。TRUE与UNKNOWN保持区别；只保存一批及
+共享右端，没有完整选择历史或第二套算法。事件范围由必要历史提供相同协议。
+"""
+from ..core.calculations_reference import select_reference
+from ..core.calculations_numpy import select_numpy
+from ..results.budget import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+from .record_point_buffer import RecordPointBuffer
+from .record_sample_series import sample_series
+
+
+class RecordSelection(RecordPointBuffer):
+    """拥有有限样本缓冲；结果行只在回调期间借用，不累计输出列表。"""
+    def __init__(self,budget,spec,input_unit,dtype,step_ns,*,backend='numpy',batch_intervals=64,
+                 conditioned=False,consumer=None):
+        """预约必要缓冲。参数: 共享预算/选择请求/类型/后端/回调。返回: owner。异常: 配置或预算错。"""
+        if spec.operation!='select' or step_ns is not None or backend not in ('reference','numpy') or not callable(consumer):
+            raise ValueError('选择需要select、无周期和明确后端及行消费者')
+        if type(batch_intervals) is not int or not 1<=batch_intervals<=4096 or type(conditioned) is not bool:
+            raise ValueError('选择需要合法批大小及条件开关')
+        self._budget,self._spec,self._input_unit,self._dtype=budget,spec,input_unit,dtype
+        self._consumer,self._backend=consumer,backend
+        self._limit,self._conditioned,self._samples=batch_intervals,conditioned,True
+        self._held_cost=self._fixed_cost=self._workspace_cost=0
+        self._rows=None;self._last_time=None
+        self._closed=self._closing=self._failed=self._finished=False
+        try:
+            _reserve_owned_ram(self,65536+(batch_intervals+1)*4096,'_fixed_cost')
+            self._rows=[]
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_selection_cleanup_owner','样本选择');raise
+
+    def _flush(self):
+        """消费当前正时段，留下右端供下一批。参数: 无。返回: None。异常: 核或输出错误。"""
+        if len(self._rows)<2:return
+        series=row=iterator=None
+        try:
+            _reserve_owned_ram(self,65536+len(self._rows)*36864,'_workspace_cost')
+            series=sample_series(self._rows,self._input_unit,self._conditioned)
+            iterator=(select_reference if self._backend=='reference' else select_numpy)(series,self._spec)
+            for row in iterator:self._consumer(row)
+            self._rows[:]=self._rows[-1:]
+        except BaseException:
+            self._failed=True;raise
+        finally:
+            if iterator is not None:iterator.close()
+            series=row=iterator=None
+            _release_owned_ram(self,self._workspace_cost,'_workspace_cost')
+
+    def finish(self):
+        """EOF后输出最后正范围，无末尾假样本。参数: 无。返回: None。异常: 原计算/写入错。"""
+        self._require_open()
+        if not self._finished:self._flush();self._finished=True
+
+    def close(self):
+        """释放缓冲及回调，实际费用归零后关闭。参数: 无。返回: None。异常: 预算释放错。"""
+        if self._closed:return
+        self._closing=True;self._rows=self._consumer=None
+        _release_owned_ram(self,self._workspace_cost,'_workspace_cost')
+        _release_owned_ram(self,self._fixed_cost,'_fixed_cost')
+        self._closed=True

chronaxis/execution/record_sequences.py

@@ -0,0 +1,199 @@
+"""收齐同刻的请求、响应和条件后配对，直接交付最终结果。
+
+只保留本次输入组之前的有限条件边界及尚待响应的请求。没有配对请求时不
+建立本对象；不会为配对保存整段信号历史或另一时间轴。每个规则的观测终点
+由其必要来源决定，响应来源提前结束只使后续响应未知，不提前结束其他来源。
+"""
+
+from ..planning.intervals import IntervalChoice
+from dataclasses import replace
+from ..core.sequence import SequenceRule, SequenceTick
+from ..core.sequence_reference import SequenceDetector
+from ..core.temporal import ConditionTick
+from ..core.types import Truth as T, QualityFlag as Q
+from ..results.errors import ResultClosedError, BudgetExceededError
+from ..results.spool import _reserve_owned_ram, _release_owned_ram, _cleanup_owner
+from .history import _metadata_bytes
+
+
+class RecordSequences:
+    """拥有同刻合并队列及FIFO候选；计划、状态和结果消费者为借用。"""
+
+    def __init__(self,plan,state,budget,steps,consumer):
+        """登记有限配对配置。参数: 计划、共享状态/预算、周期映射、结果回调。返回: owner。异常: 构造原错附owner。"""
+        self._plan,self._state,self._budget,self._steps,self._consumer=plan,state,budget,steps,consumer
+        self._held_cost=self._fixed_cost=self._queue_cost=self._pending_cost=self._step_cost=0
+        self._queue,self._active,self._costs={},{},{}
+        self._closed=self._failed=False
+        self._rules={r.rule_id:r for r in plan.rules}
+        self._needed={name for s in plan.sequences for name in (s.start_rule,s.response_rule)}
+        try:
+            _reserve_owned_ram(self,65536+32*_metadata_bytes(plan.sequences),'_fixed_cost')
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_sequences_cleanup_owner','在线配对构造')
+            raise
+
+    def _open(self):
+        """拒绝失败实例。参数: 无。返回: None。异常: ResultClosedError。"""
+        if self._closed or self._failed:
+            raise ResultClosedError('在线配对已关闭或失败')
+
+    def _entry(self,time_ns):
+        """先付费再建立一组。参数: 实际时间。返回: 可变组。异常: 预算原错。"""
+        if time_ns not in self._queue:
+            _reserve_owned_ram(self,8192,'_queue_cost')
+            self._queue[time_ns]=[{},set(),8192]
+        return self._queue[time_ns]
+
+    def bounds(self,cursors,ends):
+        """从真实来源范围开始/收窄配对域，在末组交付之前调用。
+
+        参数: 已前瞻的来源和确认EOF终点。返回: None。异常: 范围/预算错误。
+        """
+        self._open()
+        choices=dict(self._plan.intervals.resolved)
+        for spec in self._plan.sequences:
+            names=set(self._rules[spec.start_rule].dependencies)|set(self._rules[spec.response_rule].dependencies)
+            driver=choices[spec.sequence_id].driver
+            if driver:
+                names.add(driver)
+            sources={self._state.definitions[name].source for name in names}
+            if any(not self._rules[name].dependencies and choices.get(name,IntervalChoice('actual')).driver is None
+                   for name in (spec.start_rule,spec.response_rule)):
+                sources.update(source.name for source in self._plan.sources)
+            starts=[c.observed_start for c in cursors if c.source_name in sources and c.observed_start is not None]
+            if not starts:
+                continue
+            start=max(min(starts),self._plan.dataset.domain.start_ns)
+            end=self._plan.dataset.domain.end_ns
+            finished={c.source_name for c in cursors if c._finished}
+            final=bool(sources) and sources<=finished
+            if final:
+                end=min(end,max(ends[source] for source in sources if source in ends))
+            if start>end:
+                continue
+            if spec.sequence_id not in self._active:
+                rule=SequenceRule(spec.sequence_id,self._plan.dataset.dataset_id,self._plan.dataset.session_id,
+                    spec.start_rule,spec.response_rule,spec.min_delay_ns,spec.max_delay_ns,
+                    self._plan.dataset.entity,record_clock=self._steps[spec.sequence_id] is not None)
+                detector=SequenceDetector(rule,start,end,max_pending=spec.max_pending)
+                self._active[spec.sequence_id]=[spec,detector,None,False,False]
+                self._entry(start)
+            detector=self._active[spec.sequence_id][1]
+            if not self._plan.dataset.domain_explicit and not detector._ended:
+                detector.end_ns=end
+            if final and not detector._ended:
+                if detector._last_time is not None and end<=detector._last_time:
+                    raise ValueError('配对末组已提交，不能回退观测范围')
+                detector.end_ns=end
+                self._entry(end)
+
+    def observe(self,rule,tick,events):
+        """借用规则批时先付费再保留必要点，不保存不参与配对的规则。
+
+        参数: 规则ID、条件点及事件tuple。返回: None。异常: 预算/重复点错误。
+        """
+        self._open()
+        if rule not in self._needed:
+            return
+        entry=self._entry(tick.time_ns)
+        if rule in entry[0]:
+            raise ValueError('配对收到重复规则时间组')
+        cost=8192+16*_metadata_bytes(events)
+        _reserve_owned_ram(self,cost,'_queue_cost')
+        entry[2]+=cost
+        entry[0][rule]=(tick,events)
+
+    def drivers(self,group):
+        """仅记录配对实际需要的驱动更新身份。参数: 完整原始组。返回: None。异常: 预算错误。"""
+        self._open()
+        names={choice.driver for name,choice in self._plan.intervals.resolved
+               if name in self._steps and choice.driver is not None}
+        selected={sample.name for sample in group.samples}&names
+        if selected:
+            self._entry(group.time_ns)[1].update(selected)
+
+    def _consume(self,time_ns,entry,active):
+        """一次提交同刻A/B，候选到结果交付完毕才退费。参数: 时间/组/检测状态。返回: None。异常: 原计算错。"""
+        spec,detector,last,seen,finished=active
+        if finished or not detector.start_ns<=time_ns<=detector.end_ns:
+            return
+        a=entry[0].get(spec.start_rule)
+        b=entry[0].get(spec.response_rule)
+        if b is not None:
+            condition=b[0]
+        elif last is None:
+            condition=ConditionTick(time_ns,T.UNKNOWN,Q.MISSING)
+        else:
+            condition=ConditionTick(time_ns,last.state,last.quality)
+        terminal=time_ns==detector.end_ns
+        condition=replace(condition,terminal=terminal,
+            state=T.UNKNOWN if terminal else condition.state,
+            quality=condition.quality|Q.MISSING if terminal else condition.quality)
+        starts=() if a is None else a[1]
+        responses=() if b is None else b[1]
+        _reserve_owned_ram(self,16384+16*_metadata_bytes(responses),'_step_cost')
+        for event in starts:
+            cost=32768+16*_metadata_bytes((event,detector.rule))
+            _reserve_owned_ram(self,cost,'_pending_cost')
+            self._costs[(spec.sequence_id,event.event_id)]=cost
+        step=self._steps[spec.sequence_id]
+        choice=dict(self._plan.intervals.resolved)[spec.sequence_id]
+        selected=choice.driver in entry[1]
+        advance=step if selected and seen else 0
+        active[3]=seen or selected
+        try:
+            results=detector.push((SequenceTick(condition,starts,responses),),
+                advances=None if step is None else (advance,))
+        except MemoryError as error:
+            raise BudgetExceededError('配对等待候选超过限制：'+spec.sequence_id) from error
+        released=0
+        for result in results:
+            self._consumer(result)
+            released+=self._costs.pop((spec.sequence_id,result.request.event_id))
+        result=results=None
+        _release_owned_ram(self,released,'_pending_cost')
+        _release_owned_ram(self,self._step_cost,'_step_cost')
+        active[2]=condition
+        if terminal:
+            detector.finish()
+            active[4]=True
+
+    def flush_before(self,before=None):
+        """所有规则已交付边界后，按实际时间处理一次；None仅用于真实全体EOF。
+
+        参数: 下一个尚未提交的实际组。返回: None。异常: 原错并封闭实例。
+        """
+        self._open()
+        try:
+            for time in sorted(self._queue):
+                if before is not None and time>=before:
+                    break
+                entry=self._queue[time]
+                for active in self._active.values():
+                    self._consume(time,entry,active)
+                cost=entry[2]
+                del self._queue[time]
+                entry=None
+                _release_owned_ram(self,cost,'_queue_cost')
+            if before is None and any(not active[4] for active in self._active.values()):
+                raise ValueError('配对尚未收到实际终点')
+        except BaseException as error:
+            self._failed=True
+            error.record_sequences_cleanup_owner=self
+            raise
+
+    @property
+    def closed(self):
+        """返回资源关闭状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """放弃未发布候选并退还自有费用。参数: 无。返回: None。异常: 预算释放原错可重试。"""
+        if self._closed:
+            return
+        self._queue.clear();self._active.clear();self._costs.clear()
+        self._plan=self._state=self._consumer=self._steps=self._rules=None
+        for slot in ('_pending_cost','_step_cost','_queue_cost','_fixed_cost'):
+            _release_owned_ram(self,getattr(self,slot),slot)
+        self._closed=True