chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/execution/record_windows.py

@@ -0,0 +1,229 @@
+"""从最终事件表生成窗口，不再复制一份事件阶段或重扫原输入。
+
+每个窗口只保最后可能继续合并的父组及有限新父；记录周期借共享实际时刻索引。
+边界扩展/合并继续使用既有两个独立窗口核，默认输出精简片段。
+"""
+from dataclasses import replace
+from fractions import Fraction
+from ..core.models import Interval
+from ..core.temporal import Event,TemporalRule
+from ..core.windows import WindowSpec
+from ..core.windows_reference import build_segments_reference
+from ..core.windows_numpy import build_segments_numpy
+from ..results.summary import SummaryEventRow
+from ..results.codec import decode_row
+from ..results.errors import ResultClosedError,ResultFormatError
+from ..results.spool import _reserve_owned_ram,_release_owned_ram,_cleanup_owner
+from .history import _metadata_bytes
+
+
+class RecordWindows:
+    """拥有最终事件表读槽和有限待合并父组；共享时点索引、结果仓均为借用。"""
+
+    def __init__(self,plan,budget,indexes,steps,consumer):
+        """预付声明，不读取输入或事件表。参数: 计划/预算/时点索引/周期/片段回调。返回: owner。异常: 原构造错。"""
+        self._plan,self._budget,self._indexes,self._steps,self._consumer=plan,budget,indexes,steps,consumer
+        self._held_cost=self._fixed_cost=self._parents_cost=self._reader_cost=self._workspace_cost=0
+        self._handle=None
+        self._parents={}
+        self._since={}
+        self._observation={}
+        self._specs={}
+        self._rules={}
+        self._closed=self._failed=False
+        self._choices=dict(plan.intervals.resolved)
+        self._coverage_needed={calculation.scope.split(":",1)[1] for calculation in plan.calculations
+            if calculation.scope.startswith("segment:") and calculation.minimum_coverage>0}
+        try:
+            _reserve_owned_ram(self,131072+64*_metadata_bytes(plan.windows),'_fixed_cost')
+            for request in plan.windows:
+                self._parents[request.window_id]=[]
+                self._since[request.window_id]=0
+                self._specs[request.window_id]=WindowSpec(request.window_id,request.event,request.anchor,
+                    request.pre_ns,request.post_ns,request.merge,request.exit_delay_ns)
+            for rule in plan.rules:
+                self._rules[rule.rule_id]=TemporalRule(rule.rule_id,plan.dataset.dataset_id,plan.dataset.session_id,
+                    rule.temporal_rule_type,rule.minimum_duration_ns or 0,rule.emit_initial,rule.window_duration_ns or 0,
+                    duration_comparison=rule.duration_comparison)
+            self._build=build_segments_reference if plan.execution.backend=='reference' else build_segments_numpy
+        except BaseException as error:
+            _cleanup_owner(self,error,'record_windows_cleanup_owner','按需窗口构造')
+            raise
+
+    def _bounds(self,window,event):
+        """按所选周期定位实际边界；actual由原核直接扩展。参数: 窗口/事件。返回: 四元组或None。异常: 原查找错。"""
+        step=self._steps[window.window_id]
+        if step is None:
+            return None
+        driver=self._choices[window.window_id].driver
+        if not self._indexes.count(driver):
+            return event.start_ns,event.start_ns,True,True
+        end=event.start_ns if event.end_ns is None else event.end_ns
+        extension=window.exit_delay_ns if window.merge=='exit_delay' else window.post_ns
+        left,left_clip=self._indexes.shift(driver,event.start_ns,-window.pre_ns,step)
+        right,right_clip=self._indexes.shift(driver,end,extension,step)
+        return left,right,left_clip,right_clip
+
+    def _coverage(self,window,segment,parents):
+        """仅明确门槛请求才算窗口已取得部分比例，不保存各记录的第二时间。
+
+        参数: 窗口/结果/本组父事件。返回: 0—1或无法确定的None。异常: 原时间读取错。
+        actual沿原请求秒数；周期模式按已选记录跨度与请求周期数比较。
+        """
+        if segment.actual is None:
+            return 0.
+        ids=set(segment.parent_event_ids)
+        selected=tuple(parent for parent in parents if parent.event_id in ids)
+        extension=window.exit_delay_ns if window.merge=='exit_delay' else window.post_ns
+        step=self._steps[window.window_id]
+        if step is None:
+            left=min(parent.start_ns-window.pre_ns for parent in selected)
+            right=max((parent.start_ns if parent.end_ns is None else parent.end_ns)+extension for parent in selected)
+            return segment.actual.duration_ns()/(right-left)
+        driver=self._choices[window.window_id].driver
+        starts=[]
+        ends=[]
+        for parent in selected:
+            start,outside=self._indexes.position(driver,parent.start_ns)
+            end,outside_end=self._indexes.position(driver,parent.start_ns if parent.end_ns is None else parent.end_ns)
+            if outside or outside_end:
+                return None
+            starts.append(start-Fraction(window.pre_ns,step))
+            ends.append(end+Fraction(extension,step))
+        actual_left,_=self._indexes.position(driver,segment.actual.start_ns)
+        actual_right,_=self._indexes.position(driver,segment.actual.end_ns)
+        length=max(ends)-min(starts)
+        return 0. if length==0 else min(1.,max(0.,float((actual_right-actual_left)/length)))
+
+    def _process(self,window,final=False):
+        """复用窗口核，非末批只保最后合并组，其他片段直接输出。
+
+        参数: 窗口/真实EOF标识。返回: None。异常: 预算/窗口/发布原错，责任保留到close。
+        """
+        name=window.window_id
+        entries=self._parents[name]
+        if not entries:
+            return
+        parents=bounds=segments=None
+        primary=None
+        try:
+            _reserve_owned_ram(self,65536+sum(8192+16*_metadata_bytes(item[0]) for item in entries),'_workspace_cost')
+            parents=tuple(item[0] for item in entries)
+            bounds=None if self._steps[name] is None else tuple(item[2] for item in entries)
+            segments=self._build(parents,self._specs[name],self._observation[name],bounds=bounds,compact=True)
+            limit=len(segments) if final else max(0,len(segments)-1)
+            for index in range(limit):
+                segment=segments[index]
+                if name in self._coverage_needed:
+                    segment=replace(segment,coverage=self._coverage(window,segment,parents))
+                self._consumer(segment)
+            segment=None
+            keep=0
+            if not final:
+                first=segments[-1].parent_event_ids[0]
+                keep=next(index for index,item in enumerate(entries) if item[0].event_id==first)
+            else:
+                keep=len(entries)
+            cost=sum(item[1] for item in entries[:keep])
+            del entries[:keep]
+            parents=bounds=segments=None
+            _release_owned_ram(self,cost,'_parents_cost')
+            self._since[name]=0
+        except BaseException as error:
+            primary=error
+            raise
+        finally:
+            parents=bounds=segments=None
+            try:
+                _release_owned_ram(self,self._workspace_cost,'_workspace_cost')
+            except BaseException as cleanup:
+                if primary is None:
+                    raise
+                # 真实写出/计算错误优先；未退费用仍在本owner，交由父会话恢复。
+                primary.add_note('窗口工作区清理附加失败：'+type(cleanup).__name__)
+
+    def finish(self,cursors,spool):
+        """所有来源结束后只读一次最终事件表，并生成片段。
+
+        参数: 真正EOF的游标、同次最终结果仓。返回: None。异常: 缺范围/短读/损坏/预算/发布原错。
+        未请求窗口时调用方不创建本对象，空事件不建立额外中间仓。
+        """
+        if self._closed or self._failed:
+            raise ResultClosedError('窗口已关闭或失败')
+        if not spool.counts.get('events',0):
+            return
+        row=event=payload=None
+        try:
+            definitions={item.definition.name:item.definition for item in self._plan.signals}
+            rules={rule.rule_id:rule for rule in self._plan.rules}
+            for window in self._plan.windows:
+                names=set(rules[window.event].dependencies)
+                driver=self._choices[window.window_id].driver
+                if driver:
+                    names.add(driver)
+                sources={definitions[name].source for name in names} if names else {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]
+                ends=[c.observed_end for c in cursors if c.source_name in sources and c.observed_start is not None and c.observed_end is not None]
+                if starts and ends:
+                    left=max(min(starts),self._plan.dataset.domain.start_ns)
+                    right=min(max(ends),self._plan.dataset.domain.end_ns)
+                    if left<=right:
+                        self._observation[window.window_id]=Interval(left,right)
+            path=spool._seal_table('events')
+            _reserve_owned_ram(self,spool.reader_cost_for('events'),'_reader_cost')
+            self._handle=path.open('rb',buffering=8192)
+            maximum=spool.row_limit('events')
+            count=0
+            while True:
+                payload=self._handle.readline(maximum+1)
+                if not payload:
+                    break
+                if len(payload)>maximum or not payload.endswith(b'\n'):
+                    raise ResultFormatError('窗口事件输入短读或行超限')
+                row=decode_row(payload,maximum)
+                if type(row) is not SummaryEventRow:
+                    raise ResultFormatError('窗口需要同次精简事件表')
+                count+=1
+                event=Event(row.event_id,self._rules[row.rule_id],'point' if row.end_ns is None else 'activity',
+                    row.start_ns,row.confirmed_ns,row.end_ns,row.status,row.trigger,row.quality,row.quality)
+                for window in self._plan.windows:
+                    if window.event!=row.rule_id:
+                        continue
+                    if window.window_id not in self._observation:
+                        raise ValueError('有事件却没有实际窗口观测范围')
+                    cost=8192+32*_metadata_bytes(event)
+                    _reserve_owned_ram(self,cost,'_parents_cost')
+                    bounds=self._bounds(window,event)
+                    self._parents[window.window_id].append((event,cost,bounds))
+                    self._since[window.window_id]+=1
+                    if self._since[window.window_id]>=min(self._plan.execution.batch_rows,64):
+                        self._process(window)
+                row=event=payload=None
+            if count!=spool.counts['events']:
+                raise ResultFormatError('窗口事件表记录缺失')
+            self._handle.close();self._handle=None
+            _release_owned_ram(self,self._reader_cost,'_reader_cost')
+            for window in self._plan.windows:
+                self._process(window,final=True)
+        except BaseException:
+            self._failed=True
+            raise
+        finally:
+            row=event=payload=None
+
+    @property
+    def closed(self):
+        """返回资源关闭状态。参数: 无。返回: bool。异常: 无。"""
+        return self._closed
+
+    def close(self):
+        """关闭读槽并释放剩余父组，不删除最终事件表。参数: 无。返回: None。异常: 原关闭错，可重试。"""
+        if self._closed:
+            return
+        if self._handle is not None:
+            self._handle.close();self._handle=None
+        self._parents.clear()
+        self._plan=self._consumer=self._indexes=None
+        for slot in ('_parents_cost','_workspace_cost','_reader_cost','_fixed_cost'):
+            _release_owned_ram(self,getattr(self,slot),slot)
+        self._closed=True

