Current完整API参考

固定源码基线8904c2f744951857659abd40aaa3535d57faf53c；device_label: home。

覆盖包内全部Python模块、类、手写方法、函数、私有/嵌套函数、构造字段和参数。测试、示例、tools不是包API，见示例索引及维护说明。不包含RefProjects及未跟踪的同步冲突副本。

用户优先从公开API用法开始；需要修改内部实现时再按包查找。源码无类型注解时不会伪造签名，业务类型/单位以说明为准。

模块

模块	职责	定义数
chronaxis	公开时间转换、分析计划、公共AnalysisRunner和流式结果入口。	1
chronaxis.main	将python -m chronaxis委托给同一个CLI入口。	0
chronaxis._batch_worker	批量工作进程控制消息；只在收到对应任务时加载计算实现。	2
chronaxis._control_models	三条内部控制通道的固定模型转换；协议仅接受这里显式列出的构造器。	24
chronaxis._control_wire	内部有限控制消息；Connection 只收发 bytes，不使用隐含 pickle。	23
chronaxis._process_start	Linux工作进程在业务入口前登记进程组；此模块只依赖标准库。	8
chronaxis._version	取得当前这份软件的发行版本，不查询其他安装副本或业务输入。	1
chronaxis.analysis_cli	把公共AnalysisRunner的检查、解释和实际分析接到CLI，提供文本和JSON报告。	6
chronaxis.batch	公开独立批量任务模型和调度器，不自动创建进程或读取输入。	0
chronaxis.batch.api	执行一份批量计划，并返回每个任务的状态和结果目录。任务按同一套AnalysisRunner接口运行；批量报告写出失败时，异常上的batch_report仍可用于查看已完成的任务和关闭资源。	1
chronaxis.batch.cli	从严格批量配置调用公共API，打印精简计数并保留完整逐任务报告。	1
chronaxis.batch.config	加载批量清单；显式jobs保存路径，template展开为每文件独立计划。	1
chronaxis.batch.models	定义批量任务及其报告。BatchJob说明一个任务用哪份计划，BatchPlan说明同时运行几个任务，BatchJobResult记录单个任务结果，BatchReport按原任务顺序汇总。每个任务的数值结果仍保存在自己的目录。	18
chronaxis.batch.process_transport	传递独立计划快照和小型结果，保留工作进程中的失败清理责任。	10
chronaxis.batch.process_tree	管理本次工作进程树；Windows使用作业对象，Linux使用已确认身份的pidfd进程组。	8
chronaxis.batch.publication	把批量报告写入独占命名的新 JSON 文件。先完成写入和关闭，再用平台不覆盖原语发布：Windows 使用重命名，Linux 使用 renameat2 的 RENAME_NOREPLACE。目标已存在或平台能力不足时失败；不会因此删除已完成任务的结果。	2
chronaxis.batch.runner	同时运行多份彼此独立的分析计划，最多启动process_count个任务。每个任务各用自己的状态、资源限额和目录。取消或fail_fast触发后不再启动新任务；已经启动的任务完成清理后退出。process_count限制任务数，并不限制整个Python进程的总内存。	10
chronaxis.batch.templates	把一个分析模板应用于明确输入集合，每个文件形成独立任务，不读取日志。	1
chronaxis.can_dependencies	在真正使用 CAN 库时给出缺依赖诊断，已安装的库仍按需导入。	4
chronaxis.cli	提供当前配置检查、分析发布、独立批量和高性能积分器入口。	2
chronaxis.configuration	共享配置语法入口；只读指定文件，返回原生值和加载期位置，不读取业务输入。	2
chronaxis.configuration.cli	配置辅助命令；复用同一模板及配置入口，不执行分析。	1
chronaxis.configuration.diagnostics	为配置错误附上原文位置与有限的上下文；成功计划不保存此处的文档对象。	4
chronaxis.configuration.explanation	把已验证的分析声明讲成人可阅读的步骤；不加载来源、不展开运行时数据。	8
chronaxis.configuration.file_tools	当前配置的格式转换和新文件发布；不推断业务参数，不执行分析。	8
chronaxis.configuration.imports	展开分析配置明确列出的一层本地公共定义。	4
chronaxis.configuration.initialization	把已校验的随包合成场景写入新目录，不改写已有文件。	1
chronaxis.configuration.json_parser	标准库负责JSON语法和数值；轻量第二遍只定位字段，不再构造第二份配置树。	8
chronaxis.configuration.models	配置加载期的原生数据、字段位置和语法错误，不参与分析执行或来源读取。	8
chronaxis.configuration.origins	按请求说明定义或叶字段来自哪个配置文件；不作为执行计划的持久状态。	4
chronaxis.configuration.overrides	只覆盖公共定义中的明确配置项，不允许隐藏改名、添加对象或递归合并自由数据。	1
chronaxis.configuration.resolution	按请求生成可独立加载的有效配置；只读配置，不读取业务输入。	6
chronaxis.configuration.template_catalog	读取随包发布的合成场景模板；初始化命令与模板验收使用同一套资源。	5
chronaxis.configuration.yaml_parser	通过独立纯Python安全解析器读取YAML1.2受限子集，不构造任意标签对象。	8
chronaxis.core	集中导出信号分析的模型、消息表达式绑定和标准库参考实现。	0
chronaxis.core.affine	将一个已校验数值换到目标单位，执行一次完整的乘法与偏移转换。	2
chronaxis.core.affine_numpy	按列执行单位的完整仿射转换，保持固定类型和逐位置质量掩码。	2
chronaxis.core.binding	把分析中使用的名称对应到实际信号。例如把current对应到来源pack的电流字段，随后表达式就可以使用current。模块检查名称冲突、字段是否存在、单位转换和多个来源的时间关系，再生成SignalBindings。绑定标识还包含输入内容及转换设置，用来识别两次计算是否使用了相同输入。	13
chronaxis.core.calculation_output_numpy	将一个数组归约结果换到目标单位，不调用参考数值核。	1
chronaxis.core.calculation_output_reference	将一个已归约的数值换到目标单位，保留空值和数值质量。	1
chronaxis.core.calculations	定义“要算什么”和“算完得到什么”的数据对象。CalculationDefinition保存指标种类、时间范围和缺失数据处理选择；CalculationSeries保存参与计算的时间和值；CalculationResult保存计算值及数据不完整的原因。例如教程中功率恒为4000W，请求0—12秒而记录只到8秒：选择report时，同时保留32000J、partial和8/12的请求覆盖率；选择strict时，value为None。	15
chronaxis.core.calculations_memory_numpy	把已有内存行的表达式与三值条件接入NumPy指标计算。	3
chronaxis.core.calculations_memory_reference	从现有内存信号计算表达式，接入参考统计、TRUE时长或选择行流。	5
chronaxis.core.calculations_numpy	用数组计算保持值积分、时间统计、TRUE时长及真实样本统计。	3
chronaxis.core.calculations_reference	独立计算保持值积分、时间统计、TRUE时长和真实样本统计。	3
chronaxis.core.condition_evidence	整理事件检测器需要的条件结果。对同一个时刻，分别保存更新前、更新后以及该时刻本身的真假状态，并标明是否收到真实更新、是否结束读取。这样可以区分“条件变假”“数据失效”和“文件读完”。输出是ConditionTick序列；本模块不重新计算表达式。	3
chronaxis.core.conditional_integral_terms	定义条件积分的中间结果。每个时间段保存“当前值×持续秒数”得到的面积，并另存数值是否有效、筛选条件是否已知。条件为假时不计算该段面积；条件未知也不能当成假。面积尚未求和，也尚未转换到最终输出单位。	6
chronaxis.core.conditional_integral_terms_numpy	用NumPy同时计算一组时间段的条件积分面积。先按请求范围裁剪时间段，再对条件为真且数值有效的位置计算“值×持续秒数”。返回面积数组、有效标记和覆盖时长；面积尚未相加，也没有换算最终单位。	3
chronaxis.core.conditional_integral_terms_reference	逐段计算条件积分面积，供NumPy实现作结果对照。只有筛选条件为真且数值有效时才计算面积。无法精确转换的值、溢出及非零值下溢都会记录原因；条件未知不会被补成零。返回各段面积，最后的求和由后续模块完成。	1
chronaxis.core.conditional_time_reduction	定义带筛选条件的时间统计结果：时间最小值、时间最大值、时间加权平均和条件成立时长。数值有效时间与筛选条件已知时间分别记录。例如筛选条件已知为假，是“没有选中”，不属于“无法判断”。本模块定义数据和检查规则，不执行统计。	4
chronaxis.core.conditional_time_reduction_numpy	用NumPy计算带筛选条件的时间统计。最小值和最大值保留原数值类型；duration累计主条件和筛选条件同时为真的时长；time_weighted_mean先统计有效且选中的总时长，再按各段所占比例计算平均值。最终输出单位在finish时换算一次。	7
chronaxis.core.conditional_time_reduction_reference	逐段计算带筛选条件的时间统计，供NumPy实现对照。push接收下一块数据并保留累计结果；time_weighted_mean需要两遍读取，第一遍统计总有效时长，第二遍按时长比例计算平均值。每块处理完后不再保存该块的整列输入。	7
chronaxis.core.counts_v4	定义v4计数结果及对象发现的完整性，不保存事件或原始样本。	1
chronaxis.core.declarations	在读取数据之前检查来源、信号和派生名称声明，生成不可变的声明绑定。	6
chronaxis.core.decoded_binding	把读取到的信号对应回分析计划。输入包含计划中的信号定义，以及实际读取的字段、样本数量、结束状态和内容摘要；输出供表达式执行使用的DecodedBindings。调用方必须先核实读取记录，单独填写一个合法的摘要字符串并不代表文件已经读过。	12
chronaxis.core.enum_codes	在 v4 表达式中读取按需保留的枚举原始整数列，标签索引没有原码含义。	13
chronaxis.core.export_interpolation	计算离线导出的线性值；不改变分析中的向后保持、事件或积分语义。	2
chronaxis.core.expression	检查表达式中每个名称、运算、函数、类型和单位。例如voltage * current可以算功率，而battery.current这种属性访问不允许。检查成功后生成执行器可用的表达式对象；不会打开数据文件或运行任意Python代码。全部语法见表达式完整说明。	21
chronaxis.core.expression_integer_numpy	整列处理64位取余、位操作和精确转整数，保留每行无效原因。	1
chronaxis.core.expression_integer_reference	在单点64位整数与浮点输入上执行取余、位提取和精确转整数。	1
chronaxis.core.expression_integer_v4	将版本4整数编码、位选取和显式数值类型转换编译为冻结节点。	3
chronaxis.core.expression_math_numpy	在NumPy列上执行极值、限幅与开方，结果与质量均按行输出。	1
chronaxis.core.expression_math_reference	逐点解释已统一dtype和单位的极值、限幅与平方根节点。	1
chronaxis.core.expression_math_v4	编译版本4的逐点极值、限幅、平方和开方表达式。	4
chronaxis.core.expression_numpy	在同长度信号列上批量求值表达式，并逐位置保留质量诊断。	9
chronaxis.core.expression_point	为流式状态上的一个时刻准备独立生产求值，不装箱成单元素数组。	10
chronaxis.core.expression_reference	用独立标量计算求值表达式，并保留未知结果的原因。	6
chronaxis.core.expression_v4	为版本4表达式编译一次性单位转换，统一处理当前单位与函数规则。	13
chronaxis.core.extension_points	把宿主已经明确注册的纯函数调用编译进白名单表达式树。	1
chronaxis.core.function_contracts	列出已实现内置逐点函数的固定签名与编译、质量、更新和后端契约。	4
chronaxis.core.integral_sum	定义积分求和的返回值和容量限制。输入是各时间段已经算好的面积，输出包含总和及数值错误；有效时长和缺失区间另行保存。面积相加结束后才换算到输出单位。本模块本身不执行求和。	5
chronaxis.core.integral_sum_numpy	按原顺序累加各段积分面积，并用NumPy保存浮点误差项，减少大数相减后丢失小数的情况。每次push处理一块面积，finish返回当前总和并换算输出单位。partial_limit限制误差项数量；容量不足会报错。中途溢出后，后续抵消不会把结果恢复为正常值。	10
chronaxis.core.integral_sum_reference	逐项累加积分面积，并保存浮点误差，供NumPy实现对照。例如很大的正负数抵消后，仍需尽量保留夹在其中的小数。误差项最多保存partial_limit个，超过时抛错。finish返回当前结果，不删除累计状态；中途溢出会持续标记为错误。	8
chronaxis.core.integral_terms	定义积分求和之前的各段面积。每段使用左端最近一次有效值乘以该段秒数，这种计算方式称为前值保持积分。面积按原时间顺序保存，另有有效标记；无效位置即使存了0，也不能当成测得的零。	6
chronaxis.core.integral_terms_numpy	用NumPy计算每个时间段的前值保持积分面积。先裁剪时间范围，再用左端有效值乘以实际秒数；返回面积数组、有效标记、覆盖时长和缺失原因。这里不先求各块总和，也不换算最终单位。	3
chronaxis.core.integral_terms_reference	逐段计算当前区间时沿用的最近值保持积分面积，供NumPy实现对照。每段先确定落在请求范围内的实际时长，再乘以左端有效值。未知数据不会补成零；无法精确转成浮点数、面积溢出或下溢时记录原因。	1
chronaxis.core.lookup	校验 v4 一维标定表声明，并按已请求的插值方式生成只读计算表。	11
chronaxis.core.lookup_compiler	将 v4 lookup 的固定签名和表名引用编译为单输入节点。	1
chronaxis.core.lookup_numpy	通过 NumPy searchsorted 为整批活动样本查表并计算线性或阶梯输出。	1
chronaxis.core.lookup_reference	用标量二分搜索一维表，精确命中和两种阶梯模式直接取节点原值。	1
chronaxis.core.mean_weights_numpy	以独立NumPy运算执行均值权重归一化，不调用标量数值核。	1
chronaxis.core.mean_weights_reference	复用标量均值的先归一化再相乘规则，避免先求面积导致溢出。	1
chronaxis.core.message_binding	为当前消息表达式声明参数，并把独立消息仓事实关联为运行绑定。	22
chronaxis.core.models	把调用者提供的内存观测构造成不可变模型，并检查身份、时间和质量约束。	20
chronaxis.core.moments	声明 v4 样本与时间二阶统计的操作、自由度和输出量纲。	3
chronaxis.core.moments_numpy	按有限 NumPy 块维护加权中心矩或均方根，不收集历史。	4
chronaxis.core.moments_reference	以精确有理数维护参考端的加权中心矩或均方。	4
chronaxis.core.normalize_numpy	按信号声明转换一列原字段值，并保留有效性、质量和原来源身份。	4
chronaxis.core.numeric	把已解码的单个值转换成声明类型，并提供独立的标量运算参考实现。	7
chronaxis.core.numeric_numpy	对同长度数值列执行算术和比较，并逐位置记录有效性与质量。	12
chronaxis.core.numeric_point	生产逐点计算的定宽数值原语，不构造单元素数组。	11
chronaxis.core.quantile_numpy	为已付费的样本数组作原dtype全局排序，然后仅恢复两个标量端点。	1
chronaxis.core.quantile_reference	在标量原dtype域排序并对唯一一对相邻样本作精确加权插值。	1
chronaxis.core.quantiles	保存精确样本分位数的有限预算状态，结束时定位两个顺序统计值。	9
chronaxis.core.rate_numpy	用原dtype列、局部时间和中心化NumPy归约计算差分与等权拟合。	4
chronaxis.core.rate_reference	用独立标量差分和中心化等权回归计算有效真实样本的每秒变化率。	3
chronaxis.core.rate_transforms	为三类时序变化率核对数值输入和单位，并选择逐点或数组后端。	5
chronaxis.core.record_intervals	从相邻两次相关更新取得计算间隔，不创建另一套时间坐标。	6
chronaxis.core.rolling_values	对已裁剪的有限保持区间求一个滚动网格值。	1
chronaxis.core.sample_reduction	定义按真实样本计算最小值、最大值和算术平均值时使用的数据对象。样本数来自实际更新，不把一个值保持了多少时间段当成多个样本。数值与筛选条件的缺失时间分别保存；本模块只检查数据，不执行统计。	7
chronaxis.core.sample_reduction_numpy	用NumPy从真实更新中计算样本最小值、最大值和算术平均值。筛选条件为真且数值有效的样本才参与计算；条件未知会单独记录。结果累计器只保留后续计算需要的状态，不保存此前每个样本。	8
chronaxis.core.sample_reduction_reference	逐个处理真实更新，计算样本最小值、最大值和算术平均值，供NumPy实现对照。整数极值保留整数精度；平均值按输入顺序累加。保持出来的值和窗口边界不算新样本。	8
chronaxis.core.scalar	保存数值及枚举的声明类型、有效性和质量原因。	3
chronaxis.core.selection	声明已解码信号层的选择行，保留时间、原值、三值状态和来源身份。	4
chronaxis.core.sequence	在同一会话内把请求点和响应点逐个配对。保存未匹配请求，按允许延迟匹配最早合格请求；区分成功、完整等待无响应和数据不足。详见请求响应。	7
chronaxis.core.sequence_reference	按时间组将请求与响应FIFO配对，区分未响应和无法确定。	10
chronaxis.core.stability	根据一个条件进行防抖，或根据两个条件进行迟滞报警。计时跨数据批次保持，数据未知会中断活动；详见规则例子。	15
chronaxis.core.start_end	从开始条件到结束条件记录活动，并区分超时与缺观测。	11
chronaxis.core.state	检查内存样本的原行身份，并按有限有效期查询最新观测或提交同一时刻更新。	14
chronaxis.core.state_numpy	用二分索引和质量掩码查询信号的最新观测，按有效期判断能否使用。	8
chronaxis.core.temporal	定义事件检测中使用的条件时间段、单个时刻的条件结果、规则和事件。条件有三种状态：TRUE表示成立，FALSE表示不成立，UNKNOWN表示数据不足以判断，必须同时保存原因。活动的时间范围包含起点、不包含终点；文件读完不等于条件变假。	14
chronaxis.core.temporal_clock	检查本批实际边界对应的计时增量，不构造另一条时间轴。	1
chronaxis.core.temporal_memory_numpy	通过NumPy保持和表达式计算内存信号的条件时间轴，再检测事件。	3
chronaxis.core.temporal_memory_reference	从已绑定的内存信号计算条件时间轴，再用参考检测器找出活动和点事件。	4
chronaxis.core.temporal_numpy	按列查找连续TRUE区间和真实边沿，再将匹配结果构造成事件。	9
chronaxis.core.temporal_reference	逐时间组检测持续条件和真实边沿，输出已经确认的活动或点事件。	10
chronaxis.core.time_reduction	定义按持续时间计算统计结果时保存的内容，包括有效时长、缺失区间、样本数量及计算值。min_time/max_time寻找实际持续过的最小/最大值，time_weighted_mean按持续时间加权，duration累计条件成立的秒数。本模块定义这些数据和检查规则，不执行计算。	8
chronaxis.core.time_reduction_numpy	用NumPy逐块计算时间最小值、最大值、加权平均值或条件成立时长。每段用左端值代表该段持续时间；time_weighted_mean先取得总有效时长，再按各段时长比例累计。块之间只保留计算状态，不保存此前整列数据。	7
chronaxis.core.time_reduction_reference	逐段计算时间最小值、最大值、加权平均值或条件成立时长，供NumPy实现对照。push接收下一块数据，finish整理最终值。time_weighted_mean需要先统计总有效时长，再按时长比例计算；整数极值不先转成浮点数。	7
chronaxis.core.types	定义信号类型、时间坐标、三值条件和质量原因，供模型及计算层共用。	7
chronaxis.core.unit_conversion	在配置编译时确定版本4的单位转换和数值类型。	5
chronaxis.core.unit_registry	在编译期解析版本4的有限单位目录，并推导转换及复合单位。	32
chronaxis.core.units	检查转换系数和范围端点的原生有限数值；单位关系由 unit_registry 统一提供。	1
chronaxis.core.validation	检查核心模型的文本、简单名称、来源序号和不可变标量。	4
chronaxis.core.where_updates	按 where 当前选择判断某一组是否更新输出，独立于输出的数值是否改变。	8
chronaxis.core.window_delta	定义最近一段完整时间内的首尾变化量、方向和单调限制；变化量单位仍是信号单位，不是每秒变化率。详见window_delta。	6
chronaxis.core.window_delta_numpy	用数组掩码计算窗口覆盖、首尾位置和整窗单调性。	1
chronaxis.core.window_delta_reference	用独立Python遍历计算完整窗口变化量，作为数组实现的数值参考。	1
chronaxis.core.windows	声明事件窗口和片段结果，校验归属并保存请求、实际边界与原活动关联。	8
chronaxis.core.windows_numpy	独立用NumPy扩展、分组和裁剪事件窗口，再恢复片段模型。	1
chronaxis.core.windows_reference	独立用Python精确整数扩展、合并并裁剪事件窗口，输出完整片段事实。	1
chronaxis.dbc_loading	集中加载DBC文本，不进入第三方持久缓存入口。	1
chronaxis.execution	保存新执行层内部组件，公共入口由根包AnalysisRunner按需加载。	0
chronaxis.execution.batch_signal_groups	将已校验的解析信号批按watermark归为同一时刻组，不创建磁盘历史。	6
chronaxis.execution.calculation_values	读取计算列中的有效标量，并按当前消息原值决定方向桶及跳过原因。	5
chronaxis.execution.can_batch_reader	将有界CAN批次接成按需历史，保留每条原yield的时间及必要记录的原序。	11
chronaxis.execution.can_block_codec	普通 CAN 有界数据块；只恢复固定记录，绝不加载任意 Python 对象。	34
chronaxis.execution.can_reader	把旧 CAN 读取和解码程序接到 Chronaxis，按批次返回信号样本。创建读取器或查询描述时不会打开 BLF、DBC；第一次取数据时才启动读取进程。	46
chronaxis.execution.csv_observation	在读取CSV的同时记录实际第一行和最后一行的时间。只有读到文件末尾并完成清理后，才能取得完整的观测范围；该范围来自数据行，不从请求窗口推算。	37
chronaxis.execution.csv_reader	在独立信号CSV读取、引用记录累积和数组分配前申请共享预算。	48
chronaxis.execution.current_message_calculation	用三格式共用的消息计算一项逐报文累计，不建立消息历史或原帧副本。	9
chronaxis.execution.driver_expression	从已提交的同一时刻信号状态取得所选驱动的数值或BOOL表达式，不保存输入历史。	14
chronaxis.execution.frame_capture	为显式报文导出保存同次记录和新编码所需DBC上下文。	15
chronaxis.execution.groups	定义现役记录流一次交付的完整同一时刻组，不执行磁盘回放或排序。	2
chronaxis.execution.history	估算现役来源/表达式元数据和未完成批协议状态，不保存或回放历史。	4
chronaxis.execution.history_records	定义已解码历史记录与严格JSONL格式，不再次归一化数值。	8
chronaxis.execution.hosted_sample_reduction	把有限真实样本块交给明确注册的宿主归约，复用原半开选择、覆盖与独立数值后端。	5
chronaxis.execution.legacy_frame_samples	把同次BLF原帧仓与稀疏解码仓按原序连接，供新增报文重建使用。	6
chronaxis.execution.memory_reader	在既有内存适配器之外预留输入、批次与协议状态预算。	12
chronaxis.execution.message_delivery	在读取器已有预算内同步交付必要消息，不建立额外历史或结果副本。	1
chronaxis.execution.parallel_can_decode	按文件并行解码并恢复一个来源的连续记录流。	21
chronaxis.execution.parallel_can_worker	单个可复用CAN文件工作进程：读取、解码并按许可交付有限数据块。	4
chronaxis.execution.raw_signal_groups	把三格式共用的已解码更新交给实时完整同一时刻组消费者，不写历史文件。	8
chronaxis.execution.record_alarm_duration	仅在请求报警累计时，按实际有效区间折算所选周期。	7
chronaxis.execution.record_delta_condition	在当前窗口内保留必要数值片段，输出窗口变化量的三值条件。	8
chronaxis.execution.record_diagnostics	仅在请求追溯或完整性诊断时观察同次输入，不增加来源扫描。	5
chronaxis.execution.record_event_durations	按需计算每段事件的持续时长，只为周期模式保存必要驱动时间。	10
chronaxis.execution.record_export_samples	只在片段信号导出需要回看时保存所选样本；每行一个值和一个实际时间。	8
chronaxis.execution.record_exports	只为显式导出接同次读取的帧或样本；复用既有writer和结果发布。	10
chronaxis.execution.record_integral	在有限内存内累计已求值的驱动记录对，保留实际端点直到比例裁剪完成。	7
chronaxis.execution.record_object_counts	从已经封口的规则与窗口输出构建会话级对象计数，不回读结果仓。	1
chronaxis.execution.record_point_buffer	共享有限驱动点的接收与失效处理，不执行数值统计或创建历史。	4
chronaxis.execution.record_rule_timeline	用最新必要信号在线推进一条规则，不保存输入历史或第二时间轴。	17
chronaxis.execution.record_sample	记录流只保一份逻辑值；枚举单独保必要整数码，公共来源定义共享引用。	6
chronaxis.execution.record_sample_series	把一小批实际记录及有效截止交给既有样本统计/选择核。	1
chronaxis.execution.record_scope_calculations	只对明确的事件指标保存必要计算值，并按事件真实范围回读。	15
chronaxis.execution.record_selection	把真实样本更新有界地交给原select核，并直接写最终选择表。	5
chronaxis.execution.record_sequences	收齐同一时刻的请求、响应和条件后配对，直接交付最终结果。	11
chronaxis.execution.record_session_calculations	在原AnalysisRunner会话内合并所需来源并执行会话时间指标。	31
chronaxis.execution.record_signal_export	会话信号CSV随同次合并流在线写出；只暂留最后一个所需时刻组。	11
chronaxis.execution.record_source_cursor	按需读取一个来源并提供完整同一时刻组，供多来源按时间合并。	14
chronaxis.execution.record_time_calculation	用有限记录计算时间统计和真实样本统计；仅时间均值暂存必要值/权重。	10
chronaxis.execution.record_time_indexes	只为周期选窗/事件时长保存一份所需驱动时刻，按索引定位。	11
chronaxis.execution.record_value_history	只为需要回看范围的消费者保存计算值，一份实际时间和必要有效截止。	12
chronaxis.execution.record_windows	从最终事件表生成窗口，不再复制一份事件阶段或重扫原输入。	8
chronaxis.execution.result_aggregations	在最终结果行产生时按具名引用分组。只保存归约状态和精确分位数所需的样本。	12
chronaxis.execution.run_session	执行一份分析计划：读取来源并保存历史，再生成事件、窗口片段和指标，最后返回统一的结果对象。它还负责将本次资源交给结果对象管理，避免读取结束后文件仍无人关闭。	18
chronaxis.execution.same_frame_integrals	把同一物理报文的简单数值表达式直接交给现役实际时间积分器。	12
chronaxis.execution.signal_validity	从本次已经加载的DBC元数据补全必要信号的有效期。	1
chronaxis.execution.state	保存每个信号最新的值。同一时刻的全部更新收齐后一起写入状态，表达式不会看到“电压已更新、电流还未更新”的半成品。状态还保存时间、有效期和质量原因。	26
chronaxis.execution.static_metadata	按实际对象身份估算一次运行借用的静态声明，不展开重复引用。	2
chronaxis.execution.temporal_buffer	在运行时序规则前，先为本次输入和可能产生的事件申请内存。输入是一组完整的ConditionTick，以及规则、会话范围和来源引用；可选配置包括持续稳定要求和迟滞退出条件。返回TemporalEventBatch，使用完后须调用close。	34
chronaxis.execution.text_can_reader	把ASC、BLF、原始CSV的同次解码接到公共信号批次和真实观测协议。	25
chronaxis.execution.transform_partial	区分滚动输入窗口的部分性和下游查询轴的覆盖率，只标记确实参与的原值。	2
chronaxis.execution.transform_stream	在原始记录流及下游规则之间插入按需的时序变换。	17
chronaxis.execution.transform_window	保留一个变换所需的有限真实记录区间，按原端点裁剪滚动窗口。	9
chronaxis.execution.where_state	从最新完整组提取 where 的反事实输入和活动更新证据，不读历史文件。	4
chronaxis.extension_runtime	托管可信回调的后端调用、有限资源、返回形状及取消和关闭责任。	21
chronaxis.extensions	由宿主Python程序显式声明可信扩展，纯配置只引用其已注册名称。	14
chronaxis.fast	CAN同帧累计入口：单会话可并行处理分卷，主进程按确定顺序累计。	0
chronaxis.fast.main	直接运行fast单会话配置；输入可包含同一来源的多个分卷。	0
chronaxis.fast.baseline	修复版 base 的测量入口。输入为冻结的文件参数，只测读取、直接累计及发布。	1
chronaxis.fast.batch	先检查整批 fast 配置，再交给文件级工作进程；结果按声明顺序发布。	2
chronaxis.fast.blocks	贡献块的有界二进制编码。浮点使用binary64，时间和记录序号保持整数。	3
chronaxis.fast.can_io	修复版 ChrgInfo 文件循环：先选 ID，再解码一次并更新该帧的全部公式。	3
chronaxis.fast.cli	fast单会话及独立批量命令的JSON响应；静态命令不读取报文文件。	2
chronaxis.fast.compute	把单帧数值公式准备成直接读取解码字典的函数，按原始到达顺序累计。	20
chronaxis.fast.config	把一个CAN来源编译成fast会话，共用Chronaxis的单位、类型与来源位置规则。	8
chronaxis.fast.run	准备和执行单会话同帧累计，仅在全部输入、累计和资源关闭成功后发布结果。	2
chronaxis.fast.session	一个fast会话的多文件调度和最终累计。	30
chronaxis.fast.session_worker	可复用文件worker：流式求贡献，获得父进程许可后直传或直接写暂存。	1
chronaxis.fast.stream	流式读取单文件并产出当前帧贡献，不维护跨帧信号或最终累计。	8
chronaxis.fast.totals	按独立文件模板的声明顺序汇总同一业务指标。只在请求 --total 时使用。	4
chronaxis.fast.worker	在本工作进程内执行事先验证的参数，只上传本文件的少量结果。	3
chronaxis.legacy	公开旧CAN记录，以及按需加载的记录仓、逐次模型与贡献累计原语。	1
chronaxis.legacy.batch_read	在共享预算内按批取得BLF解码结果，按配置保留观测时间与所需原始记录。	13
chronaxis.legacy.batch_validation	校验批次中不再保存的原报文，避免为丢弃的数据建立完整解码记录副本。	3
chronaxis.legacy.batch_wire	定义父进程和CAN读取子进程之间使用的批次格式。一个字节包包含多少条记录、每条记录怎样编码和校验，都由这里规定。它不执行读取或DBC解码，也不反序列化任意Python对象。	7
chronaxis.legacy.batch_worker	在隔离子进程按有限批次读取BLF，并按显式串行政策解码。	5
chronaxis.legacy.binding	用报文 ID、所需信号和实际帧类型选择 DBC 定义。	8
chronaxis.legacy.dbc_cycles	核验明确请求的DBC报文周期，不读文件、不解码报文或生成逐条诊断。	2
chronaxis.legacy.decode_policy	原始报文的长度检查与显式纯BLF串行解码政策。	3
chronaxis.legacy.disjunction	按当前报文中的方向信号，把一次计算的贡献值分到正向或负向组。它保存原方向值和来源位置，便于核对分组原因；分组本身不对贡献值取绝对值或改变公式符号。	4
chronaxis.legacy.export_worker	在独立spawn进程按PUT许可将原报文写入新的BLF文件。	3
chronaxis.legacy.export_write	在独立进程把原始帧交给共用BLF写入器，真实收尾后才确认完成。	23
chronaxis.legacy.message_store	把逐报文解码结果写入JSONL文件，随后按顺序读取，供旧版指标对照计算使用。写入时传入LegacyDecodedFrame、已换算的整数纳秒时间及时间量化信息；本模块不筛选、去重或再次换算时间和值，也不执行分析规则。	24
chronaxis.legacy.process_read	在独立进程中逐次读取并解码BLF，确认退出后才交付完整EOF。	26
chronaxis.legacy.raw_store	按首次CAN读取的原序暂存完整报文，供片段发布回读而不重扫原输入。	17
chronaxis.legacy.records	保留单BLF协议的报文、解码值、定位和有界IPC字段。	36
chronaxis.legacy.required_records	保存按需分析实际使用的CAN记录、原值和来源位置。计算不需要时间时可以明确不采集时间，但不能把缺少的时间填成0或据此计算观测范围。	8
chronaxis.legacy.sum	按旧逐消息算法的顺序累加已经计算出的贡献值，并记录跳过原因。这里的累计不是按时间积分；数值结果和逐次记录由调用方提供。保存状态和临时块都受资源额度限制。	16
chronaxis.legacy.sum_numpy	用NumPy按输入顺序累计一块逐消息贡献值，保留与旧逐次加法相同的先后关系。它不改变每条消息的公式，也不把数据重新排序后求和。	1
chronaxis.legacy.updates	表示旧路径一次实际求值所见的更新，并校验单来源的求值顺序。	15
chronaxis.legacy.worker	在独立spawn进程按单条PULL许可调用共用BLF读取与串行解码政策。	12
chronaxis.planning	公开配置构建、静态检查和计划解释入口。	0
chronaxis.planning.aggregations	校验 v4 结果表聚合的来源、字段、分组、总体政策与输出单位。	3
chronaxis.planning.backend_selection	依据整个计划的静态类别选择数值后端，不读取输入或试跑计算。	4
chronaxis.planning.channels	把用户配置的 CAN 通道转换为内部编号，不读取报文或修改原始数据。	1
chronaxis.planning.checks	检查JSON/YAML解析后的配置值，并在错误中保存具体字段位置。	21
chronaxis.planning.config_groups	把当前配置的就地分组送入既有解析器，不改变时间或数值规则。	5
chronaxis.planning.dbc_defaults	仅在信号省略类型/单位或enum映射时读取DBC元数据，不读取报文。	8
chronaxis.planning.diagnostic_collection	一次收集独立配置错误，并阻断依赖坏声明的检查。	19
chronaxis.planning.export_options	把JSON中的signal_csv/can_frames选项转换成输出规格，检查信号、来源和窗口引用；只检查配置，不读日志或DBC。全部填写方式见导出。	12
chronaxis.planning.input_defaults	补齐来源的常用声明，只有唯一候选时自动选择引用。	2
chronaxis.planning.input_paths	将文件、目录或通配符展开为有序输入，不读取报文内容。	4
chronaxis.planning.input_requirements	根据实际请求的指标、事件和导出，确定需要读取哪些信号、需要检查哪些输入以及是否需要时间。配置中声明过一个信号，并不代表每个任务都必须读取它。	7
chronaxis.planning.inputs	检查来源和信号配置，建立静态定位与显式转换声明。	2
chronaxis.planning.intervals	声明计算所用的间隔及可选诊断，不读取报文或建立额外时间轴。	14
chronaxis.planning.legacy_execution	在读取前校验逐消息计划的时间域与CAN读取策略；不选择历史兼容路径。	1
chronaxis.planning.lookups	在静态配置中解析 v4 一维表；仅创建冻结点对，不创建求值数组或打开文件。	1
chronaxis.planning.message_calculations	静态解析当前消息legacy_sum声明，保持解码profile和新计算policy分开。	2
chronaxis.planning.models	保存配置解析得到的来源、信号、计算节点和执行选项声明。	17
chronaxis.planning.nodes	检查计算条件、窗口和指标配置，保存静态依赖与边界声明。	5
chronaxis.planning.plan	把分析配置转换成经过静态检查的分析计划。	6
chronaxis.planning.preset_models	定义预设配置及其角色要求。例如充电预设需要电流角色，角色可要求特定单位、方向或测量位置。展开后的规则、窗口和指标仍是普通分析配置，可以保存为JSON。	9
chronaxis.planning.process_execution	静态检查单会话文件读取并行的支持范围，不打开日志或DBC。	2
chronaxis.planning.record_execution	声明新记录流当前可执行范围；静态报告与实际会话共用同一检查。	2
chronaxis.planning.reports	解释已构建计划的声明检查结果、计算依赖和当前能力限制。	9
chronaxis.planning.sequences	检查请求/响应点事件配对的公开声明，不读取信号或执行配对。	4
chronaxis.planning.signal_groups	把同一报文的集中声明展开为既有信号绑定，不增加运行时分组或重复读取。	2
chronaxis.planning.signal_validity	确定信号的有效期声明，不读取DBC或日志。	2
chronaxis.planning.text_inputs	把ASC或原始报文CSV来源配置转换成读取规格，明确文件顺序、时间格式、偏移和DBC通道；不会自动猜日期或格式。见文本输入。	1
chronaxis.planning.transforms	解析 v4 时序变换的名称图、时间网格、输入表达式及输出单位。	6
chronaxis.presets	把四种预设展开为普通规则、窗口、指标或请求响应配对。检查角色对应的信号类型、单位和必要语义，不读取输入；全部参数见预设。	5
chronaxis.process_capabilities	按实际调度需求提示 Linux 受管工作进程的能力，不执行分析。	3
chronaxis.results	提供带有明确类型的结果行、共享预算、有限暂存、流式读取与发布协议。	1
chronaxis.results.aggregation_row	保存组级值、明确总体和互斥的纳入/排除计数，版本15不改变旧结果行。	2
chronaxis.results.analysis_outcome	说明一次执行为何有或没有业务结果，不保存逐条输入或重复时间记录。	6
chronaxis.results.artifact_exports	管理本次生成的导出文件及其索引。结果发布时复制并核对这些文件，不再重新计算导出数据。关闭对象会释放读取资源，文件是否发布由单独状态记录。	13
chronaxis.results.binding_metadata	在运行清单中记录使用了哪个预设版本，以及每个角色最终对应哪个信号。这里只保存已有选择，不重新读取来源或再次检查信号的业务含义。	4
chronaxis.results.blf_writer	独占持有一份BLF输出文件，委托既有python-can格式写入，不重写BLF编码。	6
chronaxis.results.budget	记录新分析部分已申请多少内存额度，以及还允许申请多少。超过配置上限时抛BudgetExceededError。这里的预算是字节数，不是金额，也不是操作系统对整个Python进程施加的硬限制。	10
chronaxis.results.can_metadata	保存一次CAN读取的记录：使用的输入和DBC、原始报文暂存信息、声明单位与DBC单位的比较结果。记录来自实际执行；仅仅构造这些对象不会重新读取或验证文件。	9
chronaxis.results.codec	编码和严格解码当前扁平结果JSONL；内部叶子格式另用于历史和导出。	8
chronaxis.results.errors	定义分析、暂存、资源限额和结果发布过程中使用的异常类型。调用方可据此区分“超过内存限额”“结果已经关闭”“文件格式损坏”等失败原因；异常出现不代表此前生成的文件已经回滚。	5
chronaxis.results.export_files	用有限大小的缓冲写出一组导出文件。所有文件关闭成功后才把临时目录改成正式目录；已有目标不会被覆盖。关闭失败时保存对应文件对象，以便重试清理。	13
chronaxis.results.frame_exports	把明确范围内的原帧写成新ASC或复用旧封装的BLF，同时保精确逐帧索引。	10
chronaxis.results.frame_patch	用已有DBC位域工具更新明确的连续信号，其他位沿用同一基础帧。	9
chronaxis.results.frame_rebuild	用同次读取中已解码的连续物理量，在指定时间网格上生成报文。只改选中字段的位，其他位复制同一最近原帧；未选报文默认原样透传。见导出限制。	25
chronaxis.results.frame_sort	为离线报文导出进行有界磁盘排序，不把整段报文留在内存。	14
chronaxis.results.input_diagnostics	保存明确请求的输入检查范围；摘要只覆盖实际交给分析层的记录。	3
chronaxis.results.manifest	定义运行清单和输出清单。运行清单记录配置、实际输入、时间解释、使用的实现及资源统计；输出清单记录发布后的文件和状态。未取得的信息保留为空，不把空值解释为检查通过。	9
chronaxis.results.merge_runs	在固定内存和文件句柄数量内归并多份已排序结果，减少中间文件重复写入。	6
chronaxis.results.owned_directory	只删除本次明确新建的私有目录，拒绝路径被重定向或目录被替换。	2
chronaxis.results.platform_files	按平台原语不覆盖地移动一个文件或目录，不复制内容或重读分析输入。	8
chronaxis.results.publication	给同次输出分配时间文件名，并在已有结果目录中不覆盖地发布。	6
chronaxis.results.raw_exports	保存原始片段索引并复制已生成的BLF，不重新调用旧读写或解码路径。	31
chronaxis.results.readable	将结果流关联成可直接阅读的CSV，不重新读取或计算输入。	19
chronaxis.results.readable_format	将已计算的时间、状态和质量格式化为可读文字，不改变计算结果。	4
chronaxis.results.result	管理一次已完成的分析结果。游标逐行读取平坦摘要，write向新目录发布；close关闭读取资源，默认清理本次程序为本次运行创建的临时数据，原输入与已发布结果保留。	33
chronaxis.results.rows	为当前平坦结果确定所属表和稳定排序键，不构造额外结果包装。	2
chronaxis.results.signal_exports	将指定信号的已解码历史写为原始采样及可选连续量网格CSV长表。	12
chronaxis.results.signal_grid	把明确选中的连续信号整理为等间隔记录：实测点保留，可靠相邻点之间线性估计，其余位置输出缺失原因。分析规则不会使用这些估计值。	12
chronaxis.results.spool	把结果行先写到专用临时目录，内存中只保留有限缓冲；写入结束后按稳定顺序合并各部分。之后可顺序读取并发布结果。写入或关闭失败时保留错误和清理所需资源，避免把不完整文件当作完成结果。	18
chronaxis.results.summary	定义按需执行的精简指标行，不要求不存在的完整输入证明。	20
chronaxis.results.text_can_metadata	记录本次ASC或原始报文CSV读取使用的解析设置、DBC和实际起止时间。这些信息放入文本CAN的运行清单，便于复核输入；它不代表原BLF读取路径的检查结果。	2
chronaxis.results.threshold_metadata	保存一次阈值报警预设在实际观测范围内的时长汇总。	10
chronaxis.runner	这是大多数应用只需要调用的执行入口。先用load_analysis_plan读取配置，再用AnalysisRunner.validate检查声明、AnalysisRunner.explain查看将用哪些信号，最后AnalysisRunner.run实际读取数据并计算。run返回的AnalysisResult可逐行读取，也可write到可复用的结果目录；用with语句保证文件和游标及时关闭。	7
chronaxis.sources	按需公开来源适配器和批次模型；读取 BLF 不加载无关的数组后端。	1
chronaxis.sources.asc	按明确指定的ASC版本逐行读取原始CAN报文，保留文件位置与原时间；格式错误立即报告，不自动切换解析器。公共can_asc入口使用本读取器。	21
chronaxis.sources.blf	为普通分析与高性能积分器共用既有python-can BLFReader；不重新实现BLF格式解析。	9
chronaxis.sources.can_spec	声明有序BLF来源，并保存解码样本的完整CAN定位。	8
chronaxis.sources.can_updates	把三种原始报文入口的必要值交付给同一个逐消息计算模型。	10
chronaxis.sources.csv_spec	声明独立已解码信号表的格式，并保存每个CSV样本的位置。	4
chronaxis.sources.descriptions	把显式信号定义转成来源的静态字段描述。	2
chronaxis.sources.memory	把调用者已经提供的内存信号按有限批次交给分析层。	9
chronaxis.sources.models	规定读取来源时怎样描述字段、提出读取请求，以及怎样返回一批信号数据。ReadRequest.batch_rows是所有信号样本数之和，例如一行CSV包含两个信号更新，就占两个样本。这里的数据对象帮助读取器和分析器按同一格式交接。	17
chronaxis.sources.packing	把一批已解码标量归一化为可传送的独立信号列。	3
chronaxis.sources.protocol	约定来源的描述、分批读取和关闭接口，并检查跨批承诺。	9
chronaxis.sources.raw_can	保存原始CAN记录及位置；文本用物理行，BLF用记录序号。	4
chronaxis.sources.raw_csv	按明确列映射和时间格式直接读取原始CAN报文CSV，得到原始报文和行位置；不先转换为ASC。DBC解码由上层继续处理。	24
chronaxis.sources.raw_csv_layout	定义原始报文CSV的列名/列号、固定值和值映射；只做列对应，不解码报文。它供已实现的raw_can_csv公共入口使用。见完整例子。	16
chronaxis.sources.signal_csv	读取明确格式的已解码CSV或TSV信号表，逐批传送归一化信号。	14
chronaxis.sources.text_can_decode	按需解码新ASC/CSV原帧，并接到既有数值归一化核心。	20
chronaxis.sources.text_can_ref	保存新文本CAN样本的精确原行引用，供信号历史和结果白名单编码。	2
chronaxis.sources.text_can_spec	冻结ASC/BLF连续来源或原始CSV到DBC信号的声明，不在构造时读取文件。	4
chronaxis.timebase	集中导出时间转换和标准库整数时间运算。	0
chronaxis.timebase.conversion	把明确单位的时间数值或完整日期转换为整数纳秒，并保存转换诊断。	10
chronaxis.timebase.numpy_ops	对一列纳秒时间执行固定偏移或计算相邻时间差，返回独立的新数组。	3
chronaxis.user_guide	定位可以直接阅读的AI指南，按显式请求另存独立ZIP。	3