chronaxis/execution/required_expression.py

@@ -0,0 +1,52 @@
+"""在真实部分投影上编译结果需要的表达式，保留完整静态声明检查。
+
+输入是原 StaticExpression、真实 DecodedBindings 和全部派生定义；输出身份
+与公开 compile_expression 一致的 CompiledExpression。先在声明绑定上重新
+检查所有派生，再核对原静态对象；真实绑定只解析当前根递归需要的派生，不把
+未用派生变成要求输入投影的运行根。公共编译和静态校验入口保持原行为。
+本模块不读取数据、不求值、不持有长期缓存。调用阶段须先为完整声明树、编译
+临时对象及身份材料预付费用；失败时清理本层借用引用，原异常交给阶段处理。
+"""
+
+from hashlib import sha256
+
+from ..core.decoded_binding import DecodedBindings
+from ..core.expression import (
+    CompiledExpression, StaticExpression, _Compiler, _identity, validate_expression)
+
+
+def compile_required_expression(static, bindings, *, derived=(), unit=None):
+    """完整核实静态声明，再按本结果根建立真实输入表达式。
+
+    参数:
+        static: 原 StaticExpression；bindings: 当前实际 DecodedBindings。
+        derived: 与绑定名称空间一致的完整 DerivedDefinition tuple。
+        unit: 原表达式的显式单位，省略时使用原编译器推导，不做输出换算。
+    返回:
+        CompiledExpression。身份公式、依赖、类型和单位沿用公开编译规则。
+    异常:
+        TypeError 为对象域不符；ValueError 为静态内容被替换、未知名称、
+        循环、类型/单位或实际依赖未投影；取消和内存错误原样传播。
+    边界:
+        未使用派生仍接受语法和单位检查，但不要求其原字段已读取。当前根需要
+        的字段必须有真实投影证明。预算由调用阶段在本函数执行前承担。
+    """
+    checked = compiler = root = normalized = payload = identity = None
+    try:
+        if type(static) is not StaticExpression or not isinstance(bindings, DecodedBindings):
+            raise TypeError('按需运行编译需要StaticExpression和实际DecodedBindings')
+        checked = validate_expression(static.text, bindings.declarations, derived=derived, unit=unit)
+        # 同时核根树和身份；仅比较别名或单位不能发现合法文本/常量被typed替换。
+        if checked != static:
+            raise ValueError('按需运行编译与原完整静态表达式不一致')
+        compiler = _Compiler(bindings, derived)
+        root, normalized = compiler.parse(static.text, unit)
+        bindings.require_synchronized(root.aliases)
+        payload = ('expression-v1', 'reference+numpy-v1', bindings.identity, normalized,
+            repr(root), tuple((item.name, item.expr, item.unit) for item in derived))
+        identity = sha256(_identity(payload).encode('utf-8')).hexdigest()
+        return CompiledExpression(static.text, bindings, root, root.aliases, normalized, identity)
+    finally:
+        # 阶段退款后，异常栈不得额外保活本层编译器及其全部声明索引。
+        checked = compiler = root = normalized = payload = identity = None
+        static = bindings = derived = unit = None

chronaxis/execution/retained_metadata.py

@@ -0,0 +1,71 @@
+"""估算冻结指标实体的继续保留费用，独立于JSON编解码工作副本。
+
+输入只含已校验dataclass、tuple、枚举、原生标量及原协议支持的Mapping；输出含实体、实例字段字典、
+引用槽及长文本的保守bytes。只递归计数，不复制对象、不按对象身份建立seen表；
+同一对象出现在多处仍重复计费，因此跨owner共享无需隐式转移费用。
+
+CPython实例字典以256字节头及每字段256字节覆盖字典索引、键/值槽和容量余量，
+不读取__dict__以免在估算前物化managed dict。字段名/类定义由调用方已有模型拥有；
+每个字段值仍完整递归计数。tuple的getsizeof已含引用槽，每项另留32字节容器余量。
+此费用不承担_pack的新字典树、JSON文本/UTF8或解码副本，原codec估算另行预约。
+只依赖标准库和轻量错误类型，没有文件、数组或来源读取副作用；不是RSS估计。
+"""
+
+# fields创建仅含实际字段的小tuple，大小取决于模型字段数，finally清members；
+# 与原元数据协议一致，ClassVar/InitVar不属于实例实体，不读取实例__dict__。
+from collections.abc import Mapping
+from dataclasses import fields, is_dataclass
+from enum import Enum
+from sys import getsizeof
+from ..results.errors import ResultFormatError
+
+
+def retained_metadata_bytes(value, depth=0):
+    """核算冻结对象实体及其字段，不把共享引用解释成深复制。
+
+    参数: value为上述有限模型树；depth为内部深度计数。
+    返回: 保守整数bytes，重复引用也独立计数，不需要无界身份集合。
+    异常: ResultFormatError为超过32层或含未支持可变/数组类型。
+    """
+    members = field = item = key = None
+    try:
+        # 深度与已有元数据协议一致；不执行repr、复制实例字典或序列化方法。
+        if depth > 32:
+            raise ResultFormatError('保留元数据超过32层')
+        if is_dataclass(value) and not isinstance(value, type):
+            members = fields(value)
+            amount = getsizeof(value) + 256 + 256 * len(members)
+            for field in members:
+                amount += retained_metadata_bytes(getattr(value, field.name), depth + 1)
+            return amount
+        # 自定义SourceRef原本可带Mapping；保留其原类型支持，不构造新字典或seen。
+        if isinstance(value, Mapping):
+            amount = getsizeof(value)
+            for key, item in value.items():
+                amount += 128 + retained_metadata_bytes(key, depth + 1) + retained_metadata_bytes(item, depth + 1)
+            return amount
+        # 已有tuple不复制；不用生成器让失败TB额外保留上一次大item。
+        if type(value) is tuple:
+            amount = getsizeof(value) + 32 * len(value)
+            for item in value:
+                amount += retained_metadata_bytes(item, depth + 1)
+            return amount
+        if isinstance(value, Enum):
+            return 512 + getsizeof(value)
+        if value is None or type(value) in (str, int, bool, float):
+            return getsizeof(value) + 64
+        raise ResultFormatError('保留元数据类型无法估算')
+    finally:
+        # 只断自身参数/局部；保原异常、TB节点和调用方输入，不清任何外部帧。
+        value = members = field = item = key = None
+
+
+def reference_workspace(existing_count, incoming_count):
+    """预付去重期间新list及返回tuple的指针空间，不重复支付旧ref实体。
+
+    参数: 两个count为已校验tuple长度。返回: 保守bytes。
+    异常: 无主动异常；内部调用者保证非负原生int。
+    """
+    # 每项32字节覆盖64位list最多双容量的16字节及tuple8字节，另留8字节余量；
+    # 2048覆盖两个容器头、迭代器和固定候选对象，不随payload文本长度失真。
+    return 2048 + 32 * (existing_count + incoming_count)