全部对象（按限定名称）

对象	种类
`chronaxis.__getattr__`	function
`chronaxis._batch_worker._diagnostics`	function
`chronaxis._batch_worker.worker_main`	function
`chronaxis._control_models.native`	function
`chronaxis._control_models.keys`	function
`chronaxis._control_models.extract`	function
`chronaxis._control_models._scalar`	function
`chronaxis._control_models._restore_scalar`	function
`chronaxis._control_models.pack_signal`	function
`chronaxis._control_models.restore_signal`	function
`chronaxis._control_models.pack_input`	function
`chronaxis._control_models.restore_input`	function
`chronaxis._control_models.pack_source`	function
`chronaxis._control_models.restore_source`	function
`chronaxis._control_models.pack_options`	function
`chronaxis._control_models.restore_options`	function
`chronaxis._control_models.pack_frame_context`	function
`chronaxis._control_models.restore_frame_context`	function
`chronaxis._control_models.pack_result`	function
`chronaxis._control_models.restore_result`	function
`chronaxis._control_models.pack_message`	function
`chronaxis._control_models.restore_message`	function
`chronaxis._control_models._object`	function
`chronaxis._control_models._program`	function
`chronaxis._control_models.check_fast_spec`	function
`chronaxis._control_models._check_fast_rows`	function
`chronaxis._control_models.check_message_fields`	function
`chronaxis._control_wire.ControlProtocolError`	class
`chronaxis._control_wire._pairs`	function
`chronaxis._control_wire._depth`	function
`chronaxis._control_wire.encode_json`	function
`chronaxis._control_wire.decode_json`	function
`chronaxis._control_wire.decode_json.constant`	function
`chronaxis._control_wire._integer`	function
`chronaxis._control_wire._time`	function
`chronaxis._control_wire._check`	function
`chronaxis._control_wire._short`	function
`chronaxis._control_wire._diagnostics`	function
`chronaxis._control_wire.ControlChannel`	class
`chronaxis._control_wire.ControlChannel.__init__`	function
`chronaxis._control_wire.ControlChannel._limit`	function
`chronaxis._control_wire.ControlChannel._direction`	function
`chronaxis._control_wire.ControlChannel.send`	function
`chronaxis._control_wire.ControlChannel.recv`	function
`chronaxis._control_wire.ControlChannel.__enter__`	function
`chronaxis._control_wire.ControlChannel.__exit__`	function
`chronaxis._control_wire.ControlChannel.poll`	function
`chronaxis._control_wire.ControlChannel.fileno`	function
`chronaxis._control_wire.ControlChannel.closed`	function
`chronaxis._control_wire.ControlChannel.close`	function
`chronaxis._process_start.registered_entry`	function
`chronaxis._process_start.StartupGate`	class
`chronaxis._process_start.StartupGate.__init__`	function
`chronaxis._process_start.StartupGate.closed`	function
`chronaxis._process_start.StartupGate.receive`	function
`chronaxis._process_start.StartupGate.close_child`	function
`chronaxis._process_start.StartupGate.close`	function
`chronaxis._process_start.spawn_entry`	function
`chronaxis._version.software_version`	function
`chronaxis.analysis_cli.validation_json`	function
`chronaxis.analysis_cli.explanation_json`	function
`chronaxis.analysis_cli.run_static`	function
`chronaxis.analysis_cli._new_output`	function
`chronaxis.analysis_cli._cause_chain`	function
`chronaxis.analysis_cli.run_analysis`	function
`chronaxis.batch.api.run_batch`	function
`chronaxis.batch.cli.run_batch_cli`	function
`chronaxis.batch.config.load_batch_plan`	function
`chronaxis.batch.models.Closable`	class
`chronaxis.batch.models.Closable.close`	function
`chronaxis.batch.models.CleanupHandle`	class
`chronaxis.batch.models.CleanupHandle.__init__`	function
`chronaxis.batch.models.CleanupHandle.closed`	function
`chronaxis.batch.models.CleanupHandle.close`	function
`chronaxis.batch.models.BatchJob`	class
`chronaxis.batch.models.BatchJob.__post_init__`	function
`chronaxis.batch.models.BatchPlan`	class
`chronaxis.batch.models.BatchPlan.__post_init__`	function
`chronaxis.batch.models.BatchPlan.from_dict`	function
`chronaxis.batch.models.BatchJobResult`	class
`chronaxis.batch.models.BatchJobResult.__post_init__`	function
`chronaxis.batch.models.BatchJobResult.to_dict`	function
`chronaxis.batch.models.BatchReport`	class
`chronaxis.batch.models.BatchReport.status`	function
`chronaxis.batch.models.BatchReport.to_dict`	function
`chronaxis.batch.models.BatchReport.close`	function
`chronaxis.batch.process_transport.job_packet`	function
`chronaxis.batch.process_transport.restore_job`	function
`chronaxis.batch.process_transport.ProcessWorker`	class
`chronaxis.batch.process_transport.ProcessWorker.__init__`	function
`chronaxis.batch.process_transport.ProcessWorker.submit`	function
`chronaxis.batch.process_transport.ProcessWorker.submit_fast`	function
`chronaxis.batch.process_transport.ProcessWorker.cancel_fast`	function
`chronaxis.batch.process_transport.ProcessWorker.ready`	function
`chronaxis.batch.process_transport.ProcessWorker.receive`	function
`chronaxis.batch.process_transport.ProcessWorker.close`	function
`chronaxis.batch.process_tree._BasicLimits`	class
`chronaxis.batch.process_tree._ExtendedLimits`	class
`chronaxis.batch.process_tree.ProcessTree`	class
`chronaxis.batch.process_tree.ProcessTree.__init__`	function
`chronaxis.batch.process_tree.ProcessTree._register_linux`	function
`chronaxis.batch.process_tree.ProcessTree._close_linux`	function
`chronaxis.batch.process_tree.ProcessTree._close_process_handle`	function
`chronaxis.batch.process_tree.ProcessTree.close`	function
`chronaxis.batch.publication.write_batch_report`	function
`chronaxis.batch.publication._write_batch_report`	function
`chronaxis.batch.runner._new_root`	function
`chronaxis.batch.runner._facts`	function
`chronaxis.batch.runner._cancelled`	function
`chronaxis.batch.runner._report`	function
`chronaxis.batch.runner._run_job`	function
`chronaxis.batch.runner._pause`	function
`chronaxis.batch.runner.BatchRunner`	class
`chronaxis.batch.runner.BatchRunner.__init__`	function
`chronaxis.batch.runner.BatchRunner.run`	function
`chronaxis.batch.runner.BatchRunner._run`	function
`chronaxis.batch.templates.template_jobs`	function
`chronaxis.can_dependencies.CANDependencyError`	class
`chronaxis.can_dependencies.CANDependencyError.__init__`	function
`chronaxis.can_dependencies.import_can_dependency`	function
`chronaxis.can_dependencies.runtime_dependency_versions`	function
`chronaxis.cli._parser`	function
`chronaxis.cli.main`	function
`chronaxis.configuration.parse_configuration`	function
`chronaxis.configuration.load_configuration`	function
`chronaxis.configuration.cli.run_configuration_cli`	function
`chronaxis.configuration.diagnostics.field_path_parts`	function
`chronaxis.configuration.diagnostics.child_path`	function
`chronaxis.configuration.diagnostics.value_preview`	function
`chronaxis.configuration.diagnostics.locate_error`	function
`chronaxis.configuration.explanation.time_text`	function
`chronaxis.configuration.explanation._declared`	function
`chronaxis.configuration.explanation._setting`	function
`chronaxis.configuration.explanation._scope`	function
`chronaxis.configuration.explanation._validation_lines`	function
`chronaxis.configuration.explanation.validation_text`	function
`chronaxis.configuration.explanation._rule_lines`	function
`chronaxis.configuration.explanation.explanation_text`	function
`chronaxis.configuration.file_tools.configuration_type`	function
`chronaxis.configuration.file_tools.validate_document`	function
`chronaxis.configuration.file_tools.path_fields`	function
`chronaxis.configuration.file_tools.same_native_value`	function
`chronaxis.configuration.file_tools.serialize_configuration`	function
`chronaxis.configuration.file_tools.output_format`	function
`chronaxis.configuration.file_tools.write_new_configuration`	function
`chronaxis.configuration.file_tools.convert_configuration`	function
`chronaxis.configuration.imports._reject`	function
`chronaxis.configuration.imports._source_paths`	function
`chronaxis.configuration.imports._append_definitions`	function
`chronaxis.configuration.imports.expand_document_imports`	function
`chronaxis.configuration.initialization.initialize_configuration`	function
`chronaxis.configuration.json_parser._DuplicateKey`	class
`chronaxis.configuration.json_parser._unique_pairs`	function
`chronaxis.configuration.json_parser._Locations`	class
`chronaxis.configuration.json_parser._Locations.__init__`	function
`chronaxis.configuration.json_parser._Locations.location`	function
`chronaxis.configuration.json_parser._Locations.scan`	function
`chronaxis.configuration.json_parser._finite_values`	function
`chronaxis.configuration.json_parser.parse_json`	function
`chronaxis.configuration.models.field_path_text`	function
`chronaxis.configuration.models.ConfigurationLocation`	class
`chronaxis.configuration.models.ConfigurationOrigin`	class
`chronaxis.configuration.models.ConfigurationDocument`	class
`chronaxis.configuration.models.ConfigurationDocument.origin_for`	function
`chronaxis.configuration.models.ConfigurationDocument.location_for`	function
`chronaxis.configuration.models.ConfigurationError`	class
`chronaxis.configuration.models.ConfigurationError.__init__`	function
`chronaxis.configuration.origins._at`	function
`chronaxis.configuration.origins._record`	function
`chronaxis.configuration.origins.configuration_origins`	function
`chronaxis.configuration.origins.render_origins`	function
`chronaxis.configuration.overrides.apply_overrides`	function
`chronaxis.configuration.resolution._duration`	function
`chronaxis.configuration.resolution._interval`	function
`chronaxis.configuration.resolution._signal_defaults`	function
`chronaxis.configuration.resolution._analysis_defaults`	function
`chronaxis.configuration.resolution.resolved_configuration`	function
`chronaxis.configuration.resolution.resolve_configuration`	function
`chronaxis.configuration.template_catalog.ConfigurationTemplate`	class
`chronaxis.configuration.template_catalog._catalog`	function
`chronaxis.configuration.template_catalog.available_templates`	function
`chronaxis.configuration.template_catalog._relative_path`	function
`chronaxis.configuration.template_catalog.template_files`	function
`chronaxis.configuration.yaml_parser.parse_yaml`	function
`chronaxis.configuration.yaml_parser.parse_yaml.Yaml12`	class
`chronaxis.configuration.yaml_parser.parse_yaml.Yaml12.version`	function
`chronaxis.configuration.yaml_parser.parse_yaml.location`	function
`chronaxis.configuration.yaml_parser.parse_yaml.reject`	function
`chronaxis.configuration.yaml_parser.parse_yaml.check`	function
`chronaxis.configuration.yaml_parser.parse_yaml.scalar`	function
`chronaxis.configuration.yaml_parser.parse_yaml.value`	function
`chronaxis.core.affine._validate_affine`	function
`chronaxis.core.affine.affine_reference`	function
`chronaxis.core.affine_numpy._float_coefficient`	function
`chronaxis.core.affine_numpy.affine_numpy`	function
`chronaxis.core.binding._identity`	function
`chronaxis.core.binding._source_identity`	function
`chronaxis.core.binding.SignalDefinition`	class
`chronaxis.core.binding.SignalDefinition.__post_init__`	function
`chronaxis.core.binding.SignalDefinition.identity`	function
`chronaxis.core.binding.SignalDefinition.unit_conversion_promoted`	function
`chronaxis.core.binding.SynchronizationEvidence`	class
`chronaxis.core.binding.SynchronizationEvidence.__post_init__`	function
`chronaxis.core.binding.SignalBindings`	class
`chronaxis.core.binding.SignalBindings.__post_init__`	function
`chronaxis.core.binding.SignalBindings.resolve`	function
`chronaxis.core.binding.SignalBindings.source_ref`	function
`chronaxis.core.binding.SignalBindings.require_synchronized`	function
`chronaxis.core.calculation_output_numpy.convert_result_numpy`	function
`chronaxis.core.calculation_output_reference.convert_result_reference`	function
`chronaxis.core.calculations.CalculationDefinition`	class
`chronaxis.core.calculations.CalculationDefinition.__post_init__`	function
`chronaxis.core.calculations.CalculationSeries`	class
`chronaxis.core.calculations.CalculationSeries.__post_init__`	function
`chronaxis.core.calculations.CalculationResult`	class
`chronaxis.core.calculations.CalculationResult.__post_init__`	function
`chronaxis.core.calculations.CalculationConversion`	class
`chronaxis.core.calculations.CalculationConversion.__post_init__`	function
`chronaxis.core.calculations.CalculationConversion.dtype`	function
`chronaxis.core.calculations.calculation_conversion`	function
`chronaxis.core.calculations.calculation_unit`	function
`chronaxis.core.calculations.merge_ranges`	function
`chronaxis.core.calculations.classify_calculation_value`	function
`chronaxis.core.calculations.classify_coverage`	function
`chronaxis.core.calculations.make_calculation_result`	function
`chronaxis.core.calculations_memory_numpy.build_calculation_series_numpy`	function
`chronaxis.core.calculations_memory_numpy.select_memory_numpy`	function
`chronaxis.core.calculations_memory_numpy.compute_memory_numpy`	function
`chronaxis.core.calculations_memory_reference._scalar_context`	function
`chronaxis.core.calculations_memory_reference.require_calculation_plan`	function
`chronaxis.core.calculations_memory_reference.build_calculation_series_reference`	function
`chronaxis.core.calculations_memory_reference.select_memory_reference`	function
`chronaxis.core.calculations_memory_reference.compute_memory_reference`	function
`chronaxis.core.calculations_numpy._sum_finite_numpy`	function
`chronaxis.core.calculations_numpy.select_numpy`	function
`chronaxis.core.calculations_numpy.compute_numpy`	function
`chronaxis.core.calculations_reference.require_calculation`	function
`chronaxis.core.calculations_reference.select_reference`	function
`chronaxis.core.calculations_reference.compute_reference`	function
`chronaxis.core.condition_evidence._reference_truth`	function
`chronaxis.core.condition_evidence.condition_ticks_reference`	function
`chronaxis.core.condition_evidence.condition_ticks_numpy`	function
`chronaxis.core.conditional_integral_terms._unknown_duration`	function
`chronaxis.core.conditional_integral_terms.ConditionalIntegralFacts`	class
`chronaxis.core.conditional_integral_terms.ConditionalIntegralFacts.__post_init__`	function
`chronaxis.core.conditional_integral_terms.ReferenceConditionalIntegralTerms`	class
`chronaxis.core.conditional_integral_terms.ReferenceConditionalIntegralTerms.__post_init__`	function
`chronaxis.core.conditional_integral_terms.require_conditional_integral_terms`	function
`chronaxis.core.conditional_integral_terms_numpy.NumpyConditionalIntegralTerms`	class
`chronaxis.core.conditional_integral_terms_numpy.NumpyConditionalIntegralTerms.__post_init__`	function
`chronaxis.core.conditional_integral_terms_numpy.compute_conditional_integral_terms_numpy`	function
`chronaxis.core.conditional_integral_terms_reference.compute_conditional_integral_terms_reference`	function
`chronaxis.core.conditional_time_reduction._unknown_duration`	function
`chronaxis.core.conditional_time_reduction.ConditionalTimeCalculationFacts`	class
`chronaxis.core.conditional_time_reduction.ConditionalTimeCalculationFacts.__post_init__`	function
`chronaxis.core.conditional_time_reduction.require_conditional_time_series`	function
`chronaxis.core.conditional_time_reduction_numpy.NumpyConditionalTimeReduction`	class
`chronaxis.core.conditional_time_reduction_numpy.NumpyConditionalTimeReduction.__init__`	function
`chronaxis.core.conditional_time_reduction_numpy.NumpyConditionalTimeReduction.selected_weight_seconds`	function
`chronaxis.core.conditional_time_reduction_numpy.NumpyConditionalTimeReduction.selected_duration_ns`	function
`chronaxis.core.conditional_time_reduction_numpy.NumpyConditionalTimeReduction.value_valid_duration_ns`	function
`chronaxis.core.conditional_time_reduction_numpy.NumpyConditionalTimeReduction.push`	function
`chronaxis.core.conditional_time_reduction_numpy.NumpyConditionalTimeReduction.finish`	function
`chronaxis.core.conditional_time_reduction_reference.ReferenceConditionalTimeReduction`	class
`chronaxis.core.conditional_time_reduction_reference.ReferenceConditionalTimeReduction.__init__`	function
`chronaxis.core.conditional_time_reduction_reference.ReferenceConditionalTimeReduction.selected_weight_seconds`	function
`chronaxis.core.conditional_time_reduction_reference.ReferenceConditionalTimeReduction.selected_duration_ns`	function
`chronaxis.core.conditional_time_reduction_reference.ReferenceConditionalTimeReduction.value_valid_duration_ns`	function
`chronaxis.core.conditional_time_reduction_reference.ReferenceConditionalTimeReduction.push`	function
`chronaxis.core.conditional_time_reduction_reference.ReferenceConditionalTimeReduction.finish`	function
`chronaxis.core.counts_v4.classify_count`	function
`chronaxis.core.declarations.DeclaredSource`	class
`chronaxis.core.declarations.DeclaredSource.__post_init__`	function
`chronaxis.core.declarations.DeclarationBindings`	class
`chronaxis.core.declarations.DeclarationBindings.__post_init__`	function
`chronaxis.core.declarations.DeclarationBindings.resolve`	function
`chronaxis.core.declarations.DeclarationBindings.require_synchronized`	function
`chronaxis.core.decoded_binding._require_sha256`	function
`chronaxis.core.decoded_binding.DecodedSourceEvidence`	class
`chronaxis.core.decoded_binding.DecodedSourceEvidence.__post_init__`	function
`chronaxis.core.decoded_binding.DecodedBindings`	class
`chronaxis.core.decoded_binding.DecodedBindings.__post_init__`	function
`chronaxis.core.decoded_binding.DecodedBindings.extensions`	function
`chronaxis.core.decoded_binding.DecodedBindings.lookups`	function
`chronaxis.core.decoded_binding.DecodedBindings.signals`	function
`chronaxis.core.decoded_binding.DecodedBindings.projected_signals`	function
`chronaxis.core.decoded_binding.DecodedBindings.derived_names`	function
`chronaxis.core.decoded_binding.DecodedBindings.resolve`	function
`chronaxis.core.decoded_binding.DecodedBindings.require_synchronized`	function
`chronaxis.core.enum_codes.validate_code_dtype`	function
`chronaxis.core.enum_codes.compile_enum_code`	function
`chronaxis.core.enum_codes.code_dependencies`	function
`chronaxis.core.enum_codes.original_code`	function
`chronaxis.core.enum_codes.code_column`	function
`chronaxis.core.enum_codes.memory_histories`	function
`chronaxis.core.enum_codes.aligned_scalar`	function
`chronaxis.core.enum_codes.expire_value`	function
`chronaxis.core.enum_codes.aligned_column`	function
`chronaxis.core.enum_codes.history_code`	function
`chronaxis.core.enum_codes.historical_column`	function
`chronaxis.core.enum_codes.enum_code_reference`	function
`chronaxis.core.enum_codes.enum_code_numpy`	function
`chronaxis.core.export_interpolation.linear_reference`	function
`chronaxis.core.export_interpolation.linear_numpy`	function
`chronaxis.core.expression.DerivedDefinition`	class
`chronaxis.core.expression.DerivedDefinition.__post_init__`	function
`chronaxis.core.expression.ExprNode`	class
`chronaxis.core.expression.CompiledExpression`	class
`chronaxis.core.expression.StaticExpression`	class
`chronaxis.core.expression.contains_host_call`	function
`chronaxis.core.expression._node`	function
`chronaxis.core.expression._SyntaxCompiler`	class
`chronaxis.core.expression._SyntaxCompiler.__init__`	function
`chronaxis.core.expression._SyntaxCompiler._error`	function
`chronaxis.core.expression._SyntaxCompiler.parse`	function
`chronaxis.core.expression._SyntaxCompiler._final_unit`	function
`chronaxis.core.expression._SyntaxCompiler._name`	function
`chronaxis.core.expression._SyntaxCompiler._context`	function
`chronaxis.core.expression._SyntaxCompiler._units`	function
`chronaxis.core.expression._SyntaxCompiler._binary`	function
`chronaxis.core.expression._SyntaxCompiler.visit`	function
`chronaxis.core.expression.compile_expression`	function
`chronaxis.core.expression.validate_expression`	function
`chronaxis.core.expression._create_compiler`	function
`chronaxis.core.expression.expression_identity`	function
`chronaxis.core.expression_integer_numpy.integer_numpy`	function
`chronaxis.core.expression_integer_reference.integer_reference`	function
`chronaxis.core.expression_integer_v4._require_word`	function
`chronaxis.core.expression_integer_v4._bit_parameter`	function
`chronaxis.core.expression_integer_v4.compile_integer`	function
`chronaxis.core.expression_math_numpy.math_numpy`	function
`chronaxis.core.expression_math_reference.math_reference`	function
`chronaxis.core.expression_math_v4._common_unit`	function
`chronaxis.core.expression_math_v4._common_dtype`	function
`chronaxis.core.expression_math_v4.check_integer_leaves`	function
`chronaxis.core.expression_math_v4.compile_math`	function
`chronaxis.core.expression_numpy.ArrayEvaluation`	class
`chronaxis.core.expression_numpy.ArrayEvaluation.__post_init__`	function
`chronaxis.core.expression_numpy._logic`	function
`chronaxis.core.expression_numpy._constant`	function
`chronaxis.core.expression_numpy._literal_compare`	function
`chronaxis.core.expression_numpy._where`	function
`chronaxis.core.expression_numpy._evaluate`	function
`chronaxis.core.expression_numpy.evaluate_numpy`	function
`chronaxis.core.expression_numpy.evaluate_memory_numpy`	function
`chronaxis.core.expression_point._column`	function
`chronaxis.core.expression_point._scalar`	function
`chronaxis.core.expression_point.PointProgram`	class
`chronaxis.core.expression_point.PointProgram.__init__`	function
`chronaxis.core.expression_point.PointProgram.used_names`	function
`chronaxis.core.expression_point.PointProgram.evaluate`	function
`chronaxis.core.expression_point.PointProgram._evaluate`	function
`chronaxis.core.expression_point.PointProgram.updates`	function
`chronaxis.core.expression_point.PointProgram.updates.changed`	function
`chronaxis.core.expression_point.PointProgram.active`	function
`chronaxis.core.expression_reference.Evaluation`	class
`chronaxis.core.expression_reference.require_context`	function
`chronaxis.core.expression_reference._logic`	function
`chronaxis.core.expression_reference._evaluate`	function
`chronaxis.core.expression_reference.evaluate_reference`	function
`chronaxis.core.expression_reference.evaluate_memory_reference`	function
`chronaxis.core.expression_v4.numeric_coefficient`	function
`chronaxis.core.expression_v4.UnitCompiler`	class
`chronaxis.core.expression_v4.UnitCompiler.__init__`	function
`chronaxis.core.expression_v4.UnitCompiler._known_node`	function
`chronaxis.core.expression_v4.UnitCompiler._name`	function
`chronaxis.core.expression_v4.UnitCompiler._convert`	function
`chronaxis.core.expression_v4.UnitCompiler._canonical`	function
`chronaxis.core.expression_v4.UnitCompiler._final_unit`	function
`chronaxis.core.expression_v4.UnitCompiler._context`	function
`chronaxis.core.expression_v4.UnitCompiler._units`	function
`chronaxis.core.expression_v4.UnitCompiler._binary`	function
`chronaxis.core.expression_v4.UnitCompiler._where`	function
`chronaxis.core.expression_v4.UnitCompiler.visit`	function
`chronaxis.core.extension_points.compile_host_function`	function
`chronaxis.core.function_contracts.BuiltinFunctionContract`	class
`chronaxis.core.function_contracts._catalog`	function
`chronaxis.core.function_contracts._catalog.add`	function
`chronaxis.core.function_contracts.builtin_function_specs`	function
`chronaxis.core.integral_sum.IntegralStateLimitError`	class
`chronaxis.core.integral_sum.require_partial_limit`	function
`chronaxis.core.integral_sum.require_sum_finish`	function
`chronaxis.core.integral_sum.IntegralSumResult`	class
`chronaxis.core.integral_sum.IntegralSumResult.__post_init__`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum`	class
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum.__init__`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum.valid_term_count`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum.calculation_failed`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum.partial_count`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum.push`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum.push_values`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum._advance`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum.finish`	function
`chronaxis.core.integral_sum_numpy.NumpyIntegralSum._rounded`	function
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum`	class
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum.__init__`	function
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum.valid_term_count`	function
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum.calculation_failed`	function
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum.partial_count`	function
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum.push`	function
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum.push_values`	function
`chronaxis.core.integral_sum_reference.ReferenceIntegralSum.finish`	function
`chronaxis.core.integral_terms.IntegralFacts`	class
`chronaxis.core.integral_terms.IntegralFacts.__post_init__`	function
`chronaxis.core.integral_terms.ReferenceIntegralTerms`	class
`chronaxis.core.integral_terms.ReferenceIntegralTerms.__post_init__`	function
`chronaxis.core.integral_terms.require_valid_until`	function
`chronaxis.core.integral_terms.require_integral_terms`	function
`chronaxis.core.integral_terms_numpy.NumpyIntegralTerms`	class
`chronaxis.core.integral_terms_numpy.NumpyIntegralTerms.__post_init__`	function
`chronaxis.core.integral_terms_numpy.compute_integral_terms_numpy`	function
`chronaxis.core.integral_terms_reference.compute_integral_terms_reference`	function
`chronaxis.core.lookup._exact_f64`	function
`chronaxis.core.lookup.LookupTablePlan`	class
`chronaxis.core.lookup.LookupTablePlan.__post_init__`	function
`chronaxis.core.lookup.LookupTablePlan.prepare`	function
`chronaxis.core.lookup.PreparedLookup`	class
`chronaxis.core.lookup.PreparedLookup.packed`	function
`chronaxis.core.lookup.PreparedLookup.axis_at`	function
`chronaxis.core.lookup.PreparedLookup.value_at`	function
`chronaxis.core.lookup.pack_requested_lookups`	function
`chronaxis.core.lookup.pack_requested_lookups.visit`	function
`chronaxis.core.lookup.validate_lookups`	function
`chronaxis.core.lookup_compiler.compile_lookup`	function
`chronaxis.core.lookup_numpy.lookup_numpy`	function
`chronaxis.core.lookup_reference.lookup_reference`	function
`chronaxis.core.mean_weights_numpy.normalized_mean_terms`	function
`chronaxis.core.mean_weights_reference.normalized_mean_terms`	function
`chronaxis.core.message_binding._hash_parts`	function
`chronaxis.core.message_binding.ExpressionParameter`	class
`chronaxis.core.message_binding.ExpressionParameter.__post_init__`	function
`chronaxis.core.message_binding.ExpressionParameter.dtype`	function
`chronaxis.core.message_binding.MessageDeclarations`	class
`chronaxis.core.message_binding.MessageDeclarations.__post_init__`	function
`chronaxis.core.message_binding.MessageDeclarations.extensions`	function
`chronaxis.core.message_binding.MessageDeclarations.lookups`	function
`chronaxis.core.message_binding.MessageDeclarations.signals`	function
`chronaxis.core.message_binding.MessageDeclarations.resolve`	function
`chronaxis.core.message_binding.MessageDeclarations.require_synchronized`	function
`chronaxis.core.message_binding.MessageSourceEvidence`	class
`chronaxis.core.message_binding.MessageSourceEvidence.__post_init__`	function
`chronaxis.core.message_binding.MessageBindings`	class
`chronaxis.core.message_binding.MessageBindings.__post_init__`	function
`chronaxis.core.message_binding.MessageBindings.extensions`	function
`chronaxis.core.message_binding.MessageBindings.lookups`	function
`chronaxis.core.message_binding.MessageBindings.signals`	function
`chronaxis.core.message_binding.MessageBindings.parameters`	function
`chronaxis.core.message_binding.MessageBindings.derived_names`	function
`chronaxis.core.message_binding.MessageBindings.resolve`	function
`chronaxis.core.message_binding.MessageBindings.require_synchronized`	function
`chronaxis.core.models.Interval`	class
`chronaxis.core.models.Interval.__post_init__`	function
`chronaxis.core.models.Interval.duration_ns`	function
`chronaxis.core.models.Interval.contains`	function
`chronaxis.core.models.TimebaseSpec`	class
`chronaxis.core.models.TimebaseSpec.__post_init__`	function
`chronaxis.core.models.MemoryRow`	class
`chronaxis.core.models.MemoryRow.__post_init__`	function
`chronaxis.core.models.SourceSpec`	class
`chronaxis.core.models.SourceSpec.__post_init__`	function
`chronaxis.core.models.SourceRef`	class
`chronaxis.core.models.SourceRef.__post_init__`	function
`chronaxis.core.models.SignalSample`	class
`chronaxis.core.models.SignalSample.__post_init__`	function
`chronaxis.core.models.SignalSample.validate_dtype`	function
`chronaxis.core.models.SessionSpec`	class
`chronaxis.core.models.SessionSpec.__post_init__`	function
`chronaxis.core.models.SessionSpec.validate_sample`	function
`chronaxis.core.models.DatasetSpec`	class
`chronaxis.core.models.DatasetSpec.__post_init__`	function
`chronaxis.core.moments.moment_ddof`	function
`chronaxis.core.moments.moment_source_unit`	function
`chronaxis.core.moments.compute_moment_series`	function
`chronaxis.core.moments_numpy.NumpyMoments`	class
`chronaxis.core.moments_numpy.NumpyMoments.__init__`	function
`chronaxis.core.moments_numpy.NumpyMoments.push`	function
`chronaxis.core.moments_numpy.NumpyMoments.finish`	function
`chronaxis.core.moments_reference.ReferenceMoments`	class
`chronaxis.core.moments_reference.ReferenceMoments.__init__`	function
`chronaxis.core.moments_reference.ReferenceMoments.push`	function
`chronaxis.core.moments_reference.ReferenceMoments.finish`	function
`chronaxis.core.normalize_numpy._affine_integer`	function
`chronaxis.core.normalize_numpy._float_limit`	function
`chronaxis.core.normalize_numpy.normalize_numpy`	function
`chronaxis.core.normalize_numpy.memory_series_numpy`	function
`chronaxis.core.numeric.result_dtype`	function
`chronaxis.core.numeric._exact_float`	function
`chronaxis.core.numeric.to_float_reference`	function
`chronaxis.core.numeric.binary_reference`	function
`chronaxis.core.numeric.unary_reference`	function
`chronaxis.core.numeric.normalize_reference`	function
`chronaxis.core.numeric.memory_series_reference`	function
`chronaxis.core.numeric_numpy._readonly`	function
`chronaxis.core.numeric_numpy.NumericArray`	class
`chronaxis.core.numeric_numpy.NumericArray.take`	function
`chronaxis.core.numeric_numpy.NumericArray.__post_init__`	function
`chronaxis.core.numeric_numpy._output`	function
`chronaxis.core.numeric_numpy._magnitude`	function
`chronaxis.core.numeric_numpy._from_magnitude`	function
`chronaxis.core.numeric_numpy.to_float_numpy`	function
`chronaxis.core.numeric_numpy._integer_compare`	function
`chronaxis.core.numeric_numpy._integer_arithmetic`	function
`chronaxis.core.numeric_numpy.binary_numpy`	function
`chronaxis.core.numeric_numpy.unary_numpy`	function
`chronaxis.core.numeric_point.failed`	function
`chronaxis.core.numeric_point.exact_float`	function
`chronaxis.core.numeric_point.to_float_point`	function
`chronaxis.core.numeric_point.checked_result`	function
`chronaxis.core.numeric_point.binary_point`	function
`chronaxis.core.numeric_point.unary_point`	function
`chronaxis.core.numeric_point.affine_point`	function
`chronaxis.core.numeric_point.logic_point`	function
`chronaxis.core.numeric_point.math_point`	function
`chronaxis.core.numeric_point.integer_point`	function
`chronaxis.core.numeric_point.lookup_point`	function
`chronaxis.core.quantile_numpy.ordered_numpy`	function
`chronaxis.core.quantile_reference.ordered_reference`	function
`chronaxis.core.quantiles.quantile_probability`	function
`chronaxis.core.quantiles.ExactQuantileBuffer`	class
`chronaxis.core.quantiles.ExactQuantileBuffer.__init__`	function
`chronaxis.core.quantiles.ExactQuantileBuffer._reserve`	function
`chronaxis.core.quantiles.ExactQuantileBuffer._append_memory_bytes`	function
`chronaxis.core.quantiles.ExactQuantileBuffer.append`	function
`chronaxis.core.quantiles.ExactQuantileBuffer.finish`	function
`chronaxis.core.quantiles.ExactQuantileBuffer.close`	function
`chronaxis.core.quantiles.compute_quantile_series`	function
`chronaxis.core.rate_numpy._relative_column`	function
`chronaxis.core.rate_numpy._restore`	function
`chronaxis.core.rate_numpy.difference_numpy`	function
`chronaxis.core.rate_numpy.fit_numpy`	function
`chronaxis.core.rate_reference._result`	function
`chronaxis.core.rate_reference.difference_reference`	function
`chronaxis.core.rate_reference.fit_reference`	function
`chronaxis.core.rate_transforms.rate_unit`	function
`chronaxis.core.rate_transforms._quality`	function
`chronaxis.core.rate_transforms._position`	function
`chronaxis.core.rate_transforms.rate_difference`	function
`chronaxis.core.rate_transforms.rate_fit`	function
`chronaxis.core.record_intervals.require_record_step`	function
`chronaxis.core.record_intervals.clipped_record_seconds`	function
`chronaxis.core.record_intervals.RecordIntervals`	class
`chronaxis.core.record_intervals.RecordIntervals.__init__`	function
`chronaxis.core.record_intervals.RecordIntervals.advance`	function
`chronaxis.core.record_intervals.RecordIntervals.advance_seconds`	function
`chronaxis.core.rolling_values.rolling_value`	function
`chronaxis.core.sample_reduction._unknown_duration`	function
`chronaxis.core.sample_reduction.SampleCalculationFacts`	class
`chronaxis.core.sample_reduction.SampleCalculationFacts.__post_init__`	function
`chronaxis.core.sample_reduction.SampleReductionResult`	class
`chronaxis.core.sample_reduction.SampleReductionResult.__post_init__`	function
`chronaxis.core.sample_reduction.require_sample_config`	function
`chronaxis.core.sample_reduction.require_sample_series`	function
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction`	class
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction.__init__`	function
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction.selected_duration_ns`	function
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction.value_valid_duration_ns`	function
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction.valid_sample_count`	function
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction.push`	function
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction.finish`	function
`chronaxis.core.sample_reduction_numpy.NumpySampleReduction.close`	function
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction`	class
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction.__init__`	function
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction.selected_duration_ns`	function
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction.value_valid_duration_ns`	function
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction.valid_sample_count`	function
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction.push`	function
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction.finish`	function
`chronaxis.core.sample_reduction_reference.ReferenceSampleReduction.close`	function
`chronaxis.core.scalar.ScalarValue`	class
`chronaxis.core.scalar.ScalarValue.__post_init__`	function
`chronaxis.core.scalar._scalar_from_validated_fields`	function
`chronaxis.core.selection.SelectionRow`	class
`chronaxis.core.selection.SelectionRow.__post_init__`	function
`chronaxis.core.selection.require_selection`	function
`chronaxis.core.selection.partial_selection`	function
`chronaxis.core.sequence.SequenceRule`	class
`chronaxis.core.sequence.SequenceRule.__post_init__`	function
`chronaxis.core.sequence.SequenceRule.check_event`	function
`chronaxis.core.sequence.SequenceTick`	class
`chronaxis.core.sequence.SequenceTick.__post_init__`	function
`chronaxis.core.sequence.SequenceResult`	class
`chronaxis.core.sequence.SequenceResult.__post_init__`	function
`chronaxis.core.sequence_reference.SequenceDetector`	class
`chronaxis.core.sequence_reference.SequenceDetector.__init__`	function
`chronaxis.core.sequence_reference.SequenceDetector.pending_count`	function
`chronaxis.core.sequence_reference.SequenceDetector._note`	function
`chronaxis.core.sequence_reference.SequenceDetector._advance`	function
`chronaxis.core.sequence_reference.SequenceDetector._result`	function
`chronaxis.core.sequence_reference.SequenceDetector._consume`	function
`chronaxis.core.sequence_reference.SequenceDetector.push`	function
`chronaxis.core.sequence_reference.SequenceDetector.finish`	function
`chronaxis.core.sequence_reference.pair_sequence`	function
`chronaxis.core.stability.StabilitySpec`	class
`chronaxis.core.stability.StabilitySpec.__post_init__`	function
`chronaxis.core.stability.invert_tick`	function
`chronaxis.core.stability.StabilityDetector`	class
`chronaxis.core.stability.StabilityDetector.__init__`	function
`chronaxis.core.stability.StabilityDetector._push_core`	function
`chronaxis.core.stability.StabilityDetector.duration_counts`	function
`chronaxis.core.stability.StabilityDetector.next_deadline_ns`	function
`chronaxis.core.stability.StabilityDetector._target`	function
`chronaxis.core.stability.StabilityDetector._settle`	function
`chronaxis.core.stability.StabilityDetector._point`	function
`chronaxis.core.stability.StabilityDetector._continuous`	function
`chronaxis.core.stability.StabilityDetector.push`	function
`chronaxis.core.stability.StabilityDetector.drain_events`	function
`chronaxis.core.stability.StabilityDetector.finish`	function
`chronaxis.core.start_end.StartEndSpec`	class
`chronaxis.core.start_end.StartEndSpec.__post_init__`	function
`chronaxis.core.start_end.StartEndDetector`	class
`chronaxis.core.start_end.StartEndDetector.__init__`	function
`chronaxis.core.start_end.StartEndDetector.next_deadline_ns`	function
`chronaxis.core.start_end.StartEndDetector._close`	function
`chronaxis.core.start_end.StartEndDetector._unknown_status`	function
`chronaxis.core.start_end.StartEndDetector._advance`	function
`chronaxis.core.start_end.StartEndDetector.push`	function
`chronaxis.core.start_end.StartEndDetector.drain_events`	function
`chronaxis.core.start_end.StartEndDetector.finish`	function
`chronaxis.core.state._collapse`	function
`chronaxis.core.state.SignalSeries`	class
`chronaxis.core.state.SignalSeries.__post_init__`	function
`chronaxis.core.state.StateValue`	class
`chronaxis.core.state.align_reference`	function
`chronaxis.core.state._require_series_group`	function
`chronaxis.core.state.common_timeline`	function
`chronaxis.core.state.TimeGroup`	class
`chronaxis.core.state.AtomicUpdateBuffer`	class
`chronaxis.core.state.AtomicUpdateBuffer.__init__`	function
`chronaxis.core.state.AtomicUpdateBuffer._commit`	function
`chronaxis.core.state.AtomicUpdateBuffer.push`	function
`chronaxis.core.state.AtomicUpdateBuffer.finish`	function
`chronaxis.core.state.iter_time_groups`	function
`chronaxis.core.state_numpy._require_axis`	function
`chronaxis.core.state_numpy._readonly`	function
`chronaxis.core.state_numpy.SignalArray`	class
`chronaxis.core.state_numpy.SignalArray.__post_init__`	function
`chronaxis.core.state_numpy.build_signal_array`	function
`chronaxis.core.state_numpy.AlignedArray`	class
`chronaxis.core.state_numpy.AlignedArray.__post_init__`	function
`chronaxis.core.state_numpy.align_numpy`	function
`chronaxis.core.temporal._require_truth`	function
`chronaxis.core.temporal.ConditionSpan`	class
`chronaxis.core.temporal.ConditionSpan.__post_init__`	function
`chronaxis.core.temporal.ConditionTick`	class
`chronaxis.core.temporal.ConditionTick.__post_init__`	function
`chronaxis.core.temporal.TemporalRule`	class
`chronaxis.core.temporal.TemporalRule.__post_init__`	function
`chronaxis.core.temporal.TemporalRule.qualifying_duration_ns`	function
`chronaxis.core.temporal.Event`	class
`chronaxis.core.temporal.Event.__post_init__`	function
`chronaxis.core.temporal.make_event`	function
`chronaxis.core.temporal.ConditionTimeline`	class
`chronaxis.core.temporal.ConditionTimeline.__post_init__`	function
`chronaxis.core.temporal.timeline_from_spans`	function
`chronaxis.core.temporal_clock.require_clock_advances`	function
`chronaxis.core.temporal_memory_numpy._evidence_numpy`	function
`chronaxis.core.temporal_memory_numpy.build_timeline_numpy`	function
`chronaxis.core.temporal_memory_numpy.detect_memory_numpy`	function
`chronaxis.core.temporal_memory_reference.require_memory_rule`	function
`chronaxis.core.temporal_memory_reference._evidence`	function
`chronaxis.core.temporal_memory_reference.build_timeline_reference`	function
`chronaxis.core.temporal_memory_reference.detect_memory_reference`	function
`chronaxis.core.temporal_numpy.NumpyTemporalDetector`	class
`chronaxis.core.temporal_numpy.NumpyTemporalDetector.__init__`	function
`chronaxis.core.temporal_numpy.NumpyTemporalDetector.next_deadline_ns`	function
`chronaxis.core.temporal_numpy.NumpyTemporalDetector._duration`	function
`chronaxis.core.temporal_numpy.NumpyTemporalDetector._edges`	function
`chronaxis.core.temporal_numpy.NumpyTemporalDetector.push`	function
`chronaxis.core.temporal_numpy.NumpyTemporalDetector.drain_events`	function
`chronaxis.core.temporal_numpy.NumpyTemporalDetector.finish`	function
`chronaxis.core.temporal_numpy.detect_numpy`	function
`chronaxis.core.temporal_reference.require_batch`	function
`chronaxis.core.temporal_reference.require_detector`	function
`chronaxis.core.temporal_reference.ReferenceTemporalDetector`	class
`chronaxis.core.temporal_reference.ReferenceTemporalDetector.__init__`	function
`chronaxis.core.temporal_reference.ReferenceTemporalDetector.next_deadline_ns`	function
`chronaxis.core.temporal_reference.ReferenceTemporalDetector._consume`	function
`chronaxis.core.temporal_reference.ReferenceTemporalDetector.push`	function
`chronaxis.core.temporal_reference.ReferenceTemporalDetector.drain_events`	function
`chronaxis.core.temporal_reference.ReferenceTemporalDetector.finish`	function
`chronaxis.core.temporal_reference.detect_reference`	function
`chronaxis.core.time_reduction.TimeCalculationFacts`	class
`chronaxis.core.time_reduction.TimeCalculationFacts.__post_init__`	function
`chronaxis.core.time_reduction.TimeReductionResult`	class
`chronaxis.core.time_reduction.TimeReductionResult.__post_init__`	function
`chronaxis.core.time_reduction.MeanTimeBlock`	class
`chronaxis.core.time_reduction.require_time_config`	function
`chronaxis.core.time_reduction.require_time_series`	function
`chronaxis.core.time_reduction.require_time_options`	function
`chronaxis.core.time_reduction_numpy.NumpyTimeReduction`	class
`chronaxis.core.time_reduction_numpy.NumpyTimeReduction.__init__`	function
`chronaxis.core.time_reduction_numpy.NumpyTimeReduction.selected_weight_seconds`	function
`chronaxis.core.time_reduction_numpy.NumpyTimeReduction.selected_duration_ns`	function
`chronaxis.core.time_reduction_numpy.NumpyTimeReduction.value_valid_duration_ns`	function
`chronaxis.core.time_reduction_numpy.NumpyTimeReduction.push`	function
`chronaxis.core.time_reduction_numpy.NumpyTimeReduction.finish`	function
`chronaxis.core.time_reduction_reference.ReferenceTimeReduction`	class
`chronaxis.core.time_reduction_reference.ReferenceTimeReduction.__init__`	function
`chronaxis.core.time_reduction_reference.ReferenceTimeReduction.selected_weight_seconds`	function
`chronaxis.core.time_reduction_reference.ReferenceTimeReduction.selected_duration_ns`	function
`chronaxis.core.time_reduction_reference.ReferenceTimeReduction.value_valid_duration_ns`	function
`chronaxis.core.time_reduction_reference.ReferenceTimeReduction.push`	function
`chronaxis.core.time_reduction_reference.ReferenceTimeReduction.finish`	function
`chronaxis.core.types.Truth`	class
`chronaxis.core.types.Truth.__bool__`	function
`chronaxis.core.types.QualityFlag`	class
`chronaxis.core.types.QualityFlag._missing_`	function
`chronaxis.core.types.SignalDType`	class
`chronaxis.core.types.TimeType`	class
`chronaxis.core.types.SourceType`	class
`chronaxis.core.unit_conversion.require_config_version`	function
`chronaxis.core.unit_conversion.binding_version`	function
`chronaxis.core.unit_conversion.affine_conversion`	function
`chronaxis.core.unit_conversion.validate_conversion_v4`	function
`chronaxis.core.unit_conversion.converted_dtype`	function
`chronaxis.core.unit_registry._indices`	function
`chronaxis.core.unit_registry._dimensions`	function
`chronaxis.core.unit_registry.Scale`	class
`chronaxis.core.unit_registry.Scale.__post_init__`	function
`chronaxis.core.unit_registry.Scale.to_float`	function
`chronaxis.core.unit_registry.Scale.multiply`	function
`chronaxis.core.unit_registry.Scale.divide`	function
`chronaxis.core.unit_registry.Scale.power`	function
`chronaxis.core.unit_registry.Scale.square_root`	function
`chronaxis.core.unit_registry.Unit`	class
`chronaxis.core.unit_registry.Unit.__post_init__`	function
`chronaxis.core.unit_registry._temperature_role`	function
`chronaxis.core.unit_registry._make`	function
`chronaxis.core.unit_registry._require_unit`	function
`chronaxis.core.unit_registry._require_multiplicative`	function
`chronaxis.core.unit_registry.multiply`	function
`chronaxis.core.unit_registry.divide`	function
`chronaxis.core.unit_registry._power`	function
`chronaxis.core.unit_registry.square`	function
`chronaxis.core.unit_registry.square_root`	function
`chronaxis.core.unit_registry.conversion`	function
`chronaxis.core.unit_registry._kind_symbol`	function
`chronaxis.core.unit_registry.canonical_unit`	function
`chronaxis.core.unit_registry.output_label`	function
`chronaxis.core.unit_registry._build_atoms`	function
`chronaxis.core.unit_registry._build_preferred`	function
`chronaxis.core.unit_registry._Parser`	class
`chronaxis.core.unit_registry._Parser.__init__`	function
`chronaxis.core.unit_registry._Parser.peek`	function
`chronaxis.core.unit_registry._Parser.factor`	function
`chronaxis.core.unit_registry._Parser.expression`	function
`chronaxis.core.unit_registry.resolve_unit`	function
`chronaxis.core.units.require_number`	function
`chronaxis.core.validation.require_text`	function
`chronaxis.core.validation.require_identifier`	function
`chronaxis.core.validation.require_sequence`	function
`chronaxis.core.validation.require_scalar`	function
`chronaxis.core.where_updates.contains_where`	function
`chronaxis.core.where_updates.reference_updates`	function
`chronaxis.core.where_updates.reference_updates.visit`	function
`chronaxis.core.where_updates.numpy_updates`	function
`chronaxis.core.where_updates.numpy_updates.condition_at`	function
`chronaxis.core.where_updates.numpy_updates.visit`	function
`chronaxis.core.where_updates.reference_active`	function
`chronaxis.core.where_updates.numpy_active`	function
`chronaxis.core.window_delta.WindowDeltaSpec`	class
`chronaxis.core.window_delta.WindowDeltaSpec.__post_init__`	function
`chronaxis.core.window_delta.DeltaSpan`	class
`chronaxis.core.window_delta.DeltaSpan.__post_init__`	function
`chronaxis.core.window_delta.WindowDeltaResult`	class
`chronaxis.core.window_delta.validate_delta_input`	function
`chronaxis.core.window_delta_numpy.window_delta_numpy`	function
`chronaxis.core.window_delta_reference.window_delta_reference`	function
`chronaxis.core.windows.WindowSpec`	class
`chronaxis.core.windows.WindowSpec.__post_init__`	function
`chronaxis.core.windows.Segment`	class
`chronaxis.core.windows.Segment.__post_init__`	function
`chronaxis.core.windows.require_windows`	function
`chronaxis.core.windows.CompactSegment`	class
`chronaxis.core.windows.require_resolved_windows`	function
`chronaxis.core.windows.make_segment`	function
`chronaxis.core.windows_numpy.build_segments_numpy`	function
`chronaxis.core.windows_reference.build_segments_reference`	function
`chronaxis.dbc_loading.load_dbc_file`	function
`chronaxis.execution.batch_signal_groups.BatchSignalGroups`	class
`chronaxis.execution.batch_signal_groups.BatchSignalGroups.__init__`	function
`chronaxis.execution.batch_signal_groups.BatchSignalGroups.consume`	function
`chronaxis.execution.batch_signal_groups.BatchSignalGroups._flush`	function
`chronaxis.execution.batch_signal_groups.BatchSignalGroups.finish`	function
`chronaxis.execution.batch_signal_groups.BatchSignalGroups.close`	function
`chronaxis.execution.calculation_values.scalar_from_column`	function
`chronaxis.execution.calculation_values._scalar_from_validated_column`	function
`chronaxis.execution.calculation_values._extract_scalar`	function
`chronaxis.execution.calculation_values.direction_bucket_state`	function
`chronaxis.execution.calculation_values.direction_skip_reason`	function
`chronaxis.execution.can_batch_reader._float_seconds_ns`	function
`chronaxis.execution.can_batch_reader._dense_time_tail`	function
`chronaxis.execution.can_batch_reader._retained_time_indices`	function
`chronaxis.execution.can_batch_reader._sparse_batch_times`	function
`chronaxis.execution.can_batch_reader.CANBatchObservationRead`	class
`chronaxis.execution.can_batch_reader.CANBatchObservationRead.__init__`	function
`chronaxis.execution.can_batch_reader.CANBatchObservationRead._load_batch`	function
`chronaxis.execution.can_batch_reader.CANBatchObservationRead._advance_record`	function
`chronaxis.execution.can_batch_reader.CANBatchObservationRead._packed_batch`	function
`chronaxis.execution.can_batch_reader.CANBatchObservationRead.__next__`	function
`chronaxis.execution.can_batch_reader.CANBatchObservationRead.close`	function
`chronaxis.execution.can_block_codec.CANBlockError`	class
`chronaxis.execution.can_block_codec._Writer`	class
`chronaxis.execution.can_block_codec._Writer.__init__`	function
`chronaxis.execution.can_block_codec._Writer.add`	function
`chronaxis.execution.can_block_codec._Writer.byte`	function
`chronaxis.execution.can_block_codec._Writer.uint`	function
`chronaxis.execution.can_block_codec._Writer.text`	function
`chronaxis.execution.can_block_codec._Writer.scalar`	function
`chronaxis.execution.can_block_codec._Writer.optional_text`	function
`chronaxis.execution.can_block_codec._Writer.pairs`	function
`chronaxis.execution.can_block_codec._Writer.decimal`	function
`chronaxis.execution.can_block_codec._Writer.finish`	function
`chronaxis.execution.can_block_codec._Reader`	class
`chronaxis.execution.can_block_codec._Reader.__init__`	function
`chronaxis.execution.can_block_codec._Reader.close`	function
`chronaxis.execution.can_block_codec._Reader.charge`	function
`chronaxis.execution.can_block_codec._Reader.remaining`	function
`chronaxis.execution.can_block_codec._Reader.take`	function
`chronaxis.execution.can_block_codec._Reader.byte`	function
`chronaxis.execution.can_block_codec._Reader.uint`	function
`chronaxis.execution.can_block_codec._Reader.boolean`	function
`chronaxis.execution.can_block_codec._Reader.text`	function
`chronaxis.execution.can_block_codec._Reader.scalar`	function
`chronaxis.execution.can_block_codec._Reader.nonnegative`	function
`chronaxis.execution.can_block_codec._Reader.optional_text`	function
`chronaxis.execution.can_block_codec._Reader.pairs`	function
`chronaxis.execution.can_block_codec._Reader.decimal`	function
`chronaxis.execution.can_block_codec._write_frame`	function
`chronaxis.execution.can_block_codec._read_frame`	function
`chronaxis.execution.can_block_codec.encode_block`	function
`chronaxis.execution.can_block_codec.decode_block`	function
`chronaxis.execution.can_block_codec._metadata`	function
`chronaxis.execution.can_block_codec.encode_metadata`	function
`chronaxis.execution.can_block_codec.decode_metadata`	function
`chronaxis.execution.can_reader.CANObservation`	class
`chronaxis.execution.can_reader.CANObservation.__post_init__`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter`	class
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.__init__`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.capture_message_updates`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.batch_read`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.retain_raw_frames`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.message_frame_ids`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.decode_scope`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.decode_frame_ids`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter._ensure_open`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.describe`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.iter_batches`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.iter_batches_with_observation`	function
`chronaxis.execution.can_reader.BudgetedLegacyCANSourceAdapter.close`	function
`chronaxis.execution.can_reader.CANObservationRead`	class
`chronaxis.execution.can_reader.CANObservationRead.__init__`	function
`chronaxis.execution.can_reader.CANObservationRead.capture_message_updates`	function
`chronaxis.execution.can_reader.CANObservationRead.identity`	function
`chronaxis.execution.can_reader.CANObservationRead.request`	function
`chronaxis.execution.can_reader.CANObservationRead.closed`	function
`chronaxis.execution.can_reader.CANObservationRead.failed`	function
`chronaxis.execution.can_reader.CANObservationRead.finished`	function
`chronaxis.execution.can_reader.CANObservationRead.exhausted`	function
`chronaxis.execution.can_reader.CANObservationRead._require_open`	function
`chronaxis.execution.can_reader.CANObservationRead.observation`	function
`chronaxis.execution.can_reader.CANObservationRead.observed_bounds`	function
`chronaxis.execution.can_reader.CANObservationRead.input_fingerprints`	function
`chronaxis.execution.can_reader.CANObservationRead._observe_validated_packet`	function
`chronaxis.execution.can_reader.CANObservationRead.runtime_metadata`	function
`chronaxis.execution.can_reader.CANObservationRead.prepare_metadata`	function
`chronaxis.execution.can_reader.CANObservationRead._adopt`	function
`chronaxis.execution.can_reader.CANObservationRead._fail`	function
`chronaxis.execution.can_reader.CANObservationRead._start`	function
`chronaxis.execution.can_reader.CANObservationRead._accept`	function
`chronaxis.execution.can_reader.CANObservationRead._release_current`	function
`chronaxis.execution.can_reader.CANObservationRead._new_record`	function
`chronaxis.execution.can_reader.CANObservationRead._deliver_message`	function
`chronaxis.execution.can_reader.CANObservationRead._batch`	function
`chronaxis.execution.can_reader.CANObservationRead.__iter__`	function
`chronaxis.execution.can_reader.CANObservationRead.__next__`	function
`chronaxis.execution.can_reader.CANObservationRead._close_child`	function
`chronaxis.execution.can_reader.CANObservationRead._finish`	function
`chronaxis.execution.can_reader.CANObservationRead.take_raw_store`	function
`chronaxis.execution.can_reader.CANObservationRead.take_message_store`	function
`chronaxis.execution.can_reader.CANObservationRead.close`	function
`chronaxis.execution.csv_observation.CSVObservation`	class
`chronaxis.execution.csv_observation.CSVObservation.__post_init__`	function
`chronaxis.execution.csv_observation.CSVObservationRead`	class
`chronaxis.execution.csv_observation.CSVObservationRead.__init__`	function
`chronaxis.execution.csv_observation.CSVObservationRead.identity`	function
`chronaxis.execution.csv_observation.CSVObservationRead.closed`	function
`chronaxis.execution.csv_observation.CSVObservationRead.failed`	function
`chronaxis.execution.csv_observation.CSVObservationRead.exhausted`	function
`chronaxis.execution.csv_observation.CSVObservationRead.observation`	function
`chronaxis.execution.csv_observation.CSVObservationRead._read_resources`	function
`chronaxis.execution.csv_observation.CSVObservationRead._created_iterator`	function
`chronaxis.execution.csv_observation.CSVObservationRead._opened_handle`	function
`chronaxis.execution.csv_observation.CSVObservationRead._close_handle`	function
`chronaxis.execution.csv_observation.CSVObservationRead._close_resources`	function
`chronaxis.execution.csv_observation.CSVObservationRead._end_file`	function
`chronaxis.execution.csv_observation.CSVObservationRead._accept_candidate`	function
`chronaxis.execution.csv_observation.CSVObservationRead._adopt_cleanup`	function
`chronaxis.execution.csv_observation.CSVObservationRead.__iter__`	function
`chronaxis.execution.csv_observation.CSVObservationRead._ensure_active`	function
`chronaxis.execution.csv_observation.CSVObservationRead.__next__`	function
`chronaxis.execution.csv_observation.CSVObservationRead._close_request`	function
`chronaxis.execution.csv_observation.CSVObservationRead.close`	function
`chronaxis.execution.csv_observation._ObservationCSVResources`	class
`chronaxis.execution.csv_observation._ObservationCSVResources.__init__`	function
`chronaxis.execution.csv_observation._ObservationCSVResources._sync`	function
`chronaxis.execution.csv_observation._ObservationCSVResources._add`	function
`chronaxis.execution.csv_observation._ObservationCSVResources._release_amount`	function
`chronaxis.execution.csv_observation._ObservationCSVResources._release`	function
`chronaxis.execution.csv_observation._ObservationCSVResources._move`	function
`chronaxis.execution.csv_observation._ObservationCSVResources.lines`	function
`chronaxis.execution.csv_observation._ObservationCSVResources.records`	function
`chronaxis.execution.csv_observation._ObservationCSVResources.after_pack`	function
`chronaxis.execution.csv_observation._ObservationCSVResources.close`	function
`chronaxis.execution.csv_observation._ObservationPhysicalLines`	class
`chronaxis.execution.csv_observation._ObservationPhysicalLines.__next__`	function
`chronaxis.execution.csv_observation._ObservationCSVRecords`	class
`chronaxis.execution.csv_observation._ObservationCSVRecords.__next__`	function
`chronaxis.execution.csv_reader._expanded_integer_bytes`	function
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter`	class
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter.__init__`	function
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter.iter_batches`	function
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter.iter_batches_with_observation`	function
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter._ensure_open`	function
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter._read_resources`	function
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter._close_handle`	function
`chronaxis.execution.csv_reader.BudgetedSignalCSVSourceAdapter.close`	function
`chronaxis.execution.csv_reader._CSVRequest`	class
`chronaxis.execution.csv_reader._CSVRequest.__init__`	function
`chronaxis.execution.csv_reader._CSVRequest._adopt_cleanup`	function
`chronaxis.execution.csv_reader._CSVRequest._created_iterator`	function
`chronaxis.execution.csv_reader._CSVRequest._read_resources`	function
`chronaxis.execution.csv_reader._CSVRequest._opened_handle`	function
`chronaxis.execution.csv_reader._CSVRequest._close_handle`	function
`chronaxis.execution.csv_reader._CSVRequest._end_file`	function
`chronaxis.execution.csv_reader._CSVRequest._close_resources`	function
`chronaxis.execution.csv_reader._CSVRequest.__iter__`	function
`chronaxis.execution.csv_reader._CSVRequest.__next__`	function
`chronaxis.execution.csv_reader._CSVRequest.close`	function
`chronaxis.execution.csv_reader._CSVResources`	class
`chronaxis.execution.csv_reader._CSVResources.__init__`	function
`chronaxis.execution.csv_reader._CSVResources._sync`	function
`chronaxis.execution.csv_reader._CSVResources._add`	function
`chronaxis.execution.csv_reader._CSVResources._release_amount`	function
`chronaxis.execution.csv_reader._CSVResources._move`	function
`chronaxis.execution.csv_reader._CSVResources._release`	function
`chronaxis.execution.csv_reader._CSVResources.lines`	function
`chronaxis.execution.csv_reader._CSVResources.records`	function
`chronaxis.execution.csv_reader._CSVResources._sample_estimate`	function
`chronaxis.execution.csv_reader._CSVResources._pack_estimate`	function
`chronaxis.execution.csv_reader._CSVResources.should_flush`	function
`chronaxis.execution.csv_reader._CSVResources.before_sample`	function
`chronaxis.execution.csv_reader._CSVResources.before_pack`	function
`chronaxis.execution.csv_reader._CSVResources.after_pack`	function
`chronaxis.execution.csv_reader._CSVResources.clear_pending`	function
`chronaxis.execution.csv_reader._CSVResources.end_file`	function
`chronaxis.execution.csv_reader._CSVResources.close`	function
`chronaxis.execution.csv_reader._PhysicalLines`	class
`chronaxis.execution.csv_reader._PhysicalLines.__init__`	function
`chronaxis.execution.csv_reader._PhysicalLines.__iter__`	function
`chronaxis.execution.csv_reader._PhysicalLines._retained_line_bytes`	function
`chronaxis.execution.csv_reader._PhysicalLines.__next__`	function
`chronaxis.execution.csv_reader._CSVRecords`	class
`chronaxis.execution.csv_reader._CSVRecords.__init__`	function
`chronaxis.execution.csv_reader._CSVRecords.__iter__`	function
`chronaxis.execution.csv_reader._CSVRecords.__next__`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation`	class
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation.__init__`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation._require_open`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation._matches`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation.consume`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation.snapshot`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation.quality`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation.closed`	function
`chronaxis.execution.current_message_calculation.CurrentMessageCalculation.close`	function
`chronaxis.execution.driver_expression.DriverExpression`	class
`chronaxis.execution.driver_expression.DriverExpression.__init__`	function
`chronaxis.execution.driver_expression.DriverExpression._require_open`	function
`chronaxis.execution.driver_expression.DriverExpression._context_at`	function
`chronaxis.execution.driver_expression.DriverExpression._evaluate_values`	function
`chronaxis.execution.driver_expression.DriverExpression.actual_update_at`	function
`chronaxis.execution.driver_expression.DriverExpression.active_end_at`	function
`chronaxis.execution.driver_expression.DriverExpression.actual_unknown_at`	function
`chronaxis.execution.driver_expression.DriverExpression._point_evidence`	function
`chronaxis.execution.driver_expression.DriverExpression._output_deadline`	function
`chronaxis.execution.driver_expression.DriverExpression.evaluate`	function
`chronaxis.execution.driver_expression.DriverExpression.invalidated_at`	function
`chronaxis.execution.driver_expression.DriverExpression.evaluate_at`	function
`chronaxis.execution.driver_expression.DriverExpression.close`	function
`chronaxis.execution.frame_capture.FrameDBCContext`	class
`chronaxis.execution.frame_capture.FrameDBCContext.__init__`	function
`chronaxis.execution.frame_capture.FrameDBCContext._hash`	function
`chronaxis.execution.frame_capture.FrameDBCContext.require_open`	function
`chronaxis.execution.frame_capture.FrameDBCContext.pairs`	function
`chronaxis.execution.frame_capture.FrameDBCContext.observe`	function
`chronaxis.execution.frame_capture.FrameDBCContext.is_known_frame`	function
`chronaxis.execution.frame_capture.FrameDBCContext.close`	function
`chronaxis.execution.frame_capture.TextFrameStore`	class
`chronaxis.execution.frame_capture.TextFrameStore.__init__`	function
`chronaxis.execution.frame_capture.TextFrameStore.append`	function
`chronaxis.execution.frame_capture.TextFrameStore.seal`	function
`chronaxis.execution.frame_capture.TextFrameStore.iter_samples`	function
`chronaxis.execution.frame_capture.TextFrameStore.iter_frames`	function
`chronaxis.execution.frame_capture.TextFrameStore.close`	function
`chronaxis.execution.groups.DecodedTimeGroup`	class
`chronaxis.execution.groups.DecodedTimeGroup.__post_init__`	function
`chronaxis.execution.history._metadata_bytes`	function
`chronaxis.execution.history._metadata_cost`	function
`chronaxis.execution.history._expression_metadata_cost`	function
`chronaxis.execution.history._pending_bytes`	function
`chronaxis.execution.history_records.HistorySample`	class
`chronaxis.execution.history_records.HistorySample.__post_init__`	function
`chronaxis.execution.history_records.HistoryProgress`	class
`chronaxis.execution.history_records.HistoryProgress.__post_init__`	function
`chronaxis.execution.history_records.record_values`	function
`chronaxis.execution.history_records.estimate_record_bytes`	function
`chronaxis.execution.history_records.encode_record`	function
`chronaxis.execution.history_records.decode_record`	function
`chronaxis.execution.hosted_sample_reduction.HostedSampleReduction`	class
`chronaxis.execution.hosted_sample_reduction.HostedSampleReduction.__init__`	function
`chronaxis.execution.hosted_sample_reduction.HostedSampleReduction.push`	function
`chronaxis.execution.hosted_sample_reduction.HostedSampleReduction.finish`	function
`chronaxis.execution.hosted_sample_reduction.HostedSampleReduction.close`	function
`chronaxis.execution.legacy_frame_samples.LegacyFrameSamples`	class
`chronaxis.execution.legacy_frame_samples.LegacyFrameSamples.__init__`	function
`chronaxis.execution.legacy_frame_samples.LegacyFrameSamples.closed`	function
`chronaxis.execution.legacy_frame_samples.LegacyFrameSamples.__iter__`	function
`chronaxis.execution.legacy_frame_samples.LegacyFrameSamples.__next__`	function
`chronaxis.execution.legacy_frame_samples.LegacyFrameSamples.close`	function
`chronaxis.execution.memory_reader.BudgetedMemorySourceAdapter`	class
`chronaxis.execution.memory_reader.BudgetedMemorySourceAdapter.__init__`	function
`chronaxis.execution.memory_reader.BudgetedMemorySourceAdapter._ensure_open`	function
`chronaxis.execution.memory_reader.BudgetedMemorySourceAdapter.describe`	function
`chronaxis.execution.memory_reader.BudgetedMemorySourceAdapter._request_cost`	function
`chronaxis.execution.memory_reader.BudgetedMemorySourceAdapter.iter_batches`	function
`chronaxis.execution.memory_reader.BudgetedMemorySourceAdapter.close`	function
`chronaxis.execution.memory_reader._BudgetedBatches`	class
`chronaxis.execution.memory_reader._BudgetedBatches.__init__`	function
`chronaxis.execution.memory_reader._BudgetedBatches.__iter__`	function
`chronaxis.execution.memory_reader._BudgetedBatches.__next__`	function
`chronaxis.execution.memory_reader._BudgetedBatches.close`	function
`chronaxis.execution.message_delivery.deliver_message`	function
`chronaxis.execution.parallel_can_decode._with_position`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead`	class
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.__init__`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.closed`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.exhausted`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.metadata`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._receive`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._bytes`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._assign`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._accept_metadata`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._accept_metadata.reserve_model`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.prepare_metadata`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._block`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._record_identity`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._next_task`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._stop_workers`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._prepare_sorted`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead._push`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.__iter__`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.__next__`	function
`chronaxis.execution.parallel_can_decode.ParallelCANDecodeRead.close`	function
`chronaxis.execution.parallel_can_worker.plain`	function
`chronaxis.execution.parallel_can_worker.facts`	function
`chronaxis.execution.parallel_can_worker.read_block`	function
`chronaxis.execution.parallel_can_worker.worker_main`	function
`chronaxis.execution.raw_signal_groups.RawSignalGroups`	class
`chronaxis.execution.raw_signal_groups.RawSignalGroups.__init__`	function
`chronaxis.execution.raw_signal_groups.RawSignalGroups._require_open`	function
`chronaxis.execution.raw_signal_groups.RawSignalGroups.configure_metadata`	function
`chronaxis.execution.raw_signal_groups.RawSignalGroups.consume`	function
`chronaxis.execution.raw_signal_groups.RawSignalGroups._flush`	function
`chronaxis.execution.raw_signal_groups.RawSignalGroups.finish`	function
`chronaxis.execution.raw_signal_groups.RawSignalGroups.close`	function
`chronaxis.execution.record_alarm_duration.RecordAlarmDuration`	class
`chronaxis.execution.record_alarm_duration.RecordAlarmDuration.__init__`	function
`chronaxis.execution.record_alarm_duration.RecordAlarmDuration.consume`	function
`chronaxis.execution.record_alarm_duration.RecordAlarmDuration.driver`	function
`chronaxis.execution.record_alarm_duration.RecordAlarmDuration.finish`	function
`chronaxis.execution.record_alarm_duration.RecordAlarmDuration.closed`	function
`chronaxis.execution.record_alarm_duration.RecordAlarmDuration.close`	function
`chronaxis.execution.record_delta_condition.RecordDeltaCondition`	class
`chronaxis.execution.record_delta_condition.RecordDeltaCondition.__init__`	function
`chronaxis.execution.record_delta_condition.RecordDeltaCondition._condition`	function
`chronaxis.execution.record_delta_condition.RecordDeltaCondition._append`	function
`chronaxis.execution.record_delta_condition.RecordDeltaCondition._left`	function
`chronaxis.execution.record_delta_condition.RecordDeltaCondition.update`	function
`chronaxis.execution.record_delta_condition.RecordDeltaCondition.closed`	function
`chronaxis.execution.record_delta_condition.RecordDeltaCondition.close`	function
`chronaxis.execution.record_diagnostics.RecordDiagnostics`	class
`chronaxis.execution.record_diagnostics.RecordDiagnostics.__init__`	function
`chronaxis.execution.record_diagnostics.RecordDiagnostics.consume`	function
`chronaxis.execution.record_diagnostics.RecordDiagnostics.summaries`	function
`chronaxis.execution.record_diagnostics.RecordDiagnostics.close`	function
`chronaxis.execution.record_event_durations.RecordEventDurations`	class
`chronaxis.execution.record_event_durations.RecordEventDurations.__init__`	function
`chronaxis.execution.record_event_durations.RecordEventDurations._open`	function
`chronaxis.execution.record_event_durations.RecordEventDurations.observe_group`	function
`chronaxis.execution.record_event_durations.RecordEventDurations.observe_event`	function
`chronaxis.execution.record_event_durations.RecordEventDurations._calculate`	function
`chronaxis.execution.record_event_durations.RecordEventDurations._flush_ready`	function
`chronaxis.execution.record_event_durations.RecordEventDurations.finish`	function
`chronaxis.execution.record_event_durations.RecordEventDurations.closed`	function
`chronaxis.execution.record_event_durations.RecordEventDurations.close`	function
`chronaxis.execution.record_export_samples.RecordExportSamples`	class
`chronaxis.execution.record_export_samples.RecordExportSamples.__init__`	function
`chronaxis.execution.record_export_samples.RecordExportSamples.append`	function
`chronaxis.execution.record_export_samples.RecordExportSamples._fields`	function
`chronaxis.execution.record_export_samples.RecordExportSamples._lower`	function
`chronaxis.execution.record_export_samples.RecordExportSamples.rows`	function
`chronaxis.execution.record_export_samples.RecordExportSamples.closed`	function
`chronaxis.execution.record_export_samples.RecordExportSamples.close`	function
`chronaxis.execution.record_exports.RecordExports`	class
`chronaxis.execution.record_exports.RecordExports.__init__`	function
`chronaxis.execution.record_exports.RecordExports._require_clock`	function
`chronaxis.execution.record_exports.RecordExports._export`	function
`chronaxis.execution.record_exports.RecordExports.session`	function
`chronaxis.execution.record_exports.RecordExports.segment`	function
`chronaxis.execution.record_exports.RecordExports.seal`	function
`chronaxis.execution.record_exports.RecordExports.take_exports`	function
`chronaxis.execution.record_exports.RecordExports.closed`	function
`chronaxis.execution.record_exports.RecordExports.close`	function
`chronaxis.execution.record_integral.RecordIntegralResult`	class
`chronaxis.execution.record_integral.RecordIntegral`	class
`chronaxis.execution.record_integral.RecordIntegral.__init__`	function
`chronaxis.execution.record_integral.RecordIntegral._flush`	function
`chronaxis.execution.record_integral.RecordIntegral.finish`	function
`chronaxis.execution.record_integral.RecordIntegral.closed`	function
`chronaxis.execution.record_integral.RecordIntegral.close`	function
`chronaxis.execution.record_object_counts.object_count_results`	function
`chronaxis.execution.record_point_buffer.RecordPointBuffer`	class
`chronaxis.execution.record_point_buffer.RecordPointBuffer._require_open`	function
`chronaxis.execution.record_point_buffer.RecordPointBuffer.consume`	function
`chronaxis.execution.record_point_buffer.RecordPointBuffer.expire_at`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline`	class
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.__init__`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.extend_observation`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline._open`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.begin`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline._snapshot`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline._commit`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline._drain_before`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.before_group`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.after_group`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.clock_group`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.finish`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.outcome`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.count_evidence`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.duration_result`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.closed`	function
`chronaxis.execution.record_rule_timeline.RecordRuleTimeline.close`	function
`chronaxis.execution.record_sample.RecordSample`	class
`chronaxis.execution.record_sample.RecordSample.__post_init__`	function
`chronaxis.execution.record_sample.RecordSample.array_value`	function
`chronaxis.execution.record_sample.RecordSample.original_present`	function
`chronaxis.execution.record_sample.RecordSample.original_value`	function
`chronaxis.execution.record_sample._record_from_validated_fields`	function
`chronaxis.execution.record_sample_series.sample_series`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations`	class
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations.__init__`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations._new`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations._open`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations.observe_group`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations.observe_event`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations.observe_segment`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations._calculate`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations._calculate_chunk`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations._estimated_selection`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations._finish_observation_tail`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations._flush`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations.finish`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations.closed`	function
`chronaxis.execution.record_scope_calculations.RecordScopeCalculations.close`	function
`chronaxis.execution.record_selection.RecordSelection`	class
`chronaxis.execution.record_selection.RecordSelection.__init__`	function
`chronaxis.execution.record_selection.RecordSelection._flush`	function
`chronaxis.execution.record_selection.RecordSelection.finish`	function
`chronaxis.execution.record_selection.RecordSelection.close`	function
`chronaxis.execution.record_sequences.RecordSequences`	class
`chronaxis.execution.record_sequences.RecordSequences.__init__`	function
`chronaxis.execution.record_sequences.RecordSequences._open`	function
`chronaxis.execution.record_sequences.RecordSequences._entry`	function
`chronaxis.execution.record_sequences.RecordSequences.bounds`	function
`chronaxis.execution.record_sequences.RecordSequences.observe`	function
`chronaxis.execution.record_sequences.RecordSequences.drivers`	function
`chronaxis.execution.record_sequences.RecordSequences._consume`	function
`chronaxis.execution.record_sequences.RecordSequences.flush_before`	function
`chronaxis.execution.record_sequences.RecordSequences.closed`	function
`chronaxis.execution.record_sequences.RecordSequences.close`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations`	class
`chronaxis.execution.record_session_calculations.RecordSessionCalculations.__init__`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._new`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._consume_group`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._emit_selection`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._emit_input_trace`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._emit_contribution`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations.execute_into`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._prepare_requests`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._prepare_input_state`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._prepare_operators`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._complete_results`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._append_aggregate_input`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._finish_actual_tails`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._consume_constants`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._emit_event`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._emit_event_duration`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._emit_segment`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._count_outcome`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations.analysis_outcome`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations.threshold_summaries`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._emit_sequence`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._consume_message`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._flush_messages`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._consume_direct_update`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._before_direct_group`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._advance_observed_domain`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._merge_sources`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._close_slot`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations._require_closed`	function
`chronaxis.execution.record_session_calculations.RecordSessionCalculations.close`	function
`chronaxis.execution.record_signal_export.RecordSignalExport`	class
`chronaxis.execution.record_signal_export.RecordSignalExport.__init__`	function
`chronaxis.execution.record_signal_export.RecordSignalExport.update_observation`	function
`chronaxis.execution.record_signal_export.RecordSignalExport._bounds`	function
`chronaxis.execution.record_signal_export.RecordSignalExport._begin`	function
`chronaxis.execution.record_signal_export.RecordSignalExport._flush`	function
`chronaxis.execution.record_signal_export.RecordSignalExport.observe`	function
`chronaxis.execution.record_signal_export.RecordSignalExport.finish`	function
`chronaxis.execution.record_signal_export.RecordSignalExport.segment`	function
`chronaxis.execution.record_signal_export.RecordSignalExport.closed`	function
`chronaxis.execution.record_signal_export.RecordSignalExport.close`	function
`chronaxis.execution.record_source_cursor._queued_group_cost`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor`	class
`chronaxis.execution.record_source_cursor.RecordSourceCursor.__init__`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._consume_message`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._attach_raw_groups`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._refresh_observed_bounds`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._new`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._enqueue`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor.peek`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor.advance`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._retain_frame_notices`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._require_closed`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor._close_slot`	function
`chronaxis.execution.record_source_cursor.RecordSourceCursor.close`	function
`chronaxis.execution.record_time_calculation.RecordTimeResult`	class
`chronaxis.execution.record_time_calculation.RecordTimeCalculation`	class
`chronaxis.execution.record_time_calculation.RecordTimeCalculation.__init__`	function
`chronaxis.execution.record_time_calculation.RecordTimeCalculation._append_mean`	function
`chronaxis.execution.record_time_calculation.RecordTimeCalculation._flush`	function
`chronaxis.execution.record_time_calculation.RecordTimeCalculation._flush_block`	function
`chronaxis.execution.record_time_calculation.RecordTimeCalculation._finish_mean`	function
`chronaxis.execution.record_time_calculation.RecordTimeCalculation.finish`	function
`chronaxis.execution.record_time_calculation.RecordTimeCalculation.closed`	function
`chronaxis.execution.record_time_calculation.RecordTimeCalculation.close`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes`	class
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.__init__`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.observe_group`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.count`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.last`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.at`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.lower`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.position`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.shift`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.closed`	function
`chronaxis.execution.record_time_indexes.RecordTimeIndexes.close`	function
`chronaxis.execution.record_value_history.RecordValueHistory`	class
`chronaxis.execution.record_value_history.RecordValueHistory.__init__`	function
`chronaxis.execution.record_value_history.RecordValueHistory.count`	function
`chronaxis.execution.record_value_history.RecordValueHistory.last_time`	function
`chronaxis.execution.record_value_history.RecordValueHistory._open`	function
`chronaxis.execution.record_value_history.RecordValueHistory.append`	function
`chronaxis.execution.record_value_history.RecordValueHistory.expire_at`	function
`chronaxis.execution.record_value_history.RecordValueHistory.at`	function
`chronaxis.execution.record_value_history.RecordValueHistory.lower`	function
`chronaxis.execution.record_value_history.RecordValueHistory.rows`	function
`chronaxis.execution.record_value_history.RecordValueHistory.closed`	function
`chronaxis.execution.record_value_history.RecordValueHistory.close`	function
`chronaxis.execution.record_windows.RecordWindows`	class
`chronaxis.execution.record_windows.RecordWindows.__init__`	function
`chronaxis.execution.record_windows.RecordWindows._bounds`	function
`chronaxis.execution.record_windows.RecordWindows._coverage`	function
`chronaxis.execution.record_windows.RecordWindows._process`	function
`chronaxis.execution.record_windows.RecordWindows.finish`	function
`chronaxis.execution.record_windows.RecordWindows.closed`	function
`chronaxis.execution.record_windows.RecordWindows.close`	function
`chronaxis.execution.result_aggregations.discovery_rules`	function
`chronaxis.execution.result_aggregations._Group`	class
`chronaxis.execution.result_aggregations._Group.__init__`	function
`chronaxis.execution.result_aggregations._Group.accept`	function
`chronaxis.execution.result_aggregations._Group.value`	function
`chronaxis.execution.result_aggregations.ResultAggregations`	class
`chronaxis.execution.result_aggregations.ResultAggregations.__init__`	function
`chronaxis.execution.result_aggregations.ResultAggregations._input_dtype`	function
`chronaxis.execution.result_aggregations.ResultAggregations._group`	function
`chronaxis.execution.result_aggregations.ResultAggregations.accept`	function
`chronaxis.execution.result_aggregations.ResultAggregations.rows`	function
`chronaxis.execution.result_aggregations.ResultAggregations.close`	function
`chronaxis.execution.run_session.RunSession`	class
`chronaxis.execution.run_session.RunSession.__init__`	function
`chronaxis.execution.run_session.RunSession._require_static_derived`	function
`chronaxis.execution.run_session.RunSession.closed`	function
`chronaxis.execution.run_session.RunSession.failed`	function
`chronaxis.execution.run_session.RunSession.work_dir`	function
`chronaxis.execution.run_session.RunSession._construct`	function
`chronaxis.execution.run_session.RunSession.execute`	function
`chronaxis.execution.run_session.RunSession._run_record_calculations`	function
`chronaxis.execution.run_session.RunSession._adopt_cleanup`	function
`chronaxis.execution.run_session.RunSession._diagnose`	function
`chronaxis.execution.run_session.RunSession._require_closed`	function
`chronaxis.execution.run_session.RunSession._close_slot`	function
`chronaxis.execution.run_session.RunSession._close_inputs`	function
`chronaxis.execution.run_session.RunSession._clear_contracts`	function
`chronaxis.execution.run_session.RunSession._release_costs`	function
`chronaxis.execution.run_session.RunSession._assert_owned_balance`	function
`chronaxis.execution.run_session.RunSession.close`	function
`chronaxis.execution.same_frame_integrals.direct_integral_inputs`	function
`chronaxis.execution.same_frame_integrals.SameFrameBinding`	class
`chronaxis.execution.same_frame_integrals.SameFrameBinding.matches`	function
`chronaxis.execution.same_frame_integrals.same_frame_binding`	function
`chronaxis.execution.same_frame_integrals._same_value`	function
`chronaxis.execution.same_frame_integrals.SameFrameIntegrals`	class
`chronaxis.execution.same_frame_integrals.SameFrameIntegrals.__init__`	function
`chronaxis.execution.same_frame_integrals.SameFrameIntegrals._require_open`	function
`chronaxis.execution.same_frame_integrals.SameFrameIntegrals.consume`	function
`chronaxis.execution.same_frame_integrals.SameFrameIntegrals._flush`	function
`chronaxis.execution.same_frame_integrals.SameFrameIntegrals.finish`	function
`chronaxis.execution.same_frame_integrals.SameFrameIntegrals.close`	function
`chronaxis.execution.signal_validity.resolve_signal_validity`	function
`chronaxis.execution.state.CommittedUpdates`	class
`chronaxis.execution.state.CommittedUpdates.__post_init__`	function
`chronaxis.execution.state._committed_from_validated_fields`	function
`chronaxis.execution.state._same_fact`	function
`chronaxis.execution.state._StateSnapshot`	class
`chronaxis.execution.state.LatestSignalState`	class
`chronaxis.execution.state.LatestSignalState.__init__`	function
`chronaxis.execution.state.LatestSignalState.budget`	function
`chronaxis.execution.state.LatestSignalState.session_id`	function
`chronaxis.execution.state.LatestSignalState.closed`	function
`chronaxis.execution.state.LatestSignalState.definitions`	function
`chronaxis.execution.state.LatestSignalState.latest`	function
`chronaxis.execution.state.LatestSignalState.fixed_cost`	function
`chronaxis.execution.state.LatestSignalState.retained_cost`	function
`chronaxis.execution.state.LatestSignalState._transaction_delta`	function
`chronaxis.execution.state.LatestSignalState.last_time_ns`	function
`chronaxis.execution.state.LatestSignalState.conflict_count`	function
`chronaxis.execution.state.LatestSignalState.revision`	function
`chronaxis.execution.state.LatestSignalState._ensure_open`	function
`chronaxis.execution.state.LatestSignalState.get`	function
`chronaxis.execution.state.LatestSignalState._before_group`	function
`chronaxis.execution.state.LatestSignalState.apply`	function
`chronaxis.execution.state.LatestSignalState._change_budget`	function
`chronaxis.execution.state.LatestSignalState._restore_transaction`	function
`chronaxis.execution.state.LatestSignalState.close`	function
`chronaxis.execution.state._sequence`	function
`chronaxis.execution.static_metadata.static_metadata_bytes`	function
`chronaxis.execution.static_metadata._static_metadata_cost`	function
`chronaxis.execution.temporal_buffer._BatchRegistry`	class
`chronaxis.execution.temporal_buffer._BatchRegistry.__init__`	function
`chronaxis.execution.temporal_buffer._BatchRegistry.__bool__`	function
`chronaxis.execution.temporal_buffer._BatchRegistry.__len__`	function
`chronaxis.execution.temporal_buffer._BatchRegistry.__iter__`	function
`chronaxis.execution.temporal_buffer._BatchRegistry.add`	function
`chronaxis.execution.temporal_buffer._BatchRegistry.discard`	function
`chronaxis.execution.temporal_buffer.TemporalEventBatch`	class
`chronaxis.execution.temporal_buffer.TemporalEventBatch.__init__`	function
`chronaxis.execution.temporal_buffer.TemporalEventBatch.closed`	function
`chronaxis.execution.temporal_buffer.TemporalEventBatch.events`	function
`chronaxis.execution.temporal_buffer.TemporalEventBatch.close`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector`	class
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.__init__`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._ensure_open`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._ensure_active`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.rule`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.start_ns`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.end_ns`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.next_deadline_ns`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.closed`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.failed`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.duration_counts`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.extend_observed_end`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.set_observed_end`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._workspace_cost`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._register`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._discard_unreturned`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._fail`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._release_failed_workspace`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector._refund_failed_workspace`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.push`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.finish`	function
`chronaxis.execution.temporal_buffer.BudgetedTemporalDetector.close`	function
`chronaxis.execution.text_can_reader._record_metadata_bytes`	function
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter`	class
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter.__init__`	function
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter.retain_raw_frames`	function
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter._ensure_open`	function
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter.describe`	function
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter.iter_batches_with_observation`	function
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter.iter_batches`	function
`chronaxis.execution.text_can_reader.BudgetedTextCANSourceAdapter.close`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead`	class
`chronaxis.execution.text_can_reader.TextCANObservationRead.__init__`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.closed`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.failed`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.exhausted`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.observation`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.observed_bounds`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.runtime_metadata`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.prepare_metadata`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.__iter__`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead._accept`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead._fill`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.__next__`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead._finish`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.take_raw_store`	function
`chronaxis.execution.text_can_reader.TextCANObservationRead.close`	function
`chronaxis.execution.transform_partial.partial_in_block`	function
`chronaxis.execution.transform_partial.partial_result`	function
`chronaxis.execution.transform_stream.TransformStage`	class
`chronaxis.execution.transform_stream.TransformStage.__init__`	function
`chronaxis.execution.transform_stream.TransformStage._ensure_active`	function
`chronaxis.execution.transform_stream.TransformStage.bounds`	function
`chronaxis.execution.transform_stream.TransformStage._invalid`	function
`chronaxis.execution.transform_stream.TransformStage._sample`	function
`chronaxis.execution.transform_stream.TransformStage._at_grid`	function
`chronaxis.execution.transform_stream.TransformStage._convert_rate`	function
`chronaxis.execution.transform_stream.TransformStage._deliver`	function
`chronaxis.execution.transform_stream.TransformStage._drain`	function
`chronaxis.execution.transform_stream.TransformStage._append_span`	function
`chronaxis.execution.transform_stream.TransformStage.push`	function
`chronaxis.execution.transform_stream.TransformStage._flush_waiting`	function
`chronaxis.execution.transform_stream.TransformStage._process`	function
`chronaxis.execution.transform_stream.TransformStage.finish`	function
`chronaxis.execution.transform_stream.TransformStage._finish_grid`	function
`chronaxis.execution.transform_stream.TransformStage.close`	function
`chronaxis.execution.transform_window.TransformSpan`	class
`chronaxis.execution.transform_window.first_grid`	function
`chronaxis.execution.transform_window.TransformWindow`	class
`chronaxis.execution.transform_window.TransformWindow.__init__`	function
`chronaxis.execution.transform_window.TransformWindow.append`	function
`chronaxis.execution.transform_window.TransformWindow._weight`	function
`chronaxis.execution.transform_window.TransformWindow.trim`	function
`chronaxis.execution.transform_window.TransformWindow.slices`	function
`chronaxis.execution.transform_window.TransformWindow.close`	function
`chronaxis.execution.where_state.before_context`	function
`chronaxis.execution.where_state.scalar_columns`	function
`chronaxis.execution.where_state.group_updates`	function
`chronaxis.execution.where_state.group_active`	function
`chronaxis.extension_runtime.ExtensionResources`	class
`chronaxis.extension_runtime.ExtensionResources.__init__`	function
`chronaxis.extension_runtime.ExtensionResources.reserve`	function
`chronaxis.extension_runtime.ExtensionResources.release`	function
`chronaxis.extension_runtime.ExtensionResources.close`	function
`chronaxis.extension_runtime._check_scalar`	function
`chronaxis.extension_runtime._check_values`	function
`chronaxis.extension_runtime.point_call`	function
`chronaxis.extension_runtime._HostedState`	class
`chronaxis.extension_runtime._HostedState.__init__`	function
`chronaxis.extension_runtime._HostedState._require_open`	function
`chronaxis.extension_runtime._HostedState.close`	function
`chronaxis.extension_runtime.HostedReduction`	class
`chronaxis.extension_runtime.HostedReduction.__init__`	function
`chronaxis.extension_runtime.HostedReduction.consume`	function
`chronaxis.extension_runtime.HostedReduction.merge`	function
`chronaxis.extension_runtime.HostedReduction.finalize`	function
`chronaxis.extension_runtime.HostedTransform`	class
`chronaxis.extension_runtime.HostedTransform.__init__`	function
`chronaxis.extension_runtime.HostedTransform.advance`	function
`chronaxis.extension_runtime.advance_grid`	function
`chronaxis.extensions.ValueSpec`	class
`chronaxis.extensions.ValueSpec.__post_init__`	function
`chronaxis.extensions._BackendSpec`	class
`chronaxis.extensions._BackendSpec.require_backend`	function
`chronaxis.extensions._BackendSpec._check`	function
`chronaxis.extensions.FunctionSpec`	class
`chronaxis.extensions.FunctionSpec.__post_init__`	function
`chronaxis.extensions.ReductionSpec`	class
`chronaxis.extensions.ReductionSpec.__post_init__`	function
`chronaxis.extensions.TransformSpec`	class
`chronaxis.extensions.TransformSpec.__post_init__`	function
`chronaxis.extensions.ExtensionRegistry`	class
`chronaxis.extensions.ExtensionRegistry.__init__`	function
`chronaxis.extensions.using_extension_budget`	function
`chronaxis.fast.baseline.main`	function
`chronaxis.fast.batch.prepare_batch`	function
`chronaxis.fast.batch.run_batch`	function
`chronaxis.fast.blocks.encode`	function
`chronaxis.fast.blocks.decode`	function
`chronaxis.fast.blocks.batches`	function
`chronaxis.fast.can_io._Group`	class
`chronaxis.fast.can_io._prepare`	function
`chronaxis.fast.can_io.run_one`	function
`chronaxis.fast.cli.execute`	function
`chronaxis.fast.cli._batch`	function
`chronaxis.fast.compute._float`	function
`chronaxis.fast.compute._typed`	function
`chronaxis.fast.compute._number_type`	function
`chronaxis.fast.compute._affine`	function
`chronaxis.fast.compute.encode_program`	function
`chronaxis.fast.compute._syntax`	function
`chronaxis.fast.compute._syntax.literal`	function
`chronaxis.fast.compute._syntax.visit`	function
`chronaxis.fast.compute._bind`	function
`chronaxis.fast.compute._Accumulator`	class
`chronaxis.fast.compute._Accumulator.__init__`	function
`chronaxis.fast.compute._Accumulator.add`	function
`chronaxis.fast.compute._Accumulator.result`	function
`chronaxis.fast.compute._Metric`	class
`chronaxis.fast.compute._Metric.__init__`	function
`chronaxis.fast.compute._Metric.consume`	function
`chronaxis.fast.compute._Metric.contribution`	function
`chronaxis.fast.compute.prepare_metric`	function
`chronaxis.fast.compute._prepare_program_metric`	function
`chronaxis.fast.compute._check_program_spec`	function
`chronaxis.fast.config._unsupported`	function
`chronaxis.fast.config._capabilities`	function
`chronaxis.fast.config._source`	function
`chronaxis.fast.config._flag`	function
`chronaxis.fast.config._metric`	function
`chronaxis.fast.config._compile_plan`	function
`chronaxis.fast.config.compile_template_plan`	function
`chronaxis.fast.config.compile_config`	function
`chronaxis.fast.run.run_prepared`	function
`chronaxis.fast.run.run`	function
`chronaxis.fast.session.effective_spec`	function
`chronaxis.fast.session._worker_process_limit`	function
`chronaxis.fast.session.file_specs`	function
`chronaxis.fast.session._checked_file_specs`	function
`chronaxis.fast.session.SessionAccumulator`	class
`chronaxis.fast.session.SessionAccumulator.__init__`	function
`chronaxis.fast.session.SessionAccumulator.consume`	function
`chronaxis.fast.session.SessionAccumulator.finish_file`	function
`chronaxis.fast.session.SessionAccumulator.result`	function
`chronaxis.fast.session.FilePool`	class
`chronaxis.fast.session.FilePool.__init__`	function
`chronaxis.fast.session.FilePool.check_cancel`	function
`chronaxis.fast.session.FilePool.start`	function
`chronaxis.fast.session.FilePool.assign`	function
`chronaxis.fast.session.FilePool.grant`	function
`chronaxis.fast.session.FilePool.pump`	function
`chronaxis.fast.session.FilePool.message`	function
`chronaxis.fast.session.FilePool.packet_records`	function
`chronaxis.fast.session.FilePool.read_spool`	function
`chronaxis.fast.session.FilePool.concatenate`	function
`chronaxis.fast.session.FilePool.file_records`	function
`chronaxis.fast.session.FilePool.time_order`	function
`chronaxis.fast.session.FilePool.close`	function
`chronaxis.fast.session._SessionResources`	class
`chronaxis.fast.session._SessionResources.__init__`	function
`chronaxis.fast.session._SessionResources.open_reader`	function
`chronaxis.fast.session._SessionResources.close_reader`	function
`chronaxis.fast.session._SessionResources.create_directory`	function
`chronaxis.fast.session._SessionResources.close`	function
`chronaxis.fast.session.run_session`	function
`chronaxis.fast.session_worker.worker_main`	function
`chronaxis.fast.stream.FileContributions`	class
`chronaxis.fast.stream.FileContributions.__init__`	function
`chronaxis.fast.stream.FileContributions._measured`	function
`chronaxis.fast.stream.FileContributions._selected_time`	function
`chronaxis.fast.stream.FileContributions.__iter__`	function
`chronaxis.fast.stream.FileContributions.__next__`	function
`chronaxis.fast.stream.FileContributions.summary`	function
`chronaxis.fast.stream.FileContributions.close`	function
`chronaxis.fast.totals._semantics`	function
`chronaxis.fast.totals.FastTotals`	class
`chronaxis.fast.totals.FastTotals.from_specs`	function
`chronaxis.fast.totals.FastTotals.finish`	function
`chronaxis.fast.worker._run_file`	function
`chronaxis.fast.worker._dbc_digest`	function
`chronaxis.fast.worker.file_response`	function
`chronaxis.legacy.__getattr__`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead`	class
`chronaxis.legacy.batch_read.LegacyCANBatchRead.__init__`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._check_ready`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._check_ready_metadata`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead.counters`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead.full_check_count`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._receive_reply`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead.__next__`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._new_packet`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._set_prefetch_headroom`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._available_limit`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._try_prefetch`	function
`chronaxis.legacy.batch_read.LegacyCANBatchRead._release_closed_state`	function
`chronaxis.legacy.batch_validation._item_base_size`	function
`chronaxis.legacy.batch_validation._validate_native_frame`	function
`chronaxis.legacy.batch_validation.validate_discarded`	function
`chronaxis.legacy.batch_wire.LegacyDecodedBatch`	class
`chronaxis.legacy.batch_wire.LegacyDecodedBatch.frame_count`	function
`chronaxis.legacy.batch_wire.encode_batch`	function
`chronaxis.legacy.batch_wire.decode_batch`	function
`chronaxis.legacy.batch_wire.record_payload_offset`	function
`chronaxis.legacy.batch_wire._encode_required_batch`	function
`chronaxis.legacy.batch_wire._decode_required_batch`	function
`chronaxis.legacy.batch_worker._requested_fields`	function
`chronaxis.legacy.batch_worker._project_values`	function
`chronaxis.legacy.batch_worker._encode_fresh_packet`	function
`chronaxis.legacy.batch_worker._limits`	function
`chronaxis.legacy.batch_worker.batch_worker_main`	function
`chronaxis.legacy.binding.field_matches`	function
`chronaxis.legacy.binding.dbc_candidates`	function
`chronaxis.legacy.binding.select_message`	function
`chronaxis.legacy.binding.FrameBindingResolver`	class
`chronaxis.legacy.binding.FrameBindingResolver.__init__`	function
`chronaxis.legacy.binding.FrameBindingResolver.fields_for`	function
`chronaxis.legacy.binding.FrameBindingResolver.message_for`	function
`chronaxis.legacy.binding.FrameBindingResolver.missing_flags`	function
`chronaxis.legacy.dbc_cycles.require_cycle_fields`	function
`chronaxis.legacy.dbc_cycles.cycle_time_ns`	function
`chronaxis.legacy.decode_policy.validate_decode_policy`	function
`chronaxis.legacy.decode_policy.check_decode_length`	function
`chronaxis.legacy.decode_policy.decode_serial_frame`	function
`chronaxis.legacy.disjunction.LegacyDisjunction`	class
`chronaxis.legacy.disjunction.LegacyDisjunction.__post_init__`	function
`chronaxis.legacy.disjunction.LegacyDisjunctionTrace`	class
`chronaxis.legacy.disjunction.LegacyDisjunctionTrace.__post_init__`	function
`chronaxis.legacy.export_worker._output`	function
`chronaxis.legacy.export_worker._message`	function
`chronaxis.legacy.export_worker.worker_main`	function
`chronaxis.legacy.export_write.LegacyCANWriteError`	class
`chronaxis.legacy.export_write.LegacyCANProcessWrite`	class
`chronaxis.legacy.export_write.LegacyCANProcessWrite.__init__`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._check_path`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.output_path`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.closed`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.finished`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.failed`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.worker_pid`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.spool_bytes`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.counters`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.metadata`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._require_open`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._reserve_spool`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._fail`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.start`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._check_ready`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._exchange`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.write`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.finish`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._close_connection`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite._close_process`	function
`chronaxis.legacy.export_write.LegacyCANProcessWrite.close`	function
`chronaxis.legacy.message_store._clear_records_traceback`	function
`chronaxis.legacy.message_store.StoredDecodedMessage`	class
`chronaxis.legacy.message_store.StoredDecodedMessage.__post_init__`	function
`chronaxis.legacy.message_store._encode_row`	function
`chronaxis.legacy.message_store._decode_row`	function
`chronaxis.legacy.message_store.DecodedMessageStore`	class
`chronaxis.legacy.message_store.DecodedMessageStore.__init__`	function
`chronaxis.legacy.message_store.DecodedMessageStore.line_limit`	function
`chronaxis.legacy.message_store.DecodedMessageStore.closed`	function
`chronaxis.legacy.message_store.DecodedMessageStore.spool_bytes`	function
`chronaxis.legacy.message_store.DecodedMessageStore._require`	function
`chronaxis.legacy.message_store.DecodedMessageStore._fail`	function
`chronaxis.legacy.message_store.DecodedMessageStore._reserve_spool`	function
`chronaxis.legacy.message_store.DecodedMessageStore._write_pending`	function
`chronaxis.legacy.message_store.DecodedMessageStore.append`	function
`chronaxis.legacy.message_store.DecodedMessageStore._close_writer`	function
`chronaxis.legacy.message_store.DecodedMessageStore.seal`	function
`chronaxis.legacy.message_store.DecodedMessageStore.iter_records`	function
`chronaxis.legacy.message_store.DecodedMessageStore.close`	function
`chronaxis.legacy.message_store._DecodedMessageReader`	class
`chronaxis.legacy.message_store._DecodedMessageReader.__init__`	function
`chronaxis.legacy.message_store._DecodedMessageReader.__iter__`	function
`chronaxis.legacy.message_store._DecodedMessageReader.__next__`	function
`chronaxis.legacy.message_store._DecodedMessageReader.close`	function
`chronaxis.legacy.process_read._wire_metadata_bytes`	function
`chronaxis.legacy.process_read._freeze`	function
`chronaxis.legacy.process_read.RemoteLegacyError`	class
`chronaxis.legacy.process_read.RemoteLegacyError.__init__`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead`	class
`chronaxis.legacy.process_read.LegacyCANProcessRead.__init__`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.closed`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.finished`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.worker_pid`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.counters`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.metadata`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._require_open`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._fail`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.start`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._check_ready`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._check_ready_metadata`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._exchange`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._send_request`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._receive_response`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._receive_reply`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.__iter__`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.__next__`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._close_connection`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._close_process`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead._release_closed_state`	function
`chronaxis.legacy.process_read.LegacyCANProcessRead.close`	function
`chronaxis.legacy.raw_store.RawFrameStore`	class
`chronaxis.legacy.raw_store.RawFrameStore.__init__`	function
`chronaxis.legacy.raw_store.RawFrameStore.closed`	function
`chronaxis.legacy.raw_store.RawFrameStore.spool_bytes`	function
`chronaxis.legacy.raw_store.RawFrameStore._require`	function
`chronaxis.legacy.raw_store.RawFrameStore._fail`	function
`chronaxis.legacy.raw_store.RawFrameStore._reserve_spool`	function
`chronaxis.legacy.raw_store.RawFrameStore.append`	function
`chronaxis.legacy.raw_store.RawFrameStore._close_writer`	function
`chronaxis.legacy.raw_store.RawFrameStore.seal`	function
`chronaxis.legacy.raw_store.RawFrameStore.iter_frames`	function
`chronaxis.legacy.raw_store.RawFrameStore.close`	function
`chronaxis.legacy.raw_store._RawFrameReader`	class
`chronaxis.legacy.raw_store._RawFrameReader.__init__`	function
`chronaxis.legacy.raw_store._RawFrameReader.__iter__`	function
`chronaxis.legacy.raw_store._RawFrameReader.__next__`	function
`chronaxis.legacy.raw_store._RawFrameReader.close`	function
`chronaxis.legacy.records.normalize_frame_id`	function
`chronaxis.legacy.records._small_item_fits`	function
`chronaxis.legacy.records._integer`	function
`chronaxis.legacy.records._text`	function
`chronaxis.legacy.records._shape`	function
`chronaxis.legacy.records.LegacyRawFrame`	class
`chronaxis.legacy.records.LegacyRawFrame.__post_init__`	function
`chronaxis.legacy.records.LegacyDecodedFrame`	class
`chronaxis.legacy.records.LegacyDecodedFrame.__post_init__`	function
`chronaxis.legacy.records.StoredRawFrame`	class
`chronaxis.legacy.records.StoredRawFrame.__post_init__`	function
`chronaxis.legacy.records.LegacyCANField`	class
`chronaxis.legacy.records.LegacyCANField.__post_init__`	function
`chronaxis.legacy.records.LegacyCANField.key`	function
`chronaxis.legacy.records.LegacyCANRequest`	class
`chronaxis.legacy.records.LegacyCANRequest.__post_init__`	function
`chronaxis.legacy.records.LegacyCANRequest.profile`	function
`chronaxis.legacy.records.frame_to_dict`	function
`chronaxis.legacy.records.frame_from_dict`	function
`chronaxis.legacy.records._value_to_wire`	function
`chronaxis.legacy.records._value_from_wire`	function
`chronaxis.legacy.records.decoded_to_dict`	function
`chronaxis.legacy.records.decoded_from_dict`	function
`chronaxis.legacy.records._decoded_from_checked_dict`	function
`chronaxis.legacy.records._try_decoded_small_packet`	function
`chronaxis.legacy.records._decoded_from_packet`	function
`chronaxis.legacy.records.field_to_dict`	function
`chronaxis.legacy.records.field_from_dict`	function
`chronaxis.legacy.records._scalar_size`	function
`chronaxis.legacy.records._decoded_entry_size`	function
`chronaxis.legacy.records._decoded_values_size`	function
`chronaxis.legacy.records._wire_tree`	function
`chronaxis.legacy.records.encode_packet`	function
`chronaxis.legacy.records._unique_object`	function
`chronaxis.legacy.records._reject_constant`	function
`chronaxis.legacy.records.decode_packet`	function
`chronaxis.legacy.required_records.RequiredCANFrame`	class
`chronaxis.legacy.required_records.RequiredCANFrame.__post_init__`	function
`chronaxis.legacy.required_records.required_frame_to_dict`	function
`chronaxis.legacy.required_records.RequiredDecodedFrame`	class
`chronaxis.legacy.required_records.RequiredDecodedFrame.__post_init__`	function
`chronaxis.legacy.required_records.required_to_dict`	function
`chronaxis.legacy.required_records.required_from_dict`	function
`chronaxis.legacy.required_records.required_from_packet`	function
`chronaxis.legacy.sum.LegacySkipReason`	class
`chronaxis.legacy.sum._require_contribution`	function
`chronaxis.legacy.sum.LegacySumContribution`	class
`chronaxis.legacy.sum.LegacySumContribution.__post_init__`	function
`chronaxis.legacy.sum.LegacySumSnapshot`	class
`chronaxis.legacy.sum.LegacySumSnapshot.__post_init__`	function
`chronaxis.legacy.sum._sum_reference`	function
`chronaxis.legacy.sum.LegacySumAccumulator`	class
`chronaxis.legacy.sum.LegacySumAccumulator.__init__`	function
`chronaxis.legacy.sum.LegacySumAccumulator.closed`	function
`chronaxis.legacy.sum.LegacySumAccumulator._ensure_open`	function
`chronaxis.legacy.sum.LegacySumAccumulator._candidate`	function
`chronaxis.legacy.sum.LegacySumAccumulator._release_failed_batch`	function
`chronaxis.legacy.sum.LegacySumAccumulator.consume`	function
`chronaxis.legacy.sum.LegacySumAccumulator.snapshot`	function
`chronaxis.legacy.sum.LegacySumAccumulator.close`	function
`chronaxis.legacy.sum_numpy.sum_numpy`	function
`chronaxis.legacy.updates._require_nonnegative_int`	function
`chronaxis.legacy.updates.LegacyDecodedUpdate`	class
`chronaxis.legacy.updates.LegacyDecodedUpdate.__post_init__`	function
`chronaxis.legacy.updates.LegacyDecodedUpdate._freeze_fields`	function
`chronaxis.legacy.updates.LegacyUntimedUpdate`	class
`chronaxis.legacy.updates.LegacyUntimedUpdate.__post_init__`	function
`chronaxis.legacy.updates.LegacyUpdateOrder`	class
`chronaxis.legacy.updates.LegacyUpdateOrder.__init__`	function
`chronaxis.legacy.updates.LegacyUpdateOrder.session_id`	function
`chronaxis.legacy.updates.LegacyUpdateOrder.source`	function
`chronaxis.legacy.updates.LegacyUpdateOrder.last_time_ns`	function
`chronaxis.legacy.updates.LegacyUpdateOrder.last_sequence`	function
`chronaxis.legacy.updates.LegacyUpdateOrder.last_evaluation_index`	function
`chronaxis.legacy.updates.LegacyUpdateOrder.count`	function
`chronaxis.legacy.updates.LegacyUpdateOrder.accept`	function
`chronaxis.legacy.worker._send`	function
`chronaxis.legacy.worker._receive`	function
`chronaxis.legacy.worker._exact`	function
`chronaxis.legacy.worker._request`	function
`chronaxis.legacy.worker._load_can_runtime`	function
`chronaxis.legacy.worker._iter_blf`	function
`chronaxis.legacy.worker._field_metadata`	function
`chronaxis.legacy.worker._frame`	function
`chronaxis.legacy.worker._argument_text`	function
`chronaxis.legacy.worker._error_packet`	function
`chronaxis.legacy.worker._report_error`	function
`chronaxis.legacy.worker.worker_main`	function
`chronaxis.planning.aggregations.AggregationPlan`	class
`chronaxis.planning.aggregations.aggregation_unit`	function
`chronaxis.planning.aggregations.parse_aggregations`	function
`chronaxis.planning.backend_selection.BackendSelection`	class
`chronaxis.planning.backend_selection.simple_numeric_expression`	function
`chronaxis.planning.backend_selection.select_backend`	function
`chronaxis.planning.backend_selection.execution_plan`	function
`chronaxis.planning.channels.channel_index`	function
`chronaxis.planning.checks.PlanValidationError`	class
`chronaxis.planning.checks.PlanValidationError.__init__`	function
`chronaxis.planning.checks.PlanValidationError.refresh_text`	function
`chronaxis.planning.checks.PlanValidationError.to_dict`	function
`chronaxis.planning.checks.PlanValidationError.diagnostics`	function
`chronaxis.planning.checks.PlanValidationError.from_diagnostics`	function
`chronaxis.planning.checks.configuration_error`	function
`chronaxis.planning.checks.object_at`	function
`chronaxis.planning.checks.array_at`	function
`chronaxis.planning.checks.text_at`	function
`chronaxis.planning.checks.choice_at`	function
`chronaxis.planning.checks.number_at`	function
`chronaxis.planning.checks.duration_at`	function
`chronaxis.planning.checks.coordinate_at`	function
`chronaxis.planning.checks.timezone_at`	function
`chronaxis.planning.checks.metadata_at`	function
`chronaxis.planning.checks.require_json_value`	function
`chronaxis.planning.checks.json_value`	function
`chronaxis.planning.checks.canonical`	function
`chronaxis.planning.checks.absolute_path`	function
`chronaxis.planning.checks.model_at`	function
`chronaxis.planning.config_groups.public_errors`	function
`chronaxis.planning.config_groups.public_errors.checked`	function
`chronaxis.planning.config_groups._leaves`	function
`chronaxis.planning.config_groups.normalize_configuration`	function
`chronaxis.planning.config_groups.public_configuration`	function
`chronaxis.planning.dbc_defaults.scoped_dbc_cache`	function
`chronaxis.planning.dbc_defaults.load_dbc`	function
`chronaxis.planning.dbc_defaults.requested_enum_codes`	function
`chronaxis.planning.dbc_defaults._numeric_dtype`	function
`chronaxis.planning.dbc_defaults._enum_choices`	function
`chronaxis.planning.dbc_defaults.DBCDefaults`	class
`chronaxis.planning.dbc_defaults.DBCDefaults.__init__`	function
`chronaxis.planning.dbc_defaults.DBCDefaults.fill`	function
`chronaxis.planning.diagnostic_collection.schema_validator`	function
`chronaxis.planning.diagnostic_collection._host_validator`	function
`chronaxis.planning.diagnostic_collection._specific_errors`	function
`chronaxis.planning.diagnostic_collection.DiagnosticCollection`	class
`chronaxis.planning.diagnostic_collection.DiagnosticCollection.__init__`	function
`chronaxis.planning.diagnostic_collection.DiagnosticCollection.add`	function
`chronaxis.planning.diagnostic_collection.DiagnosticCollection.usable`	function
`chronaxis.planning.diagnostic_collection.DiagnosticCollection.block`	function
`chronaxis.planning.diagnostic_collection.DiagnosticCollection.stage`	function
`chronaxis.planning.diagnostic_collection.DiagnosticCollection.finish`	function
`chronaxis.planning.diagnostic_collection.DiagnosticCollection.finish.priority`	function
`chronaxis.planning.diagnostic_collection.current_collection`	function
`chronaxis.planning.diagnostic_collection.collecting`	function
`chronaxis.planning.diagnostic_collection.usable_node`	function
`chronaxis.planning.diagnostic_collection.collect_node_error`	function
`chronaxis.planning.diagnostic_collection.require_expression_dependencies`	function
`chronaxis.planning.diagnostic_collection.expression_scope`	function
`chronaxis.planning.diagnostic_collection.diagnose_plan`	function
`chronaxis.planning.diagnostic_collection.diagnose_plan.checked`	function
`chronaxis.planning.export_options.SignalCSVOutput`	class
`chronaxis.planning.export_options.SignalCSVOutput.__post_init__`	function
`chronaxis.planning.export_options.CANFramesOutput`	class
`chronaxis.planning.export_options.CANFramesOutput.__post_init__`	function
`chronaxis.planning.export_options._typed_scope`	function
`chronaxis.planning.export_options.require_export_options`	function
`chronaxis.planning.export_options._scope`	function
`chronaxis.planning.export_options._grid`	function
`chronaxis.planning.export_options._signal_grid_driver`	function
`chronaxis.planning.export_options.parse_signal_output`	function
`chronaxis.planning.export_options._require_frame_direction`	function
`chronaxis.planning.export_options.parse_frame_output`	function
`chronaxis.planning.input_defaults.source_defaults`	function
`chronaxis.planning.input_defaults.source_reference`	function
`chronaxis.planning.input_paths.natural_path_key`	function
`chronaxis.planning.input_paths.expand_source_files`	function
`chronaxis.planning.input_paths.expand_input_paths`	function
`chronaxis.planning.input_paths.source_path_fields`	function
`chronaxis.planning.input_requirements.SourceInputRequirements`	class
`chronaxis.planning.input_requirements.InputRequirements`	class
`chronaxis.planning.input_requirements.InputRequirements.for_source`	function
`chronaxis.planning.input_requirements.supports_unbounded_message_summary`	function
`chronaxis.planning.input_requirements.collect_input_requirements`	function
`chronaxis.planning.input_requirements.collect_input_requirements.add`	function
`chronaxis.planning.input_requirements.collect_input_requirements.add_rule`	function
`chronaxis.planning.inputs.parse_sources`	function
`chronaxis.planning.inputs.parse_signals`	function
`chronaxis.planning.intervals.IntervalChoice`	class
`chronaxis.planning.intervals.IntervalChoice.__post_init__`	function
`chronaxis.planning.intervals.IntervalPlan`	class
`chronaxis.planning.intervals.IntervalPlan.__post_init__`	function
`chronaxis.planning.intervals.DiagnosticPlan`	class
`chronaxis.planning.intervals.DiagnosticPlan.__post_init__`	function
`chronaxis.planning.intervals.parse_diagnostics`	function
`chronaxis.planning.intervals._choice`	function
`chronaxis.planning.intervals._consumers`	function
`chronaxis.planning.intervals._driver_key`	function
`chronaxis.planning.intervals._resolve`	function
`chronaxis.planning.intervals.resolve_intervals`	function
`chronaxis.planning.intervals.parse_intervals`	function
`chronaxis.planning.intervals.require_interval_declarations`	function
`chronaxis.planning.legacy_execution.require_can_decode_scope`	function
`chronaxis.planning.lookups.parse_lookups`	function
`chronaxis.planning.message_calculations.require_message_calculation`	function
`chronaxis.planning.message_calculations.parse_message_calculations`	function
`chronaxis.planning.models.DatasetPlan`	class
`chronaxis.planning.models.SourcePlan`	class
`chronaxis.planning.models.SignalPlan`	class
`chronaxis.planning.models.DerivedPlan`	class
`chronaxis.planning.models.RulePlan`	class
`chronaxis.planning.models.RulePlan.__post_init__`	function
`chronaxis.planning.models.RulePlan.temporal_rule_type`	function
`chronaxis.planning.models.RulePlan.expressions`	function
`chronaxis.planning.models.RulePlan.dependencies`	function
`chronaxis.planning.models.WindowPlan`	class
`chronaxis.planning.models.CalculationPlan`	class
`chronaxis.planning.models.LegacyMessageSelector`	class
`chronaxis.planning.models.LegacyMessageSelector.__post_init__`	function
`chronaxis.planning.models.MessageCalculationPlan`	class
`chronaxis.planning.models.MessageCalculationPlan.__post_init__`	function
`chronaxis.planning.models.ExecutionPlan`	class
`chronaxis.planning.models.OutputPlan`	class
`chronaxis.planning.nodes.expression_at`	function
`chronaxis.planning.nodes.register_id`	function
`chronaxis.planning.nodes.parse_rules`	function
`chronaxis.planning.nodes.parse_windows`	function
`chronaxis.planning.nodes.parse_calculations`	function
`chronaxis.planning.plan.AnalysisPlan`	class
`chronaxis.planning.plan.AnalysisPlan.__post_init__`	function
`chronaxis.planning.plan.AnalysisPlan.extensions`	function
`chronaxis.planning.plan.AnalysisPlan.lookups`	function
`chronaxis.planning.plan.AnalysisPlan.from_dict`	function
`chronaxis.planning.plan.load_analysis_plan`	function
`chronaxis.planning.preset_models.RoleContract`	class
`chronaxis.planning.preset_models.PresetSpec`	class
`chronaxis.planning.preset_models.PresetSpec.__post_init__`	function
`chronaxis.planning.preset_models.PresetSpec.from_dict`	function
`chronaxis.planning.preset_models.RoleBinding`	class
`chronaxis.planning.preset_models.PresetRule`	class
`chronaxis.planning.preset_models.PresetCalculation`	class
`chronaxis.planning.preset_models.PlanFragment`	class
`chronaxis.planning.preset_models.PlanFragment.to_dict`	function
`chronaxis.planning.process_execution.process_execution_errors`	function
`chronaxis.planning.process_execution.source_execution_facts`	function
`chronaxis.planning.record_execution.is_event_duration`	function
`chronaxis.planning.record_execution.record_execution_errors`	function
`chronaxis.planning.reports.ValidationReport`	class
`chronaxis.planning.reports.ExplainNode`	class
`chronaxis.planning.reports.ExplainReport`	class
`chronaxis.planning.reports._window_available`	function
`chronaxis.planning.reports._can_source_available`	function
`chronaxis.planning.reports._static_errors`	function
`chronaxis.planning.reports._extension_backend_errors`	function
`chronaxis.planning.reports.validate_analysis_plan`	function
`chronaxis.planning.reports.explain_analysis_plan`	function
`chronaxis.planning.sequences.SequencePlan`	class
`chronaxis.planning.sequences.SequencePlan.__post_init__`	function
`chronaxis.planning.sequences.sequence_dependencies`	function
`chronaxis.planning.sequences.parse_sequences`	function
`chronaxis.planning.signal_groups.signal_entries`	function
`chronaxis.planning.signal_groups.declared_signals`	function
`chronaxis.planning.signal_validity.triple_period`	function
`chronaxis.planning.signal_validity.declared_valid_for`	function
`chronaxis.planning.text_inputs.parse_text_source`	function
`chronaxis.planning.transforms.TemporalTransformPlan`	class
`chronaxis.planning.transforms._names`	function
`chronaxis.planning.transforms.build_transforms`	function
`chronaxis.planning.transforms.build_transforms.visit`	function
`chronaxis.planning.transforms.active_transforms`	function
`chronaxis.planning.transforms.physical_dependencies`	function
`chronaxis.presets._parameters`	function
`chronaxis.presets._mismatches`	function
`chronaxis.presets.resolve_preset_roles`	function
`chronaxis.presets.build_preset`	function
`chronaxis.presets.expand_presets`	function
`chronaxis.process_capabilities._pidfd_group_capability`	function
`chronaxis.process_capabilities.managed_worker_warnings`	function
`chronaxis.process_capabilities.warn_managed_worker`	function
`chronaxis.results.__getattr__`	function
`chronaxis.results.aggregation_row.SummaryAggregationRow`	class
`chronaxis.results.aggregation_row.SummaryAggregationRow.__post_init__`	function
`chronaxis.results.analysis_outcome.RuleOutcome`	class
`chronaxis.results.analysis_outcome.RuleOutcome.__post_init__`	function
`chronaxis.results.analysis_outcome.RuleOutcome.to_dict`	function
`chronaxis.results.analysis_outcome.AnalysisOutcome`	class
`chronaxis.results.analysis_outcome.AnalysisOutcome.__post_init__`	function
`chronaxis.results.analysis_outcome.AnalysisOutcome.to_dict`	function
`chronaxis.results.artifact_exports.ArtifactExportStore`	class
`chronaxis.results.artifact_exports.ArtifactExportStore.__init__`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.closed`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.owned_ram`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.next_path`	function
`chronaxis.results.artifact_exports.ArtifactExportStore._close_slot`	function
`chronaxis.results.artifact_exports.ArtifactExportStore._identity`	function
`chronaxis.results.artifact_exports.ArtifactExportStore._file`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.append`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.seal`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.copy_to`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.recover_copy`	function
`chronaxis.results.artifact_exports.ArtifactExportStore.close`	function
`chronaxis.results.binding_metadata.PresetRoleMetadata`	class
`chronaxis.results.binding_metadata.PresetRoleMetadata.__post_init__`	function
`chronaxis.results.binding_metadata.PresetBindingMetadata`	class
`chronaxis.results.binding_metadata.PresetBindingMetadata.__post_init__`	function
`chronaxis.results.blf_writer.BLFWrite`	class
`chronaxis.results.blf_writer.BLFWrite.__init__`	function
`chronaxis.results.blf_writer.BLFWrite.closed`	function
`chronaxis.results.blf_writer.BLFWrite.write`	function
`chronaxis.results.blf_writer.BLFWrite.finish`	function
`chronaxis.results.blf_writer.BLFWrite.close`	function
`chronaxis.results.budget._reserve_owned_ram`	function
`chronaxis.results.budget._release_owned_ram`	function
`chronaxis.results.budget._cleanup_owner`	function
`chronaxis.results.budget.ResourceBudget`	class
`chronaxis.results.budget.ResourceBudget.__init__`	function
`chronaxis.results.budget.ResourceBudget.reserve_ram`	function
`chronaxis.results.budget.ResourceBudget.release_ram`	function
`chronaxis.results.budget.ResourceBudget.reserve_spool`	function
`chronaxis.results.budget.ResourceBudget._amount`	function
`chronaxis.results.budget.ResourceBudget.snapshot`	function
`chronaxis.results.can_metadata._integer`	function
`chronaxis.results.can_metadata._sha256`	function
`chronaxis.results.can_metadata._pairs`	function
`chronaxis.results.can_metadata.CANUnitCheck`	class
`chronaxis.results.can_metadata.CANUnitCheck.__post_init__`	function
`chronaxis.results.can_metadata.CANFrameFormatNotice`	class
`chronaxis.results.can_metadata.CANFrameFormatNotice.__post_init__`	function
`chronaxis.results.can_metadata.CANSourceMetadata`	class
`chronaxis.results.can_metadata.CANSourceMetadata.__post_init__`	function
`chronaxis.results.codec._pack`	function
`chronaxis.results.codec._unpack`	function
`chronaxis.results.codec._unique_object`	function
`chronaxis.results.codec._reject_constant`	function
`chronaxis.results.codec.estimate_row_bytes`	function
`chronaxis.results.codec._estimate`	function
`chronaxis.results.codec.encode_row`	function
`chronaxis.results.codec.decode_row`	function
`chronaxis.results.errors.AnalysisError`	class
`chronaxis.results.errors.BudgetExceededError`	class
`chronaxis.results.errors.ResultClosedError`	class
`chronaxis.results.errors.ResultFormatError`	class
`chronaxis.results.errors.ContributionsUnavailableError`	class
`chronaxis.results.export_files.ExportFiles`	class
`chronaxis.results.export_files.ExportFiles.__init__`	function
`chronaxis.results.export_files.ExportFiles.closed`	function
`chronaxis.results.export_files.ExportFiles.open_file`	function
`chronaxis.results.export_files.ExportFiles.select_file`	function
`chronaxis.results.export_files.ExportFiles.append`	function
`chronaxis.results.export_files.ExportFiles.close_file`	function
`chronaxis.results.export_files.ExportFiles.close_reader`	function
`chronaxis.results.export_files.ExportFiles.close_files`	function
`chronaxis.results.export_files.ExportFiles.register_external`	function
`chronaxis.results.export_files.ExportFiles.finish`	function
`chronaxis.results.export_files.ExportFiles.close`	function
`chronaxis.results.export_files.ExportFiles._cleanup_failed_output`	function
`chronaxis.results.frame_exports.FrameExportSpec`	class
`chronaxis.results.frame_exports.FrameExportSpec.__post_init__`	function
`chronaxis.results.frame_exports.FrameExportSpec.date_origin_ns`	function
`chronaxis.results.frame_exports.ExportCANFrame`	class
`chronaxis.results.frame_exports.ExportCANFrame.__post_init__`	function
`chronaxis.results.frame_exports.SkippedCANFrame`	class
`chronaxis.results.frame_exports.SkippedCANFrame.__post_init__`	function
`chronaxis.results.frame_exports.as_export_frame`	function
`chronaxis.results.frame_exports._asc_line`	function
`chronaxis.results.frame_exports.export_can_frames`	function
`chronaxis.results.frame_patch.FrameRebuildRule`	class
`chronaxis.results.frame_patch.FrameRebuildRule.__post_init__`	function
`chronaxis.results.frame_patch.FrameRebuildRule.matches`	function
`chronaxis.results.frame_patch.DBCFramePatch`	class
`chronaxis.results.frame_patch.DBCFramePatch.__init__`	function
`chronaxis.results.frame_patch.DBCFramePatch.accept_frame`	function
`chronaxis.results.frame_patch.DBCFramePatch.selected`	function
`chronaxis.results.frame_patch.DBCFramePatch.patch`	function
`chronaxis.results.frame_patch.DBCFramePatch.close`	function
`chronaxis.results.frame_rebuild.FrameSample`	class
`chronaxis.results.frame_rebuild.FrameSample.__post_init__`	function
`chronaxis.results.frame_rebuild.FrameGridSpec`	class
`chronaxis.results.frame_rebuild.FrameGridSpec.__post_init__`	function
`chronaxis.results.frame_rebuild._frame_packet`	function
`chronaxis.results.frame_rebuild._restore_frame`	function
`chronaxis.results.frame_rebuild._sample_packet`	function
`chronaxis.results.frame_rebuild._restore_sample`	function
`chronaxis.results.frame_rebuild._facts`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead`	class
`chronaxis.results.frame_rebuild.FrameRebuildRead.__init__`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._cancel`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._output`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead.prepare`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._group`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._reason`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._skip`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._emit`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._nearest`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._segment`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead.__iter__`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead.export_metadata`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead.__next__`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead._close_input`	function
`chronaxis.results.frame_rebuild.FrameRebuildRead.close`	function
`chronaxis.results.frame_sort.FrameSort`	class
`chronaxis.results.frame_sort.FrameSort.__init__`	function
`chronaxis.results.frame_sort.FrameSort._check`	function
`chronaxis.results.frame_sort.FrameSort._open`	function
`chronaxis.results.frame_sort.FrameSort._close_file`	function
`chronaxis.results.frame_sort.FrameSort._mac`	function
`chronaxis.results.frame_sort.FrameSort._write`	function
`chronaxis.results.frame_sort.FrameSort._read`	function
`chronaxis.results.frame_sort.FrameSort.append`	function
`chronaxis.results.frame_sort.FrameSort._flush`	function
`chronaxis.results.frame_sort.FrameSort._merge`	function
`chronaxis.results.frame_sort.FrameSort.seal`	function
`chronaxis.results.frame_sort.FrameSort.rows`	function
`chronaxis.results.frame_sort.FrameSort.close`	function
`chronaxis.results.input_diagnostics.InputDiagnostic`	class
`chronaxis.results.input_diagnostics.InputDiagnostic.__post_init__`	function
`chronaxis.results.input_diagnostics.InputDiagnostic.to_dict`	function
`chronaxis.results.manifest.RunMetadata`	class
`chronaxis.results.manifest.RunMetadata.__post_init__`	function
`chronaxis.results.manifest.RunMetadata.estimated_bytes`	function
`chronaxis.results.manifest.RunMetadata.to_dict`	function
`chronaxis.results.manifest._metadata_size`	function
`chronaxis.results.manifest.OutputManifest`	class
`chronaxis.results.manifest.OutputManifest.__post_init__`	function
`chronaxis.results.manifest.ExportManifest`	class
`chronaxis.results.manifest.ExportManifest.__post_init__`	function
`chronaxis.results.merge_runs._MergeResources`	class
`chronaxis.results.merge_runs._MergeResources.__init__`	function
`chronaxis.results.merge_runs._MergeResources.open`	function
`chronaxis.results.merge_runs._MergeResources._close_slot`	function
`chronaxis.results.merge_runs._MergeResources.close`	function
`chronaxis.results.merge_runs.merge_runs`	function
`chronaxis.results.owned_directory.directory_identity`	function
`chronaxis.results.owned_directory.remove_owned_directory`	function
`chronaxis.results.platform_files._linux_rename`	function
`chronaxis.results.platform_files.require_publication_platform`	function
`chronaxis.results.platform_files._DirectoryHandles`	class
`chronaxis.results.platform_files._DirectoryHandles.__init__`	function
`chronaxis.results.platform_files._DirectoryHandles.closed`	function
`chronaxis.results.platform_files._DirectoryHandles.open`	function
`chronaxis.results.platform_files._DirectoryHandles.close`	function
`chronaxis.results.platform_files.move_no_replace`	function
`chronaxis.results.publication.output_root`	function
`chronaxis.results.publication._identity`	function
`chronaxis.results.publication.PublicationNames`	class
`chronaxis.results.publication.PublicationNames.__init__`	function
`chronaxis.results.publication.PublicationNames.publish`	function
`chronaxis.results.publication.PublicationNames.close`	function
`chronaxis.results.raw_exports._integer`	function
`chronaxis.results.raw_exports._text`	function
`chronaxis.results.raw_exports._interval`	function
`chronaxis.results.raw_exports._packet`	function
`chronaxis.results.raw_exports.RawExportRecord`	class
`chronaxis.results.raw_exports.RawExportRecord.__post_init__`	function
`chronaxis.results.raw_exports._decode`	function
`chronaxis.results.raw_exports._write_all`	function
`chronaxis.results.raw_exports.RawExportStore`	class
`chronaxis.results.raw_exports.RawExportStore.__init__`	function
`chronaxis.results.raw_exports.RawExportStore.closed`	function
`chronaxis.results.raw_exports.RawExportStore.spool_bytes`	function
`chronaxis.results.raw_exports.RawExportStore._require`	function
`chronaxis.results.raw_exports.RawExportStore._fail`	function
`chronaxis.results.raw_exports.RawExportStore.next_path`	function
`chronaxis.results.raw_exports.RawExportStore._relation`	function
`chronaxis.results.raw_exports.RawExportStore._close_fd`	function
`chronaxis.results.raw_exports.RawExportStore._file`	function
`chronaxis.results.raw_exports.RawExportStore._check_copy`	function
`chronaxis.results.raw_exports.RawExportStore.append`	function
`chronaxis.results.raw_exports.RawExportStore.seal`	function
`chronaxis.results.raw_exports.RawExportStore.iter_records`	function
`chronaxis.results.raw_exports.RawExportStore.copy_to`	function
`chronaxis.results.raw_exports.RawExportStore.recover_copy`	function
`chronaxis.results.raw_exports.RawExportStore._close_copy_resources`	function
`chronaxis.results.raw_exports.RawExportStore.close`	function
`chronaxis.results.raw_exports._RawExportReader`	class
`chronaxis.results.raw_exports._RawExportReader.__init__`	function
`chronaxis.results.raw_exports._RawExportReader.__iter__`	function
`chronaxis.results.raw_exports._RawExportReader.__next__`	function
`chronaxis.results.raw_exports._RawExportReader.close`	function
`chronaxis.results.readable._json`	function
`chronaxis.results.readable.ReadableWriter`	class
`chronaxis.results.readable.ReadableWriter.__init__`	function
`chronaxis.results.readable.ReadableWriter._execute`	function
`chronaxis.results.readable.ReadableWriter._reader`	function
`chronaxis.results.readable.ReadableWriter._output`	function
`chronaxis.results.readable.ReadableWriter._rows`	function
`chronaxis.results.readable.ReadableWriter.prepare`	function
`chronaxis.results.readable.ReadableWriter._number`	function
`chronaxis.results.readable.ReadableWriter._metric_columns`	function
`chronaxis.results.readable.ReadableWriter._metric_values`	function
`chronaxis.results.readable.ReadableWriter._base`	function
`chronaxis.results.readable.ReadableWriter._write`	function
`chronaxis.results.readable.ReadableWriter._write_owned_rows`	function
`chronaxis.results.readable.ReadableWriter.write`	function
`chronaxis.results.readable.ReadableWriter._detail_rows`	function
`chronaxis.results.readable.ReadableWriter._main_rows`	function
`chronaxis.results.readable.ReadableWriter.presentation`	function
`chronaxis.results.readable.ReadableWriter.close`	function
`chronaxis.results.readable_format.seconds`	function
`chronaxis.results.readable_format.quality_text`	function
`chronaxis.results.readable_format.explanation`	function
`chronaxis.results.readable_format.outcome_messages`	function
`chronaxis.results.result._json`	function
`chronaxis.results.result._row_fields`	function
`chronaxis.results.result._DigestOutput`	class
`chronaxis.results.result._DigestOutput.__init__`	function
`chronaxis.results.result._DigestOutput.write`	function
`chronaxis.results.result._DigestOutput.info`	function
`chronaxis.results.result._RowIterator`	class
`chronaxis.results.result._RowIterator.__init__`	function
`chronaxis.results.result._RowIterator.__iter__`	function
`chronaxis.results.result._RowIterator.__next__`	function
`chronaxis.results.result._RowIterator.close`	function
`chronaxis.results.result.AnalysisResult`	class
`chronaxis.results.result.AnalysisResult.__init__`	function
`chronaxis.results.result.AnalysisResult._require_open`	function
`chronaxis.results.result.AnalysisResult._manifest`	function
`chronaxis.results.result.AnalysisResult.run_manifest`	function
`chronaxis.results.result.AnalysisResult._write_state`	function
`chronaxis.results.result.AnalysisResult.iter_events`	function
`chronaxis.results.result.AnalysisResult.iter_sequences`	function
`chronaxis.results.result.AnalysisResult.iter_segments`	function
`chronaxis.results.result.AnalysisResult.iter_calculations`	function
`chronaxis.results.result.AnalysisResult.iter_contributions`	function
`chronaxis.results.result.AnalysisResult.iter_aggregations`	function
`chronaxis.results.result.AnalysisResult.iter_selections`	function
`chronaxis.results.result.AnalysisResult.iter_input_trace`	function
`chronaxis.results.result.AnalysisResult.contributions_available`	function
`chronaxis.results.result.AnalysisResult._write_table`	function
`chronaxis.results.result.AnalysisResult._file_info`	function
`chronaxis.results.result.AnalysisResult._install_directory`	function
`chronaxis.results.result.AnalysisResult.write`	function
`chronaxis.results.result.AnalysisResult.close`	function
`chronaxis.results.result.AnalysisResult.__enter__`	function
`chronaxis.results.result.AnalysisResult.__exit__`	function
`chronaxis.results.rows.row_table`	function
`chronaxis.results.rows.row_sort_key`	function
`chronaxis.results.signal_exports.SignalCSVExportSpec`	class
`chronaxis.results.signal_exports.SignalCSVExportSpec.__post_init__`	function
`chronaxis.results.signal_exports._csv_bytes`	function
`chronaxis.results.signal_exports._sample_row`	function
`chronaxis.results.signal_exports._reference_json`	function
`chronaxis.results.signal_exports._write_grid`	function
`chronaxis.results.signal_exports.SignalCSVWriter`	class
`chronaxis.results.signal_exports.SignalCSVWriter.__init__`	function
`chronaxis.results.signal_exports.SignalCSVWriter.push`	function
`chronaxis.results.signal_exports.SignalCSVWriter.observed_end`	function
`chronaxis.results.signal_exports.SignalCSVWriter.complete`	function
`chronaxis.results.signal_exports.export_signal_csv`	function
`chronaxis.results.signal_grid.SignalGridSpec`	class
`chronaxis.results.signal_grid.SignalGridSpec.__post_init__`	function
`chronaxis.results.signal_grid.GridRow`	class
`chronaxis.results.signal_grid._same_fact`	function
`chronaxis.results.signal_grid.SignalGrid`	class
`chronaxis.results.signal_grid.SignalGrid.__init__`	function
`chronaxis.results.signal_grid.SignalGrid._row`	function
`chronaxis.results.signal_grid.SignalGrid._until`	function
`chronaxis.results.signal_grid.SignalGrid._resolve`	function
`chronaxis.results.signal_grid.SignalGrid.push`	function
`chronaxis.results.signal_grid.SignalGrid.finish`	function
`chronaxis.results.signal_grid.SignalGrid.close`	function
`chronaxis.results.spool._buffer_key`	function
`chronaxis.results.spool.ResultSpool`	class
`chronaxis.results.spool.ResultSpool.__init__`	function
`chronaxis.results.spool.ResultSpool._require_building`	function
`chronaxis.results.spool.ResultSpool.row_limit`	function
`chronaxis.results.spool.ResultSpool.reader_cost_for`	function
`chronaxis.results.spool.ResultSpool.append`	function
`chronaxis.results.spool.ResultSpool._append_core`	function
`chronaxis.results.spool.ResultSpool._run_path`	function
`chronaxis.results.spool.ResultSpool._write_bytes`	function
`chronaxis.results.spool.ResultSpool._clear_buffer`	function
`chronaxis.results.spool.ResultSpool._flush`	function
`chronaxis.results.spool.ResultSpool._read_entry`	function
`chronaxis.results.spool.ResultSpool._merge`	function
`chronaxis.results.spool.ResultSpool.seal`	function
`chronaxis.results.spool.ResultSpool._seal_table`	function
`chronaxis.results.spool.ResultSpool._fail`	function
`chronaxis.results.spool.ResultSpool.close`	function
`chronaxis.results.summary.SummaryCalculationRow`	class
`chronaxis.results.summary.SummaryCalculationRow.__post_init__`	function
`chronaxis.results.summary.SummaryHostedCalculationRow`	class
`chronaxis.results.summary.SummaryHostedCalculationRow.__post_init__`	function
`chronaxis.results.summary.SummaryCoverageCalculationRow`	class
`chronaxis.results.summary.SummaryCoverageCalculationRow.__post_init__`	function
`chronaxis.results.summary._require_row_identity`	function
`chronaxis.results.summary.SummaryEventRow`	class
`chronaxis.results.summary.SummaryEventRow.__post_init__`	function
`chronaxis.results.summary.SummarySequenceRow`	class
`chronaxis.results.summary.SummarySequenceRow.__post_init__`	function
`chronaxis.results.summary.SummarySegmentRow`	class
`chronaxis.results.summary.SummarySegmentRow.__post_init__`	function
`chronaxis.results.summary.SummaryContributionRow`	class
`chronaxis.results.summary.SummaryContributionRow.__post_init__`	function
`chronaxis.results.summary.SummaryInputRow`	class
`chronaxis.results.summary.SummaryInputRow.__post_init__`	function
`chronaxis.results.summary.SummarySelectionRow`	class
`chronaxis.results.summary.SummarySelectionRow.__post_init__`	function
`chronaxis.results.summary.summary_fields`	function
`chronaxis.results.text_can_metadata.TextCANSourceMetadata`	class
`chronaxis.results.text_can_metadata.TextCANSourceMetadata.__post_init__`	function
`chronaxis.results.threshold_metadata.ThresholdDurationMetadata`	class
`chronaxis.results.threshold_metadata.ThresholdDurationMetadata.__post_init__`	function
`chronaxis.results.threshold_metadata.ThresholdDurationMetadata.observed_duration_ns`	function
`chronaxis.results.threshold_metadata.ThresholdDurationMetadata.unknown_duration_ns`	function
`chronaxis.results.threshold_metadata.ThresholdDurationMetadata.total_duration_ns`	function
`chronaxis.results.threshold_metadata.ThresholdDurationMetadata.status`	function
`chronaxis.results.threshold_metadata.ThresholdDurationMetadata.to_dict`	function
`chronaxis.results.threshold_metadata.SummaryThresholdDuration`	class
`chronaxis.results.threshold_metadata.SummaryThresholdDuration.__post_init__`	function
`chronaxis.results.threshold_metadata.SummaryThresholdDuration.to_dict`	function
`chronaxis.runner.AnalysisRunner`	class
`chronaxis.runner.AnalysisRunner.__init__`	function
`chronaxis.runner.AnalysisRunner.backend`	function
`chronaxis.runner.AnalysisRunner._effective_plan`	function
`chronaxis.runner.AnalysisRunner.validate`	function
`chronaxis.runner.AnalysisRunner.explain`	function
`chronaxis.runner.AnalysisRunner.run`	function
`chronaxis.sources.__getattr__`	function
`chronaxis.sources.asc.ASCSpec`	class
`chronaxis.sources.asc.ASCSpec.__post_init__`	function
`chronaxis.sources.asc._date`	function
`chronaxis.sources.asc._unsigned`	function
`chronaxis.sources.asc._status_event`	function
`chronaxis.sources.asc._fd_error_diagnostics`	function
`chronaxis.sources.asc._error_diagnostics`	function
`chronaxis.sources.asc._frame`	function
`chronaxis.sources.asc._repository_frame`	function
`chronaxis.sources.asc.ASCRead`	class
`chronaxis.sources.asc.ASCRead.__init__`	function
`chronaxis.sources.asc.ASCRead.closed`	function
`chronaxis.sources.asc.ASCRead.last_exact_time`	function
`chronaxis.sources.asc.ASCRead.__iter__`	function
`chronaxis.sources.asc.ASCRead._set_date`	function
`chronaxis.sources.asc.ASCRead._line`	function
`chronaxis.sources.asc.ASCRead._check_order`	function
`chronaxis.sources.asc.ASCRead.__next__`	function
`chronaxis.sources.asc.ASCRead.close`	function
`chronaxis.sources.asc.ASCRead.__enter__`	function
`chronaxis.sources.asc.ASCRead.__exit__`	function
`chronaxis.sources.blf.BLFSpec`	class
`chronaxis.sources.blf.BLFSpec.__post_init__`	function
`chronaxis.sources.blf.BLFRead`	class
`chronaxis.sources.blf.BLFRead.__init__`	function
`chronaxis.sources.blf.BLFRead.closed`	function
`chronaxis.sources.blf.BLFRead.__iter__`	function
`chronaxis.sources.blf.BLFRead.__next__`	function
`chronaxis.sources.blf.BLFRead.close`	function
`chronaxis.sources.blf._UntimedBLFRecord`	class
`chronaxis.sources.can_spec._nonnegative_integer`	function
`chronaxis.sources.can_spec.can_field_from_key`	function
`chronaxis.sources.can_spec.LegacyCANSpec`	class
`chronaxis.sources.can_spec.LegacyCANSpec.input_paths`	function
`chronaxis.sources.can_spec.LegacyCANSpec.__post_init__`	function
`chronaxis.sources.can_spec.CANSourceRef`	class
`chronaxis.sources.can_spec.CANSourceRef.__post_init__`	function
`chronaxis.sources.can_spec.CANSourceRef.evaluation_index`	function
`chronaxis.sources.can_updates.require_message_keys`	function
`chronaxis.sources.can_updates.CANUpdateProjection`	class
`chronaxis.sources.can_updates.CANUpdateProjection.__init__`	function
`chronaxis.sources.can_updates.CANUpdateProjection.configure_metadata`	function
`chronaxis.sources.can_updates.CANUpdateProjection.for_read`	function
`chronaxis.sources.can_updates.CANUpdateProjection._matching`	function
`chronaxis.sources.can_updates.CANUpdateProjection.accepts_frame`	function
`chronaxis.sources.can_updates.CANUpdateProjection.fields_for`	function
`chronaxis.sources.can_updates.CANUpdateProjection._canonical_key`	function
`chronaxis.sources.can_updates.CANUpdateProjection.build`	function
`chronaxis.sources.csv_spec.SignalCSVSpec`	class
`chronaxis.sources.csv_spec.SignalCSVSpec.__post_init__`	function
`chronaxis.sources.csv_spec.CSVSourceRef`	class
`chronaxis.sources.csv_spec.CSVSourceRef.__post_init__`	function
`chronaxis.sources.descriptions.source_timebase_identity`	function
`chronaxis.sources.descriptions.describe_fields`	function
`chronaxis.sources.memory.MemorySourceAdapter`	class
`chronaxis.sources.memory.MemorySourceAdapter.__init__`	function
`chronaxis.sources.memory.MemorySourceAdapter._ensure_open`	function
`chronaxis.sources.memory.MemorySourceAdapter.describe`	function
`chronaxis.sources.memory.MemorySourceAdapter.iter_batches`	function
`chronaxis.sources.memory.MemorySourceAdapter.iter_batches.iterate`	function
`chronaxis.sources.memory.MemorySourceAdapter._iterate`	function
`chronaxis.sources.memory.MemorySourceAdapter._make_batch`	function
`chronaxis.sources.memory.MemorySourceAdapter.close`	function
`chronaxis.sources.models.freeze_metadata`	function
`chronaxis.sources.models.FieldLocation`	class
`chronaxis.sources.models.FieldLocation.__post_init__`	function
`chronaxis.sources.models.FieldDescription`	class
`chronaxis.sources.models.FieldDescription.__post_init__`	function
`chronaxis.sources.models.SourceCapabilities`	class
`chronaxis.sources.models.SourceCapabilities.__post_init__`	function
`chronaxis.sources.models.SourceDescription`	class
`chronaxis.sources.models.SourceDescription.__post_init__`	function
`chronaxis.sources.models.ReadRequest`	class
`chronaxis.sources.models.ReadRequest.__post_init__`	function
`chronaxis.sources.models.SignalSeries`	class
`chronaxis.sources.models.SignalSeries.__post_init__`	function
`chronaxis.sources.models.SignalSeries.nbytes`	function
`chronaxis.sources.models.SignalBatch`	class
`chronaxis.sources.models.SignalBatch.__post_init__`	function
`chronaxis.sources.models.SignalBatch.sample_count`	function
`chronaxis.sources.packing._pack_numeric_columns`	function
`chronaxis.sources.packing.pack_message_values`	function
`chronaxis.sources.packing.pack_decoded`	function
`chronaxis.sources.protocol.SourceClosedError`	class
`chronaxis.sources.protocol.SourceReadError`	class
`chronaxis.sources.protocol.SourceAdapter`	class
`chronaxis.sources.protocol.SourceAdapter.describe`	function
`chronaxis.sources.protocol.SourceAdapter.iter_batches`	function
`chronaxis.sources.protocol.SourceAdapter.close`	function
`chronaxis.sources.protocol.BatchValidator`	class
`chronaxis.sources.protocol.BatchValidator.__init__`	function
`chronaxis.sources.protocol.BatchValidator.accept`	function
`chronaxis.sources.raw_can.CANTextError`	class
`chronaxis.sources.raw_can.CANTextError.__init__`	function
`chronaxis.sources.raw_can.RawCANRecord`	class
`chronaxis.sources.raw_can.RawCANRecord.__post_init__`	function
`chronaxis.sources.raw_csv.CSVTimeSpec`	class
`chronaxis.sources.raw_csv.CSVTimeSpec.__post_init__`	function
`chronaxis.sources.raw_csv.CANCSVSpec`	class
`chronaxis.sources.raw_csv.CANCSVSpec.__post_init__`	function
`chronaxis.sources.raw_csv._uint`	function
`chronaxis.sources.raw_csv._payload`	function
`chronaxis.sources.raw_csv.CSVClock`	class
`chronaxis.sources.raw_csv.CSVClock.__init__`	function
`chronaxis.sources.raw_csv.CSVClock.parse`	function
`chronaxis.sources.raw_csv._csv_frame`	function
`chronaxis.sources.raw_csv._CSVLines`	class
`chronaxis.sources.raw_csv._CSVLines.__init__`	function
`chronaxis.sources.raw_csv._CSVLines.__iter__`	function
`chronaxis.sources.raw_csv._CSVLines.__next__`	function
`chronaxis.sources.raw_csv.CANCSVRead`	class
`chronaxis.sources.raw_csv.CANCSVRead.__init__`	function
`chronaxis.sources.raw_csv.CANCSVRead.closed`	function
`chronaxis.sources.raw_csv.CANCSVRead.__iter__`	function
`chronaxis.sources.raw_csv.CANCSVRead._next_row`	function
`chronaxis.sources.raw_csv.CANCSVRead._initialize`	function
`chronaxis.sources.raw_csv.CANCSVRead.__next__`	function
`chronaxis.sources.raw_csv.CANCSVRead.close`	function
`chronaxis.sources.raw_csv.CANCSVRead.__enter__`	function
`chronaxis.sources.raw_csv.CANCSVRead.__exit__`	function
`chronaxis.sources.raw_csv_layout._scalar`	function
`chronaxis.sources.raw_csv_layout._fields`	function
`chronaxis.sources.raw_csv_layout._physical_value`	function
`chronaxis.sources.raw_csv_layout._common_value`	function
`chronaxis.sources.raw_csv_layout.ColumnMapping`	class
`chronaxis.sources.raw_csv_layout.ColumnMapping.__post_init__`	function
`chronaxis.sources.raw_csv_layout.ColumnMapping.from_dict`	function
`chronaxis.sources.raw_csv_layout.ColumnMapping.to_dict`	function
`chronaxis.sources.raw_csv_layout.CANCSVLayout`	class
`chronaxis.sources.raw_csv_layout.CANCSVLayout.__post_init__`	function
`chronaxis.sources.raw_csv_layout.CANCSVLayout.from_dict`	function
`chronaxis.sources.raw_csv_layout.CANCSVLayout.to_dict`	function
`chronaxis.sources.raw_csv_layout.CANCSVLayout.bind_header`	function
`chronaxis.sources.raw_csv_layout.BoundCANCSVLayout`	class
`chronaxis.sources.raw_csv_layout.BoundCANCSVLayout.__post_init__`	function
`chronaxis.sources.raw_csv_layout.BoundCANCSVLayout.map_row`	function
`chronaxis.sources.signal_csv.choice_text`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter`	class
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter.__init__`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._ensure_open`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter.describe`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter.iter_batches`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._request_batches`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._request_batches.iterate`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._parse_value`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._close_handle`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._read_resources`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._iterate`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter._make_batch`	function
`chronaxis.sources.signal_csv.SignalCSVSourceAdapter.close`	function
`chronaxis.sources.text_can_decode.DecodedCANRecord`	class
`chronaxis.sources.text_can_decode.DecodedCANRecord.__post_init__`	function
`chronaxis.sources.text_can_decode.DecodedCANRecord._from_bound_values`	function
`chronaxis.sources.text_can_decode.DecodedCANRecord._validate`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead`	class
`chronaxis.sources.text_can_decode.CANTextDecodeRead.__init__`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.closed`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.exhausted`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.metadata`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.prepare_metadata`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead._start`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead._decode`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.__iter__`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead._time_selected`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.__next__`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead._blf_observation`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.close`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.__enter__`	function
`chronaxis.sources.text_can_decode.CANTextDecodeRead.__exit__`	function
`chronaxis.sources.text_can_decode.pack_text_records`	function
`chronaxis.sources.text_can_ref.CANTextSourceRef`	class
`chronaxis.sources.text_can_ref.CANTextSourceRef.__post_init__`	function
`chronaxis.sources.text_can_spec.CANTextSpec`	class
`chronaxis.sources.text_can_spec.CANTextSpec.__post_init__`	function
`chronaxis.sources.text_can_spec.CANTextSpec.source_type`	function
`chronaxis.sources.text_can_spec.CANTextSpec.offset_ns`	function
`chronaxis.timebase.conversion.TimeOverflowError`	class
`chronaxis.timebase.conversion.TimeConversion`	class
`chronaxis.timebase.conversion.require_int64_ns`	function
`chronaxis.timebase.conversion._decimal_input`	function
`chronaxis.timebase.conversion.convert_time`	function
`chronaxis.timebase.conversion.parse_duration`	function
`chronaxis.timebase.conversion.parse_datetime_ns`	function
`chronaxis.timebase.conversion.checked_add_ns`	function
`chronaxis.timebase.conversion.shift_times_reference`	function
`chronaxis.timebase.conversion.time_deltas_reference`	function
`chronaxis.timebase.numpy_ops._require_time_array`	function
`chronaxis.timebase.numpy_ops.shift_times_numpy`	function
`chronaxis.timebase.numpy_ops.time_deltas_numpy`	function
`chronaxis.user_guide.guide_path`	function
`chronaxis.user_guide._installed_archive`	function
`chronaxis.user_guide.export_guide`	function