API reference¶
The reference below is generated from the installed eyeprocesspy package. The function-level frozen-R mapping is maintained separately in parity/PARITY_MATRIX.csv.
eyeprocesspy ¶
eyeprocesspy: Python parity implementation of R eyeprocess 0.11.1.
EyeProcessError ¶
Bases: Exception
Base error for eyeprocesspy.
EyeProcessValidationError ¶
Bases: EyeProcessError
Raised when a canonical dataset violates validation contracts.
EyeProcessSchemaError ¶
Bases: EyeProcessError
Raised for canonical schema errors.
EyeProcessTimebaseError ¶
Bases: EyeProcessError
Raised for timebase normalization or alignment errors.
EyeProcessCoordinateError ¶
Bases: EyeProcessError
Raised for coordinate-space errors.
EyeProcessBackendError ¶
Bases: EyeProcessError
Raised when an optional backend is required or fails.
EyeProcessModelError ¶
Bases: EyeProcessError
Raised for modelling failures.
EyeProcessGovernanceError ¶
Bases: EyeProcessError
Raised when an evidence/governance gate is violated.
EyeDataset ¶
Bases: dict
Dict-like Python counterpart of the R eye_dataset list class.
EyeClockTransform
dataclass
¶
EyeAOI
dataclass
¶
Python representation of the R eye_aoi list class.
EyeStorageSpec
dataclass
¶
Python counterpart of the R eye_storage_spec object.
EyeStorage ¶
Bases: dict
Lightweight disk-backed storage handle.
EyePartitionSpec
dataclass
¶
Python counterpart of frozen R eye_partition_spec.
EyePartitionedStorage ¶
Bases: _EyeDict
Disk-backed handle for atomic partitioned eyeprocess storage.
EyeStorageValidation ¶
Bases: _EyeDict
EyePlotSpec ¶
Bases: dict
R-list-like plot specification with stable class metadata.
eye_schema ¶
Return the canonical eyeprocess schema (R eye_schema).
schema_table ¶
Return canonical fields for one schema table.
empty_eye_table ¶
Create an empty canonical table with the R column order.
standardize_eye_table ¶
standardize_eye_table(data: DataFrame, name: str, keep_extra: bool = True, schema: Mapping | None = None) -> pd.DataFrame
Add absent canonical fields and reorder columns like R standardize_eye_table.
validate_eye_table ¶
validate_eye_table(data: DataFrame, name: str, strict: bool = False, schema: Mapping | None = None) -> pd.DataFrame
Return schema-field issues using the R validation table contract.
canonical_table_names ¶
Return canonical table names in frozen R order.
new_coordinate_space ¶
new_coordinate_space(coordinate_space_id, space_type='display_normalized_top_left', origin=None, x_unit=None, y_unit=None, width=np.nan, height=np.nan, reference_object=pd.NA, parent_space_id=pd.NA, transform_to_parent=pd.NA, clipping_policy='retain') -> pd.DataFrame
Create one coordinate-space record using the frozen R defaults.
eye_mapping ¶
eye_mapping(participant=None, recording=None, session=None, timestamp=None, timestamp_device=None, x=None, y=None, z=None, left_x=None, left_y=None, right_x=None, right_y=None, gaze_valid=None, left_valid=None, right_valid=None, confidence=None, pupil_left=None, pupil_right=None, pupil_left_valid=None, pupil_right_valid=None, fixation_id=None, blink_id=None, trial=None, item=None, stimulus=None, condition=None, response=None, score=None, response_time=None, event_name=None, event_value=None, event_type=None, biometric_channels=None, extra=None)
Construct a generic import mapping; None fields are dropped as in R.
new_eye_dataset ¶
new_eye_dataset(recordings=None, streams=None, gaze_samples=None, eye_samples=None, episodes=None, events=None, intervals=None, responses=None, coordinate_spaces=None, aoi_definitions=None, aoi_geometry=None, biometrics=None, calibrations=None, features=None, quality=None, provenance=None, raw=None, vendor_metadata=None, schema_version=SCHEMA_VERSION, validate=True) -> EyeDataset
Construct a canonical dataset preserving R table order and missing-field semantics.
add_provenance ¶
add_provenance(x, action, component=pd.NA, details=pd.NA, source_files=pd.NA, file_hashes=None, software='eyeprocess', software_version=None, reversible=True, warnings=pd.NA)
normalize_timebase ¶
normalize_timebase(x, component=('gaze_samples', 'eye_samples', 'events', 'biometrics'), native_unit=None, origin='recording_start', overwrite=True)
apply_clock_transform ¶
convert_coordinates ¶
convert_coordinates(x, from_, to, components=('gaze_samples', 'episodes', 'aoi_geometry'), clip=False, overwrite=False)
validate_eye_mapping ¶
validate_eye_mapping(mapping: Mapping[str, Any], data: DataFrame | None = None, required=('timestamp', 'x', 'y'))
Validate a generic import mapping (R validate_eye_mapping).
infer_eye_mapping ¶
Infer common eye/process fields using the frozen R candidate order.
read_eye_generic ¶
read_eye_generic(path, mapping=None, delimiter=None, time_unit='seconds', coordinate_space='display_normalized_top_left', screen_width=np.nan, screen_height=np.nan, pupil_unit=pd.NA, vendor='generic', recording_id=None, participant_id=None, session_id='S001', nominal_sampling_rate=np.nan, keep_raw=True, keep_extra=True, encoding='UTF-8', quiet=False, **kwargs)
Import a mapped delimited table into the canonical eyeprocess data contract.
register_eye_adapter ¶
Register a vendor/custom reader using the frozen R adapter contract.
read_eye_folder ¶
is_gazepoint_export ¶
Return Gazepoint format confidence using the frozen 0.11.1 detector.
read_gazepoint ¶
read_gazepoint(path, participant_id=None, recording_id=None, session_id='S001', nominal_sampling_rate=60, screen_width=np.nan, screen_height=np.nan, keep_raw=True, quiet=False, **kwargs)
Import Gazepoint Analysis 7.x samples with frozen 0.11.1 semantics.
read_gazepoint_gaze ¶
Gaze-only public alias retained from R read_gazepoint_gaze.
read_gazepoint_fixations ¶
read_gazepoint_fixations(path, participant_id=None, recording_id=None, session_id='S001', origin_tick=None, keep_raw=True, quiet=False, **kwargs)
read_gazepoint_folder ¶
read_gazepoint_folder(path, include=('gaze', 'fixations', 'events', 'biometrics', 'aoi'), participant_id=None, recording_id=None, session_id='S001', keep_raw=True, recursive=False, quiet=False, **kwargs)
read_gazepoint_biometrics ¶
read_gazepoint_biometrics(path, participant_id=None, recording_id=None, session_id='S001', keep_raw=True, quiet=False, **kwargs)
fit_device_linking ¶
fit_device_linking(x: Any, metric: str, reference_device: str, method: str = 'mixed_bland_altman', device_col: str = 'device', id_cols: Sequence[str] = ('person_id', 'item_id')) -> EyeResult
apply_device_linking ¶
apply_device_linking(x: Any, linking_model: Any, metric: str | None = None, device_col: str | None = None, output_col: str | None = None) -> pd.DataFrame
audit_device_equivalence ¶
audit_device_equivalence(x: Any, equivalence_margin: float, by: Sequence[str] = ('metric', 'task', 'aoi')) -> EyeResult
item_objective_spec ¶
item_objective_spec(information: Any, process_burden: Any, fairness: Any, exposure: Any, content_constraints: Any = None, weights: Mapping[str, float] | None = None, directions: Mapping[str, str] | None = None) -> EyeResult
optimize_item_bank ¶
optimize_item_bank(x: Any, n_items: int, objectives: Any, constraints: Any = None, method: str = 'integer', iterations: int = 500, seed: int = 20260807) -> EyeResult
audit_bank_decision_stability ¶
audit_bank_decision_stability(x: Any, draws: int = 1000, noise_sd: float = 0.1, seed: int = 20260807) -> EyeResult
fit_process_dif ¶
fit_process_dif(x: Any, response: str, process: str, group: str, item: str, ability: str | None = None) -> EyeResult
monitor_dif_drift ¶
monitor_dif_drift(x: Any, time: str, group: str, metrics: Sequence[str], item: str | None = None) -> EyeResult
decompose_dif_evidence ¶
decompose_dif_evidence(psychometric: Any, process: Any = None, design_features: Any = None) -> EyeResult
audit_fairness_transportability ¶
audit_fairness_transportability(x: Any, context: str = 'device', effect: str = 'process_dif', item: str = 'item_id') -> EyeResult
fit_process_norms ¶
fit_process_norms(x: Any, metric: str, covariates: Sequence[str] | str, family: str = 'auto') -> EyeResult
predict_process_centiles ¶
predict_process_centiles(model: Any, newdata: Any, centiles: Sequence[float] = (2.5, 10, 25, 50, 75, 90, 97.5)) -> pd.DataFrame
score_process_deviation ¶
plot_device_bias_by_magnitude ¶
plot_item_pareto ¶
plot_item_pareto(x: Any, x_objective: str = 'information', y_objective: str = 'process_burden', ax=None)
dynamic_irtree_spec ¶
dynamic_irtree_spec(source: str = 'samples', collapse_consecutive: bool = True, engine: str = 'baseline', hidden_states: int = 0, include_response: bool = True, include_person: bool = False, include_item: bool = True, condition_columns: Sequence[str] | None = (), transition_predictors: Sequence[str] | None = (), interactions: Sequence[str] | None = (), include_time_gap: bool = True, person_effect: str = 'none', item_effect: str = 'none', structural_zeros: Any = None, allowed_transitions: Any = None, hidden_structural_zeros: Any = None, hidden_allowed_transitions: Any = None, missing_state: str = 'drop', uncertain_state_probability: str | None = None, misclassification_matrix: Any = None, ridge: float = 0.0001, standardize: bool = True, reference_state: str | None = None, chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, adapt_delta: float = 0.95, max_treedepth: int = 12) -> EyeResult
prepare_dynamic_irtree_data ¶
prepare_dynamic_irtree_data(x: Any, spec: EyeResult | None = None, person: str = 'participant_id', item: str = 'item_id', trial: str = 'trial_id', state: str = 'state', time: str | None = None, from_: str = 'from_state', to: str = 'to_state', states: Sequence[str] | None = None, **kwargs: Any) -> pd.DataFrame
structural_transition_mask ¶
structural_transition_mask(states: Sequence[str], forbidden: Any = None, allowed: Any = None, allow_self: bool = True, structural_zeros: Any = None, allowed_transitions: Any = None) -> pd.DataFrame
dynamic_transition_design ¶
dynamic_transition_design(data: Any, spec: EyeResult | None = None, formula: Any = None) -> EyeResult
fit_multinomial_transition ¶
fit_multinomial_transition(design: EyeResult, ridge: float = 0.0001, reference_state: str | None = None, control: Mapping[str, Any] | None = None) -> EyeResult
fit_dynamic_irtree_stan ¶
fit_dynamic_irtree_stan(design: EyeResult, spec: EyeResult, seed: int = 1, refresh: int = 0, output_dir: str | None = None, **kwargs: Any) -> EyeResult
decode_dynamic_states ¶
dynamic_posterior_predictive_check ¶
transition_residual_diagnostics ¶
compare_dynamic_transition_models ¶
compare_dynamic_transition_models(*models: Any, criterion: str = 'AIC', **named: Any) -> pd.DataFrame
simulate_dynamic_irtree_data ¶
simulate_dynamic_irtree_data(n_person: int = 100, n_item: int = 20, transitions_per_trial: int = 8, states: Sequence[str] = ('prompt', 'evidence', 'options'), beta_response: float = 0.5, person_sd: float = 0.4, item_sd: float = 0.3, irregular_time: bool = True, state_misclassification: float = 0, missing_state: float = 0, structural_zeros: Any = None, seed: int = 1) -> EyeResult
dynamic_irtree_recovery ¶
dynamic_irtree_recovery(grid: Any = None, replications: int = 20, spec: EyeResult | None = None, base_seed: int = 1) -> EyeResult
fit_dynamic_irtree ¶
fit_dynamic_irtree(x: Any, spec: EyeResult | None = None, min_transitions: int = 10, seed: int = 1, **kwargs: Any) -> EyeResult
theory_strategy_spec ¶
theory_strategy_spec(strategies: Any = None, feature_columns: Sequence[str] | None = None, response: str = 'score', participant: str = 'participant_id', item: str = 'item_id', condition: str | None = None, item_availability: Any = None, engine: str = 'em', multiple_starts: int = 10, anchor_strength: float = 3, chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, adapt_delta: float = 0.95, max_treedepth: int = 12, prototypes: Any = None, feature_sd: Any = None, prior: Any = None) -> EyeResult
prepare_strategy_mixture_data ¶
fit_strategy_mixture_em ¶
fit_strategy_mixture_em(prepared: EyeResult, starts: int | None = None, max_iter: int = 300, tolerance: float = 1e-07, seed: int = 1) -> EyeResult
fit_strategy_mixture_stan ¶
fit_strategy_mixture_stan(prepared: EyeResult, seed: int = 1, refresh: int = 0, output_dir: str | None = None, **kwargs: Any) -> EyeResult
fit_theory_strategy_irt ¶
fit_theory_strategy_irt(data: Any, spec: EyeResult, seed: int = 1, response: str | None = None, participant: str | None = None, item: str | None = None, **kwargs: Any) -> EyeResult
strategy_posterior_probabilities ¶
strategy_classification_uncertainty ¶
strategy_label_switching_diagnostics ¶
strategy_aoi_sensitivity ¶
strategy_aoi_sensitivity(datasets: Mapping[str, Any] | Sequence[Any], spec: EyeResult, seed: int = 1, **kwargs: Any) -> EyeResult
validate_strategy_manipulation ¶
validate_strategy_manipulation(object: EyeResult, condition: str, expected_strategy: str, minimum_contrast: float = 0) -> EyeResult
simulate_strategy_mixture_data ¶
simulate_strategy_mixture_data(n_person: int = 100, n_item: int = 20, signatures: Any = None, trials_per_item: int = 1, strategy_prevalence: Any = None, feature_sd: float = 0.6, seed: int = 1) -> pd.DataFrame
gaze_diffusion_spec ¶
gaze_diffusion_spec(response: str = 'score', response_time: str = 'response_time', participant: str = 'participant_id', item: str = 'item_id', drift_features: Sequence[str] = (), boundary_features: Sequence[str] = (), nondecision_features: Sequence[str] = (), starting_features: Sequence[str] = (), censor_column: str | None = None, contaminant: bool = True, engine: str = 'baseline', gaze_features: Sequence[str] | None = None, chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, adapt_delta: float = 0.97, max_treedepth: int = 13) -> EyeResult
prepare_gaze_diffusion_data ¶
fit_gaze_diffusion_stan ¶
fit_gaze_diffusion_stan(prepared: EyeResult, seed: int = 1, refresh: int = 0, output_dir: str | None = None, **kwargs: Any) -> EyeResult
fit_gaze_diffusion_irt ¶
fit_gaze_diffusion_irt(data: Any, spec: EyeResult | None = None, seed: int = 1, **kwargs: Any) -> EyeResult
extract_diffusion_parameters ¶
extract_diffusion_parameters(object: EyeResult, variables: Sequence[str] = ('beta_drift', 'beta_boundary', 'beta_nondecision', 'beta_starting', 'person_drift', 'item_difficulty', 'boundary', 'nondecision', 'starting', 'contaminant_probability')) -> pd.DataFrame
diffusion_parameter_diagnostics ¶
diffusion_parameter_diagnostics(object: EyeResult, correlation_threshold: float = 0.85) -> EyeResult
diffusion_posterior_predictive ¶
diffusion_posterior_predictive(object: EyeResult, draws: int = 200, method: str = 'rtdists', seed: int = 1) -> EyeResult
simulate_gaze_diffusion_data ¶
simulate_gaze_diffusion_data(n_person: int = 80, n_item: int = 20, trials_per_item: int = 1, gaze_effect: float = 0.35, contaminant_fraction: float = 0.02, time_step: float = 0.002, max_decision_time: float = 10, seed: int = 1) -> pd.DataFrame
diffusion_identification_study ¶
diffusion_identification_study(conditions: Any = None, replications: int = 20, base_seed: int = 20260805, spec: EyeResult | None = None) -> EyeResult
irt_response_channel ¶
irt_response_channel(family: str = '2pl', response: str = 'response', latent: str = 'ability', options: Mapping[str, Any] | None = None) -> EyeResult
irt_rt_channel ¶
irt_rt_channel(family: str = 'lognormal', rt: str = 'rt', latent: str = 'speed', options: Mapping[str, Any] | None = None) -> EyeResult
irt_count_channel ¶
irt_count_channel(family: str = 'negative_binomial', value: str = 'fixation_count', latent: str = 'engagement', options: Mapping[str, Any] | None = None) -> EyeResult
irt_survival_channel ¶
irt_survival_channel(family: str = 'cox', time: str = 'time', event: str = 'event', latent: str | None = None, options: Mapping[str, Any] | None = None) -> EyeResult
irt_nominal_channel ¶
irt_nominal_channel(choice: str = 'response_option', categories: Sequence[str] | None = None, latent: str = 'ability', options: Mapping[str, Any] | None = None) -> EyeResult
irt_compositional_channel ¶
irt_compositional_channel(parts: Sequence[str], family: str = 'logratio_gaussian', latent: str = 'process', options: Mapping[str, Any] | None = None) -> EyeResult
irt_sequence_channel ¶
irt_sequence_channel(sequence: str = 'sequence', family: str = 'ngram', latent: str = 'strategy', options: Mapping[str, Any] | None = None) -> EyeResult
irt_functional_channel ¶
irt_functional_channel(value: str = 'pupil', time: str = 'time', family: str = 'basis_gaussian', latent: str = 'process', options: Mapping[str, Any] | None = None) -> EyeResult
irt_continuous_channel ¶
irt_continuous_channel(family: str = 'censored_normal', value: str = 'process_value', lower: float = 0, upper: float = 1, latent: str = 'process', options: Mapping[str, Any] | None = None) -> EyeResult
irt_model_spec ¶
irt_model_spec(id: str, latent: Sequence[str] | str, channels: Mapping[str, Any] | Sequence[Any], status: str = 'experimental', fit_fun: Callable[..., Any] | None = None, simulate_fun: Callable[..., Any] | None = None, validate_fun: Callable[..., Any] | None = None, citation: Sequence[str] = (), description: str | None = None, requirements: Sequence[str] = (), metadata: Mapping[str, Any] | None = None) -> EyeResult
fit_irt_model ¶
fit_irt_model(spec: Any, data: Any, *args: Any, allow_experimental: bool = False, **kwargs: Any) -> Any
simulate_irt_model ¶
compare_irt_models ¶
promote_irt_model ¶
promote_irt_model(spec: Any, evidence: Any, target: str = 'experimental', update_registry: bool = False) -> EyeResult
fit_joint_gaze_rt_irt ¶
fit_joint_gaze_rt_irt(data: Any, response: str = 'response', rt: str = 'rt', gaze: str = 'fixation_count', person: str = 'participant_id', item: str = 'item_id', gaze_family: str = 'negative_binomial', engine: str = 'reference', iter: int = 2000, chains: int = 4, cores: int = 1, seed: int = 1, **kwargs: Any) -> EyeResult
fit_speed_accuracy_engagement_irt ¶
fit_speed_accuracy_engagement_irt(data: Any, *args: Any, engine: str = 'reference', **kwargs: Any) -> EyeResult
fit_joint_graded_rt_process_irt ¶
fit_joint_graded_rt_process_irt(data: Any, response: str = 'response', rt: str = 'rt', process: str = 'fixation_count', person: str = 'participant_id', item: str = 'item_id', engine: str = 'reference', process_family: str = 'negative_binomial', iter: int = 2000, chains: int = 4, cores: int = 1, seed: int = 1, **kwargs: Any) -> EyeResult
fit_nominal_gaze_irt ¶
fit_nominal_gaze_irt(data: Any, response_option: str = 'response_option', option_gaze: Sequence[str] = (), person: str = 'participant_id', item: str = 'item_id', ability: str | None = None, correct_option: Any = None, add_item_effects: bool = True, **kwargs: Any) -> EyeResult
audit_distractor_attention ¶
audit_distractor_attention(data: Any, response_option: str = 'response_option', option_gaze: Sequence[str] = (), chosen_suffix: str | None = None) -> pd.DataFrame
classify_item_missingness ¶
classify_item_missingness(data: Any, response: str = 'response', reached: str = 'reached', inspected: str | None = None, started: str | None = None) -> pd.Categorical
estimate_visual_exposure_probability ¶
estimate_visual_exposure_probability(data: Any, exposed: str = 'reached', predictors: Sequence[str] = (), family: Any = None) -> EyeResult
fit_omission_survival_irt ¶
fit_omission_survival_irt(data: Any, response: str = 'response', response_time: str = 'response_time', omission_time: str | None = None, reached: str = 'reached', person: str = 'participant_id', item: str = 'item_id', gaze_exposure: str | None = None, first_fixation_latency: str | None = None, **kwargs: Any) -> EyeResult
fit_manyfacet_process_irt ¶
fit_manyfacet_process_irt(data: Any, response: str = 'response', process: str | None = None, person: str = 'participant_id', item: str = 'item_id', device: str | None = None, session: str | None = None, site: str | None = None, algorithm: str | None = None, aoi_definition: str | None = None, process_family: str = 'gaussian') -> EyeResult
audit_process_measurement_invariance ¶
audit_process_measurement_invariance(object: Any, channel: str = 'process', relative_sd_threshold: float = 0.25) -> EyeResult
detect_irt_changepoints ¶
detect_irt_changepoints(data: Any, person: str = 'participant_id', order: str = 'item_order', response: str = 'response', rt: str = 'rt', gaze: str | None = None, min_segment: int = 5, min_delta_sic: float = 2, max_changes: int = 2) -> EyeResult
fit_changepoint_rt_irt ¶
fit_changepoint_multimodal_irt ¶
fit_changepoint_multimodal_irt(data: Any, *args: Any, gaze: str = 'fixation_count', refit: bool = True, **kwargs: Any) -> EyeResult
recalibrate_after_changepoint ¶
recalibrate_after_changepoint(data: Any, fitter: Callable[[DataFrame], Any], person: str = 'participant_id', order: str = 'item_order', policy: str = 'flag', **kwargs: Any) -> EyeResult
fit_censored_normal_process_irt ¶
fit_censored_normal_process_irt(response_matrix: Any, theta: Any, lower: float = 0, upper: float = 1, control: Mapping[str, Any] | None = None) -> EyeResult
predict_eye_censored_normal_process_irt ¶
predict_eye_censored_normal_process_irt(object: Any, theta: Any = None, items: Sequence[str] | None = None) -> np.ndarray
process_dependent_discrimination_audit ¶
process_dependent_discrimination_audit(data: Any, response: str, theta: str, process: str, person: str, item: str, nonlinear: bool = True) -> EyeResult
process_channel_ablation ¶
process_channel_ablation(data: Any, channels: Mapping[str, Sequence[str]], evaluator: Callable[[Any, Sequence[str], str], float], baseline: Sequence[str] = (), higher_is_better: bool = True) -> pd.DataFrame
fit_multimodal_trait_irt ¶
fit_multimodal_trait_irt(data: Any, response: str, rt: str, gaze: str, person: str, item: str, trait_label: str = 'trait', process_label: str = 'process', **kwargs: Any) -> EyeResult
generalizability_process_study ¶
generalizability_process_study(data: Any, outcome: str, facets: Sequence[str], REML: bool = True) -> EyeResult
cross_device_process_equating_audit ¶
cross_device_process_equating_audit(data: Any, value: str, reference_value: str, device: str, anchor: str | None = None) -> pd.DataFrame
encode_response_combinations ¶
encode_response_combinations(data: Any, person: str = 'participant_id', item: str = 'item_id', option: str = 'option_id', selected: str = 'selected', sort_options: bool = True, empty_code: str = '<none>') -> pd.DataFrame
audit_process_local_dependence ¶
audit_process_local_dependence(response_residuals: Any, process_residuals: Any = None, threshold: float = 0.2) -> EyeResult
fit_multiple_response_process_irt ¶
fit_multiple_response_process_irt(data: Any, selected: str = 'selected', theta: str = 'theta', person: str = 'participant_id', item: str = 'item_id', option: str = 'option_id', gaze: str | None = None, engine: str = 'reference', external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_revisit_process_cdm ¶
fit_revisit_process_cdm(response_matrix: Any, q_matrix: Any, process_data: Any, person_id: str = 'participant_id', revisited: str = 'revisited', rt: str = 'response_time', gaze: Sequence[str] | str | None = None, **kwargs: Any) -> EyeResult
plot_eye_process_dependent_discrimination ¶
plot_eye_process_local_dependence_audit ¶
fit_process_hmm_irt ¶
fit_process_hmm_irt(data: Any, sequence_id: str = 'trial_id', order: str = 'timestamp', process_features: Sequence[str] = ('x', 'y'), response: str = 'response', person: str = 'participant_id', item: str = 'item_id', n_states: int = 3, max_iter: int = 100, tol: float = 1e-05, seed: int = 1) -> EyeResult
fit_cognitive_diagnosis_process ¶
fit_cognitive_diagnosis_process(response_matrix: Any, q_matrix: Any, process_data: Any = None, process_features: Sequence[str] | None = None, person_id: str | None = None, engine: str = 'GDINA', external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_latent_class_process_irt ¶
fit_latent_class_process_irt(data: Any, response: str = 'response', process_features: Sequence[str] = (), person: str = 'participant_id', item: str = 'item_id', n_classes: int = 2, seed: int = 1) -> EyeResult
fit_crossclassified_process_irt ¶
fit_crossclassified_process_irt(data: Any, outcome: str, person: str = 'participant_id', item: str = 'item_id', context: str | None = None, family: str = 'gaussian', fixed: Sequence[str] | str | None = None) -> EyeResult
fit_latent_space_irt ¶
fit_latent_space_irt(response_matrix: Any, dimensions: int = 2, penalty: float | None = None, constraint: float | None = None, starts: Any = None, tol: float = 0.001, silent: bool = True) -> EyeResult
validate_latent_space_process_similarity ¶
validate_latent_space_process_similarity(object: Any, process_matrix: Any, entity: str = 'person') -> EyeResult
equate_irt_scales ¶
equate_irt_scales(reference: Any, new: Any, method: str = 'stocking-lord', theta_grid: Sequence[float] | None = None) -> EyeResult
process_person_fit ¶
process_person_fit(object: Any, data: Any = None, person: str | None = None, response_weight: float = 1, rt_weight: float = 1, process_weight: float = 1) -> pd.DataFrame
process_dif_nuisance_surrogate ¶
process_dif_nuisance_surrogate(data: Any, process_features: Sequence[str], person: str = 'participant_id', aggregate: bool = True) -> pd.DataFrame
audit_process_adjusted_dif ¶
audit_process_adjusted_dif(data: Any, response: str = 'response', ability: str | None = None, group: str | None = None, item: str = 'item_id', process_features: Sequence[str] = (), person: str = 'participant_id') -> EyeResult
process_ngram_features ¶
process_ngram_features(sequence: Any, n: Sequence[int] = (1, 2, 3), separator: str = '>') -> np.ndarray
process_sequence_embedding ¶
process_sequence_embedding(sequence: Any, n: Sequence[int] = (1, 2, 3), dimensions: int = 5) -> np.ndarray
fit_response_process_embedding_irt ¶
fit_response_process_embedding_irt(data: Any, sequences: Any, response: str = 'response', person: str = 'participant_id', item: str = 'item_id', dimensions: int = 5, n: Sequence[int] = (1, 2, 3)) -> EyeResult
fit_gpirt ¶
fit_gpirt(response_matrix: Any, engine: str = 'spline_reference', external_engine: Callable[..., Any] | None = None, spline_df: int = 5, **kwargs: Any) -> EyeResult
compare_parametric_nonparametric_irf ¶
compare_parametric_nonparametric_irf(response_matrix: Any, gpirt_object: Any = None, theta_grid: Sequence[float] | None = None) -> pd.DataFrame
audit_irf_shape ¶
audit_irf_shape(comparison: Any, mean_absolute_threshold: float = 0.05, max_absolute_threshold: float = 0.15) -> pd.DataFrame
fit_dynamic_gpirt ¶
fit_dynamic_gpirt(data: Any, external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_continuous_time_irt ¶
fit_continuous_time_irt(data: Any, external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_flow_mirt ¶
fit_flow_mirt(response_matrix: Any, external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_variational_irt ¶
fit_variational_irt(response_matrix: Any, external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
latent_trait_trajectory ¶
process_item_information ¶
process_item_information(theta: Any, a: Any, b: Any, process_information: Any = 0, rt_information: Any = 0, weights: Mapping[str, float] | Sequence[float] = {'response': 1, 'rt': 0, 'process': 0}, expected_time: Any = 0, burden_weight: float = 0) -> EyeResult
expected_process_information ¶
select_next_item_process ¶
select_next_item_process(theta: float, item_bank: Any, used: Sequence[str] = (), weights: Mapping[str, float] | Sequence[float] = {'response': 1, 'rt': 0, 'process': 0}, burden_weight: float = 0) -> EyeResult
simulate_process_cat ¶
simulate_process_cat(item_bank: Any, true_theta: float = 0, n_items: int = 10, weights: Mapping[str, float] | Sequence[float] = {'response': 1, 'rt': 0, 'process': 0}, burden_weight: float = 0, seed: int = 1) -> pd.DataFrame
irt_validation_spec ¶
irt_validation_spec(model_id: str, replications: int = 250, parameters: Any = None, metrics: Sequence[str] = ('bias', 'rmse', 'coverage', 'interval_width', 'convergence'), grouped_validation: Sequence[str] = ('device', 'session', 'site'), preprocessing_variants: Any = None, misspecification_scenarios: Any = None, thresholds: Mapping[str, Any] | None = None, seed: int = 20260808, notes: str | None = None) -> EyeResult
summarize_parameter_recovery ¶
summarize_parameter_recovery(results: Any, by: Sequence[str] = ('scenario', 'engine', 'parameter'), interval_level: float = 0.95) -> pd.DataFrame
audit_bias ¶
audit_bias(results: Any, threshold: float = 0.1, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> pd.DataFrame
audit_rmse ¶
audit_rmse(results: Any, threshold: float = 0.3, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> pd.DataFrame
audit_coverage ¶
audit_coverage(results: Any, minimum: float = 0.9, maximum: float = 1, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> pd.DataFrame
audit_interval_width ¶
audit_interval_width(results: Any, maximum: float = math.inf, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> pd.DataFrame
audit_convergence ¶
audit_convergence(results: Any, minimum: float = 0.95, by: Sequence[str] = ('scenario', 'engine')) -> pd.DataFrame
audit_identifiability ¶
audit_identifiability(results: Any, max_missing: float = 0.05, max_sd_ratio: float = 10, correlation_matrix: Any = None, max_abs_correlation: float = 0.995) -> pd.DataFrame
recommended_validation_replications ¶
recommended_validation_replications(target_mcse: float = 0.01, metric: str = 'coverage', anticipated_sd: float = 1, anticipated_probability: float = 0.95, minimum: int = 100) -> int
run_sbc ¶
run_sbc(simulator: Callable[[int], Any], fitter: Callable[[Any], Any], posterior_draws: Callable[[Any], Any], replications: int = 100, seed: int = 20260808) -> EyeResult
posterior_sbc_contract ¶
run_posterior_sbc ¶
run_posterior_sbc(observed_data: Any, contract: Any, replications: int = 100, seed: int = 20260808) -> EyeResult
posterior_predictive_discrepancies ¶
posterior_predictive_discrepancies(observed: Any, replicated: Any, discrepancies: Mapping[str, Callable[[Any], float]] | None = None) -> pd.DataFrame
stress_test_misspecification ¶
stress_test_misspecification(scenarios: Any, runner: Callable[[Any, int], Any], replications: int = 50, seed: int = 20260808) -> pd.DataFrame
stress_test_latent_distribution ¶
stress_test_latent_distribution(runner: Callable, replications: int = 50, seed: int = 20260808) -> pd.DataFrame
stress_test_local_dependence ¶
stress_test_local_dependence(runner: Callable, strengths: Sequence[float] = (0, 0.2, 0.5, 0.8), replications: int = 50, seed: int = 20260808) -> pd.DataFrame
stress_test_speededness ¶
stress_test_speededness(runner: Callable, proportions: Sequence[float] = (0, 0.1, 0.25, 0.4), replications: int = 50, seed: int = 20260808) -> pd.DataFrame
stress_test_missingness ¶
stress_test_missingness(runner: Callable, mechanisms: Sequence[str] = ('MCAR', 'MAR', 'MNAR_omission', 'not_reached'), rates: Sequence[float] = (0.05, 0.15, 0.3), replications: int = 50, seed: int = 20260808) -> pd.DataFrame
stress_test_preprocessing ¶
stress_test_preprocessing(runner: Callable, variants: Any, replications: int = 25, seed: int = 20260808) -> pd.DataFrame
external_validate_irt ¶
external_validate_irt(train_data: Any, external_data: Any, fitter: Callable, predictor: Callable, scorer: Callable, label: str = 'external') -> pd.DataFrame
leave_device_out_validation ¶
leave_device_out_validation(data: Any, device: str, fitter: Callable, predictor: Callable, scorer: Callable) -> pd.DataFrame
leave_session_out_validation ¶
leave_session_out_validation(data: Any, session: str, fitter: Callable, predictor: Callable, scorer: Callable) -> pd.DataFrame
leave_site_out_validation ¶
leave_site_out_validation(data: Any, site: str, fitter: Callable, predictor: Callable, scorer: Callable) -> pd.DataFrame
leave_item_out_validation ¶
leave_item_out_validation(data: Any, item: str, fitter: Callable, predictor: Callable, scorer: Callable) -> pd.DataFrame
audit_measurement_transportability ¶
audit_measurement_transportability(validation: Any, metric: str, higher_is_better: bool = True, max_range: float | None = None, minimum: float | None = None, maximum: float | None = None) -> pd.DataFrame
audit_channel_incremental_information ¶
audit_channel_incremental_information(data: Any, fold: str, baseline_fitter: Callable, process_fitter: Callable, predictor: Callable, scorer: Callable, higher_is_better: bool = True) -> pd.DataFrame
negative_control_process_test ¶
negative_control_process_test(data: Any, process_columns: str | Sequence[str], evaluator: Callable[[DataFrame], float], within: str | Sequence[str] | None = None, permutations: int = 100, higher_is_better: bool = True, seed: int = 20260808) -> EyeResult
calibration_transfer_audit ¶
grade_model_evidence ¶
grade_model_evidence(recovery: Any, spec: Any = None, external_validation: Any = None, sbc: Any = None, ppc: Any = None, semantic_roundtrip: Any = None) -> EyeResult
semantic_fidelity_spec ¶
semantic_fidelity_spec(timestamp_tolerance: float = 1e-06, coordinate_tolerance: float = 1e-06, pupil_tolerance: float = 1e-06, missingness_tolerance: float = 1e-06, correlation_floor: float = 0.999, allow_row_reorder: bool = True) -> EyeResult
field_fidelity_report ¶
field_fidelity_report(source: Any, roundtrip: Any, fields: Sequence[str] | str | None = None, mapping: Mapping[str, str] | None = None, key: str | Sequence[str] | None = None, tolerance: float = 1e-08, spec: Any = None) -> EyeResult
timestamp_fidelity_audit ¶
timestamp_fidelity_audit(source: Any, roundtrip: Any, source_time: str = 'timestamp', roundtrip_time: str | None = None, source_unit: str = 'seconds', roundtrip_unit: str | None = None, key: str | Sequence[str] | None = None, tolerance: float = 1e-06) -> EyeResult
coordinate_fidelity_audit ¶
coordinate_fidelity_audit(source: Any, roundtrip: Any, source_x: str = 'x', source_y: str = 'y', roundtrip_x: str | None = None, roundtrip_y: str | None = None, key: str | Sequence[str] | None = None, tolerance: float = 1e-06, correlation_floor: float = 0.999) -> EyeResult
pupil_unit_fidelity_audit ¶
pupil_unit_fidelity_audit(source: Any, roundtrip: Any, source_pupil: str = 'pupil_size', roundtrip_pupil: str | None = None, key: str | Sequence[str] | None = None, tolerance: float = 1e-06, correlation_floor: float = 0.995) -> EyeResult
eye_stream_fidelity_audit ¶
eye_stream_fidelity_audit(source: Any, roundtrip: Any, source_eye: str = 'eye', roundtrip_eye: str | None = None, key: str | Sequence[str] | None = None) -> EyeResult
event_semantics_audit ¶
event_semantics_audit(source_events: Any, roundtrip_events: Any, label: str = 'event', time: str | None = 'timestamp', key: str | Sequence[str] | None = None, tolerance: float = 1e-06) -> EyeResult
validate_hed_event_semantics ¶
validate_bids_eye_semantics ¶
validate_bids_eye_semantics(data: Any, metadata: Mapping[str, Any], events_metadata: Mapping[str, Any] | None = None) -> EyeResult
semantic_roundtrip_audit ¶
semantic_roundtrip_audit(source: Any, roundtrip: Any, key: str | Sequence[str] | None = None, fields: Sequence[str] | None = None, timestamp: Mapping[str, Any] | None = None, coordinates: Mapping[str, Any] | None = None, pupil: Mapping[str, Any] | None = None, eye: Mapping[str, Any] | None = None, source_events: Any = None, roundtrip_events: Any = None, event_args: Mapping[str, Any] | None = None) -> EyeResult
compatibility_evidence_matrix ¶
validate_vendor_timestamp_semantics ¶
validate_vendor_timestamp_semantics(data: Any, vendor: str, device_time: str | None = None, system_time: str | None = None, media_time: str | None = None) -> EyeResult
plot_eye_compatibility_evidence_matrix ¶
fit_gaze_informed_missingness_irt ¶
fit_gaze_informed_missingness_irt(data: Any, response: str = 'response', person: str = 'participant_id', item: str = 'item_id', gaze_exposure: str = 'gaze_exposure', theta: str | None = None, reached: str | None = None) -> EyeResult
algorithm_facet_effects ¶
plot_person_item_space ¶
plot_person_item_space(object: Any, dimensions: Sequence[int] = (1, 2), labels: bool = False, ax: Any = None)
explain_latent_interaction ¶
explain_latent_interaction(object: Any, person: Any = None, item: Any = None, top: int = 10) -> pd.DataFrame
plot_irf_uncertainty ¶
plot_irf_uncertainty(object: Any, item: int | str = 1, theta_grid: Sequence[float] | None = None, level: float = 0.95, ax: Any = None)
audit_latent_distribution ¶
fit_event_time_irt ¶
fit_event_time_irt(data: Any, event_time: str = 'event_time', event: str = 'event', theta: str = 'theta', person: str = 'participant_id', item: str = 'item_id', engine: str = 'cox_reference', external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_validation_replicate ¶
fit_validation_replicate(replicate: int, generator: Callable[..., Any], fitter: Callable[..., Any], extractor: Callable[..., Any], scenario: Any = 'baseline', engine: str = 'unspecified') -> pd.DataFrame
vendor_schema_contract ¶
vendor_schema_contract(vendor: str, version: str | None = None, required_fields: Sequence[str] = (), optional_fields: Sequence[str] = (), aliases: Mapping[str, Sequence[str]] | None = None, timestamp: Mapping[str, Any] | None = None, coordinate: Mapping[str, Any] | None = None, units: Mapping[str, Any] | None = None, eye_streams: Sequence[str] = (), event_fields: Sequence[str] = ()) -> EyeResult
validate_vendor_semantics ¶
validate_vendor_semantics(data: Any, contract: Any, metadata: Mapping[str, Any] | None = None) -> EyeResult
event_roundtrip_audit ¶
event_roundtrip_audit(source_events: Any, roundtrip_events: Any, hed_column: str | None = None, **kwargs: Any) -> EyeResult
roundtrip_eye_bids ¶
roundtrip_eye_bids(source: Any, exporter: Callable[..., Any], importer: Callable[..., Any], export_args: Mapping[str, Any] | None = None, import_args: Mapping[str, Any] | None = None, extract_samples: Callable[[Any], DataFrame] = _extract_samples, audit_args: Mapping[str, Any] | None = None) -> EyeResult
cross_version_adapter_regression ¶
cross_version_adapter_regression(input: Any, baseline_adapter: Callable[..., Any], candidate_adapter: Callable[..., Any], baseline_version: str = 'baseline', candidate_version: str = 'candidate', extract_samples: Callable[[Any], DataFrame] = _extract_samples, audit_args: Mapping[str, Any] | None = None) -> EyeResult
visual_context_registry ¶
visual_context_registry(item_metadata: Any, item: str = 'item_id', context: str | None = None, context_candidates: Sequence[str] = ('visual_anchor_id', 'stimulus_id', 'stimulus_page', 'page_id', 'layout_id', 'screen_id', 'diagram_id'), min_items_per_context: int = 3) -> EyeResult
fit_visual_context_irt ¶
fit_visual_context_irt(response_matrix: Any, registry: Any, context: str | None = None, itemtype: str = '2PL', model_dimension: str = 'Ability', context_dimension: str = 'VisualContextFactor', SE: bool = False) -> EyeResult
Gate the exact frozen mirt testlet model rather than substitute it.
The registry/positions and model string are validated before raising, so the failure is an actionable backend boundary rather than a placeholder.
process_feature_blocks ¶
process_feature_blocks(data: Any, blocks: Mapping[str, Sequence[str] | str], id: str | None = None, drop_constant: bool = True) -> EyeResult
fit_multiblock_process_map ¶
fit_multiblock_process_map(x: Any, blocks: Mapping[str, Sequence[str]] | None = None, id: str | None = None, engine: str = 'auto', ncp: int = 5) -> EyeResult
fit_process_profile_mixture ¶
fit_process_profile_mixture(data: Any, variables: Sequence[str], k: int = 3, id: str = 'person_id', engine: str = 'auto', seed: int = 777) -> EyeResult
compare_process_profile_solutions ¶
compare_process_profile_solutions(data: Any, variables: Sequence[str], k_values: Sequence[int] = range(2, 7), seed: int = 777) -> pd.DataFrame
audit_process_external_validity ¶
audit_process_external_validity(data: Any, criterion: str, predictors: Sequence[str], baseline_predictors: Sequence[str] | None = None) -> EyeResult
fit_item_parameter_seed_model ¶
fit_item_parameter_seed_model(item_data: Any, difficulty: str = 'irt_difficulty', discrimination: str = 'irt_discrimination', predictors: Sequence[str] = (), engine: str = 'auto', seed: int = 2221) -> EyeResult
predict_item_parameter_priors ¶
audit_candidate_item_bank ¶
audit_candidate_item_bank(object: Any, candidate_data: Any, difficulty_range: Sequence[float] = (-3, 3), discrimination_min: float = 0.3) -> EyeResult
fit_kde_latent_distribution_irt ¶
fit_kde_latent_distribution_irt(response_matrix: Any, engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_persistence_gaze_diffusion_irt ¶
fit_persistence_gaze_diffusion_irt(data: Any, engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_nonignorable_missing_irt ¶
fit_nonignorable_missing_irt(data: Any, engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
prepare_structured_unstructured_process_features ¶
prepare_structured_unstructured_process_features(structured: Any, unstructured: Any = None, fold: str | None = None, builder: Callable[..., Any] | None = None, id: Sequence[str] = ('person_id', 'item_id'), **kwargs: Any) -> EyeResult
fit_crossclassified_process_irt_mhrm ¶
fit_crossclassified_process_irt_mhrm(data: Any, engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
audit_frontier_model_contract ¶
fit_mixture_irt_process_classes ¶
fit_mixture_irt_process_classes(response_matrix: Any, n_classes: int = 2, model: Any = 1, itemtype: str = '2PL', SE: bool = False) -> EyeResult
map_latent_classes_to_process_profiles ¶
map_latent_classes_to_process_profiles(class_membership: Any, process_data: Any, person: str = 'person_id', class_col: str = 'class', process_features: Sequence[str] = ()) -> EyeResult
audit_nonparametric_rasch ¶
audit_nonparametric_rasch(response_matrix: Any, methods: Sequence[str] = ('T1', 'T10'), n: int = 100, splitcr: str = 'median', seed: int = 321) -> EyeResult
audit_item_reduction_sensitivity ¶
audit_item_reduction_sensitivity(erm_model: Any, criterion: Any = None, alpha: float = 0.05, maxstep: int = 5) -> EyeResult
biometric_imputation_sensitivity ¶
biometric_imputation_sensitivity(data: Any, variables: Sequence[str], methods: Sequence[str] = ('mice', 'missForest'), m: int = 3, maxit: int = 3, seed: int = 521) -> EyeResult
fit_process_rasch_tree ¶
fit_process_rasch_tree(response_matrix: Any, covariates: Any, formula: Any = None, maxit: int = 60) -> EyeResult
compare_bayesian_process_models ¶
bayesian_process_diagnostics_dashboard ¶
bayesian_process_diagnostics_dashboard(*models: Any, model_names: Sequence[str] | None = None, compute_loo: bool = True, compute_bayes_factor: bool = False, posterior_summary: bool = True) -> EyeResult
bayesian_process_diagnostic_flags ¶
bayesian_process_diagnostic_flags(x: Any, rhat_threshold: float = 1.01, ess_threshold: float = 400) -> pd.DataFrame
fit_gaze_anchored_3pl_audit ¶
fit_gaze_anchored_3pl_audit(response_matrix: Any, process_data: Any = None, item: str = 'item_id', process_features: Sequence[str] = ('ttff_ms', 'dwell_ms', 'pupil_bc', 'pupil_peak', 'rt_ms', 'accuracy'), model: Any = 1, SE: bool = False) -> EyeResult
audit_3pl_process_signatures ¶
audit_3pl_process_signatures(x: Any, lower_asymptote_quantile: float = 0.8, fast_rt_quantile: float = 0.2, fast_ttff_quantile: float = 0.2) -> pd.DataFrame
prepare_multimodal_irt_data ¶
prepare_multimodal_irt_data(data: Any, person: str, item: str, trial: str | None = None, response: str | None = None, rt: str | None = None, gaze: str | None = None, pupil: str | None = None, quality: Sequence[str] = (), device: Any = None, payloads: Mapping[str, Any] | None = None, provenance: Mapping[str, Any] | None = None) -> EyeResult
multimodal_irt_spec ¶
multimodal_irt_spec(response: Any = None, rt: Any = None, gaze: Any = None, pupil: Any = None, model: str = 'M0', backend: str = 'cmdstanr', identification: Mapping[str, Any] | None = None, priors: Mapping[str, Any] | None = None) -> EyeResult
simulate_multimodal_irt ¶
simulate_multimodal_irt(n_person: int = 120, n_item: int = 20, seed: int = 42, latent_cor: Any = None, rt_sd: float = 0.3, gaze_size: float = 8, pupil_sd: float = 0.2, pupil_luminance: float = -0.2, gaze_x_effect: float = 0.08, gaze_y_effect: float = -0.05, missing_fraction: float = 0) -> EyeResult
process_information ¶
process_information(baseline: Any, augmented: Any, metric: str = 'variance_reduction') -> pd.DataFrame
ablate_multimodal_channels ¶
ablate_multimodal_channels(x: Any, include: Sequence[str] = ('response', 'rt', 'gaze', 'pupil'), include_response: bool = True) -> EyeResult
audit_multimodal_identifiability ¶
multimodal_m2_spec ¶
multimodal_m2_spec(backend: str = 'cmdstanr', prior_profile: str = 'regularized', missingness: str = 'ignorable') -> EyeResult
fit_multimodal_m2 ¶
fit_multimodal_m2(x: Any, person: str = 'person_id', item: str = 'item_id', response: str = 'response', rt: str = 'rt', gaze: str = 'gaze', prior_profile: str = 'regularized', chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, seed: int = 20260814, adapt_delta: float = 0.95, max_treedepth: int = 12, refresh: int = 100, quiet_compile: bool = True) -> EyeResult
simulate_multimodal_m2 ¶
simulate_multimodal_m2(n_person: int = 100, n_item: int = 10, mu_item: Any = None, sd_person: Any = None, cor_person: Any = None, sd_item: Any = None, cor_item: Any = None, nu_range: Sequence[float] = (0.5, 0.8), gaze_shape: Mapping[str, float] | Sequence[float] = (2, 6), dropout: Mapping[str, float] | Sequence[float] = (0, 0, 0), seed: int = 20260814) -> EyeResult
audit_multimodal_m2_identifiability ¶
audit_multimodal_m2_identifiability(x: Any, person: str = 'person_id', item: str = 'item_id', response: str = 'response', rt: str = 'rt', gaze: str = 'gaze', model: str = 'M2', min_persons: int = 20, min_items: int = 5) -> EyeResult
multimodal_m2_negative_controls ¶
validate_multimodal_m2 ¶
validate_multimodal_m2(x: Any, include_ppc: bool = True, rhat_max: float = 1.01, ess_min: int = 200) -> EyeResult
multimodal_m2_recovery ¶
multimodal_m2_recovery(n_rep: int = 10, n_person: int = 100, n_item: int = 10, dropout: Sequence[float] = (0, 0, 0), base_seed: int = 20260814, chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, prior_profile: str = 'regularized', adapt_delta: float = 0.95, max_treedepth: int = 12, refresh: int = 0) -> EyeResult
multimodal_m3_spec ¶
multimodal_m3_spec(backend: str = 'cmdstanr', prior_profile: str = 'regularized', missingness: str = 'ignorable', pupil_representation: str = 'summary', nuisance: Mapping[str, bool] | None = None) -> EyeResult
fit_multimodal_m3 ¶
fit_multimodal_m3(x: Any, person: str = 'person_id', item: str = 'item_id', response: str = 'response', rt: str = 'rt', gaze: str = 'gaze', pupil: str = 'pupil', baseline: str = 'pupil_baseline', luminance: str = 'luminance', gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', quality: str = 'pupil_quality', time_on_task: str = 'time_on_task', blink: str = 'pupil_blink', interpolated: str = 'pupil_interpolated', device: str = 'device', session: str = 'session', sampling_rate: str = 'sampling_rate_hz', pupil_scale: str = 'z', prior_profile: str = 'regularized', nuisance: Mapping[str, bool] | None = None, chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, seed: int = 20260815, adapt_delta: float = 0.95, max_treedepth: int = 12, refresh: int = 100, quiet_compile: bool = True, init: Any = 0) -> EyeResult
simulate_multimodal_m3 ¶
simulate_multimodal_m3(n_person: int = 120, n_item: int = 12, pupil_signal: str = 'informative', pupil_missingness: str = 'mcar', mu_item: Any = None, sd_person: Any = None, cor_person: Any = None, sd_item: Any = None, cor_item: Any = None, nu_range: Sequence[float] = (0.5, 0.8), gaze_shape: Sequence[float] = (2, 6), pupil_noise: float = 0.65, confound_strength: Mapping[str, float] | None = None, dropout: Mapping[str, float] | Sequence[float] = (0, 0, 0.05, 0.12), device_effect: float = 0, session_effect: float = 0, seed: int = 20260815) -> EyeResult
audit_multimodal_m3_identifiability ¶
audit_multimodal_m3_identifiability(x: Any, pupil_scale: str = 'z', min_persons: int = 20, min_items: int = 5, max_pupil_missing: float = 0.5, max_blink_rate: float = 0.3, max_interpolation_rate: float = 0.3) -> EyeResult
multimodal_m3_negative_controls ¶
multimodal_m3_functional_bridge ¶
multimodal_m3_functional_bridge(data: Any, score: Any, pupil: str = 'pupil', provenance: Any = None) -> EyeResult
multimodal_m3_ablation ¶
multimodal_m3_ablation(x: Any, models: Any = None, nuisance: Any = None, **kwargs: Any) -> EyeResult
multimodal_m3_process_information ¶
multimodal_m3_process_information(x: Any, pupil_cost: float = 1, decisive_z: float = 2) -> EyeResult
validate_multimodal_m3 ¶
validate_multimodal_m3(x: Any, include_ppc: bool = True, rhat_max: float = 1.05, ess_min: int = 50, ebfmi_min: float = 0.3) -> EyeResult
multimodal_m3_recovery ¶
multimodal_m3_recovery(reps: int = 3, pupil_signal: Sequence[str] = ('informative', 'weak', 'null', 'redundant', 'confounded'), pupil_missingness: Sequence[str] = ('mcar', 'quality', 'device'), n_person: int = 80, n_item: int = 10, seed: int = 20260815, fit_args: Mapping[str, Any] | None = None) -> EyeResult
multimodal_m4_spec ¶
multimodal_m4_spec(n_states: int = 2, state_channels: Sequence[str] = ('rt', 'gaze', 'pupil'), transition_structure: str = 'markov', trait_conditioning: Sequence[str] = ('theta', 'tau'), initial_trait_conditioning: bool = True, min_sequence_length: int = 2, identification: str = 'ordered_rt_effect', prior_profile: str = 'regularized', missingness: str = 'ignorable', nuisance: Mapping[str, bool] | None = None, backend: str = 'cmdstanr') -> EyeResult
fit_multimodal_m4 ¶
fit_multimodal_m4(x: Any, spec: Any = None, person: str = 'person_id', item: str = 'item_id', response: str = 'response', rt: str = 'rt', gaze: str = 'gaze', pupil: str = 'pupil', sequence: str = 'sequence_id', order: str = 'trial_index', baseline: str = 'pupil_baseline', luminance: str = 'luminance', gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', quality: str = 'pupil_quality', time_on_task: str = 'time_on_task', blink: str = 'pupil_blink', interpolated: str = 'pupil_interpolated', device: str = 'device', session: str = 'session', sampling_rate: str = 'sampling_rate_hz', pupil_scale: str = 'z', n_states: int = 2, state_channels: Sequence[str] = ('rt', 'gaze', 'pupil'), transition_structure: str = 'markov', trait_conditioning: Sequence[str] = ('theta', 'tau'), initial_trait_conditioning: bool = True, min_sequence_length: int = 2, prior_profile: str = 'regularized', nuisance: Mapping[str, bool] | None = None, chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, seed: int = 20260820, adapt_delta: float = 0.97, max_treedepth: int = 13, refresh: int = 100, quiet_compile: bool = True, init: Any = 0) -> EyeResult
simulate_multimodal_m4 ¶
simulate_multimodal_m4(n_person: int = 80, n_item: int = 12, n_session: int = 1, n_states: int = 2, scenario: str = 'clear', missingness: str = 'none', missing_rate: float = 0.08, seed: int = 20260820) -> EyeResult
audit_multimodal_m4_identifiability ¶
audit_multimodal_m4_identifiability(x: Any, spec: Any = None, include_posterior: bool = True, rhat_max: float = 1.05, ess_min: int = 100, ebfmi_min: float = 0.3, occupancy_min: float = 0.03, entropy_fraction_review: float = 0.8) -> EyeResult
multimodal_m4_negative_controls ¶
multimodal_m4_negative_controls(x: Any, controls: Sequence[str] = ('order_shuffle', 'process_shuffle', 'state_independent', 'nuisance_pseudostate', 'device_session_pseudostate', 'overfit_state_count'), seed: int = 20260820, run: bool = False, fit_args: Mapping[str, Any] | None = None) -> EyeResult
multimodal_m4_sensitivity ¶
multimodal_m4_sensitivity(x: Any, n_states: Sequence[int] = range(1, 5), run: bool = False, fit_args: Mapping[str, Any] | None = None) -> EyeResult
multimodal_m4_ablation ¶
multimodal_m4_ablation(x: Any, run: bool = False, include_channel_ablations: bool = False, m3_fit: Any = None, m4_fit: Any = None, fit_args: Mapping[str, Any] | None = None) -> EyeResult
multimodal_m4_process_information ¶
validate_multimodal_m4 ¶
validate_multimodal_m4(x: Any, information: Any = None, negative_controls: Any = None, sensitivity: Any = None, recovery: Any = None, include_ppc: bool = True) -> EyeResult
multimodal_m4_recovery ¶
multimodal_m4_recovery(simulation: Any = None, fit: Any = None, scenarios: Sequence[str] = ('clear', 'weak', 'null', 'trait_conditioned', 'nuisance_confounded'), run: bool = False, simulation_args: Mapping[str, Any] | None = None, fit_args: Mapping[str, Any] | None = None) -> EyeResult
response_matrix ¶
response_time_matrix ¶
model_data ¶
model_data(x: Any, include_features: bool = True, aggregate_features: Callable = np.mean) -> pd.DataFrame
fit_irt ¶
fit_irt(x: Any, engine: str = 'mirt', model: Any = 1, itemtype: str = '2PL', value: str = 'score', **kwargs: Any) -> EyeResult
fit_explanatory_irt ¶
fit_explanatory_irt(x: Any, formula: Any, engine: str = 'lme4', participant_random: bool = True, item_random: bool = True, family: Any = 'binomial', **kwargs: Any) -> EyeResult
fit_accuracy_rt ¶
fit_accuracy_rt(x: Any, engine: str = 'LNIRT', iterations: int = 1000, burnin: int = 10, residual: bool = False, **kwargs: Any) -> EyeResult
fit_dif ¶
fit_dif(x: Any, group: Any, engine: str = 'logistic', items: Any = None, **kwargs: Any) -> EyeResult
fit_shared_process_factor ¶
fit_shared_process_factor(x: Any, features: Sequence[str], n_factors: int = 1, center: bool = True, scale_: bool = True, append: bool = True, prefix: str = 'process_factor') -> EyeResult
fit_joint_process_model ¶
fit_joint_process_model(x: Any, accuracy_formula: Any, rt_formula: Any, process_formulas: Any = None, engine: str = 'brms', **kwargs: Any) -> EyeResult
fit_dynamic_aoi_model ¶
simulate_eye_dataset ¶
simulate_eye_dataset(n_person: int = 30, n_item: int = 10, sampling_rate: float = 60, trial_duration: float = 2, samples_per_trial: int | None = None, include_pupil: bool = True, include_biometrics: bool = True, missing_gaze: float = 0.05, missing_pupil: float = 0.08, seed: int | None = None) -> EyeDataset
simulate_process_irt ¶
simulate_process_irt(n_person: int = 200, n_item: int = 20, gaze_effect: float = 0.4, pupil_effect: float = 0.3, ability_speed_correlation: float = -0.3, missing_process: float = 0.1, seed: int | None = None) -> EyeResult
parameter_recovery ¶
parameter_recovery(simulator: Callable, estimator: Callable, extractor: Callable, truth_extractor: Callable, replications: int = 100, seed: int = 1, **kwargs: Any) -> pd.DataFrame
power_process_simulation ¶
power_process_simulation(n_person: Any, n_item: Any, effect: Any, replications: int = 200, alpha: float = 0.05, seed: int = 1) -> pd.DataFrame
process_irt_spec ¶
process_irt_spec(response: str = 'score', response_time: str = 'response_time', gaze_features: Sequence[str] = (), pupil_features: Sequence[str] = (), biometric_features: Sequence[str] = (), participant_effect: bool = True, item_effect: bool = True, estimand: str = 'association', confirmatory: bool = False) -> EyeResult
fit_process_irt ¶
fit_gaze_informed_irt ¶
fit_gaze_informed_irt(x: Any, response: str = 'score', gaze_features: Sequence[str] = (), engine: str = 'lme4', **kwargs: Any) -> EyeResult
fit_pupil_informed_irt ¶
fit_pupil_informed_irt(x: Any, response: str = 'score', pupil_features: Sequence[str] = (), engine: str = 'lme4', **kwargs: Any) -> EyeResult
fit_multimodal_irt ¶
fit_multimodal_irt(x: Any, response: str = 'score', gaze_features: Sequence[str] = (), pupil_features: Sequence[str] = (), biometric_features: Sequence[str] = (), engine: str = 'lme4', **kwargs: Any) -> EyeResult
functional_pupil_features ¶
functional_pupil_features(x: Any, df: int = 5, grid_points: int = 100, append: bool = True, prefix: str = 'pupil_basis') -> Any
fit_strategy_mixture ¶
fit_strategy_mixture(x: Any, features: Sequence[str], centers: int = 2, response_formula: Any = None, seed: int = 1, append: bool = True) -> EyeResult
estimate_ez_diffusion ¶
estimate_ez_diffusion(x: Any, accuracy: str = 'score', response_time: str = 'response_time', by: Sequence[str] = ('item_id',), scale: float = 0.1) -> pd.DataFrame
fit_gaze_weighted_choice ¶
fit_gaze_weighted_choice(x: Any, response: str = 'score', dwell_features: Sequence[str] = (), engine: str = 'glm', **kwargs: Any) -> EyeResult
model_missing_process ¶
model_missing_process(x: Any, feature_name: str, predictors: Sequence[str] = ('score', 'response_time'), engine: str = 'glm', **kwargs: Any) -> EyeResult
sensitivity_missing_process ¶
sensitivity_missing_process(x: Any, feature_name: str, formula: Any, methods: Sequence[str] = ('complete_case', 'median_indicator')) -> EyeResult
functional_pupil_irt_spec ¶
functional_pupil_irt_spec(df: int = 6, basis: str | Sequence[str] = ('natural_spline', 'bspline'), response: str = 'score', engine: str | Sequence[str] = ('two_stage_glm', 'two_stage_lme4', 'brms', 'stan'), alignment: str | Sequence[str] = ('trial', 'event'), event_time_column: str | None = None, latency_ms: float = 200, baseline_window: Sequence[float] = (-200, 0), baseline_method: str | Sequence[str] = ('subtract', 'percent', 'zscore'), min_baseline_samples: int = 3, drop_invalid_baseline: bool = True, time_window: Sequence[float] | None = None, pupil_column: str | None = None, time_column: str | None = None, participant_column: str = 'participant_id', item_column: str = 'item_id', trial_column: str = 'trial_id', luminance_column: str | None = None, gaze_x_column: str | None = None, gaze_y_column: str | None = None, blink_column: str | None = None, interpolated_column: str | None = None, max_interpolated_fraction: float = 0.2, nuisance_by_participant: bool = False, include_response_time: bool = True, ar1: bool = True, participant_effect: bool = True, item_effect: bool = True, chains: int = 4, parallel_chains: int | None = None, iter_warmup: int = 1000, iter_sampling: int = 1000, adapt_delta: float = 0.95, max_treedepth: int = 12) -> EyeResult
prepare_functional_pupil_data ¶
functional_pupil_basis ¶
functional_pupil_basis(x: Any, df: int = 6, basis: str | Sequence[str] = ('natural_spline', 'bspline'), degree: int = 3, boundary_knots: Sequence[float] | None = None, knots: Sequence[float] | None = None) -> pd.DataFrame
fit_functional_pupil_stan ¶
fit_functional_pupil_stan(prepared: Any, basis_matrix: Any = None, seed: int = 1, refresh: int = 0, output_dir: str | None = None, **kwargs: Any) -> EyeResult
fit_joint_functional_pupil_irt ¶
extract_functional_pupil_parameters ¶
extract_functional_pupil_parameters(x: Any, pattern: str | None = None, confidence: float = 0.95) -> pd.DataFrame
pupil_preprocessing_grid ¶
pupil_preprocessing_grid(baseline_windows: Sequence[Sequence[float]] = ((-200, 0), (-500, 0)), latency_ms: Sequence[float] = (100, 200, 300), basis_df: Sequence[int] = (4, 6, 8), baseline_methods: Sequence[str] = ('subtract', 'percent'), max_interpolated_fraction: Sequence[float] = (0.1, 0.2)) -> pd.DataFrame
pupil_preprocessing_sensitivity ¶
pupil_preprocessing_sensitivity(x: Any, grid: Any = None, base_spec: Any = None, fit: bool = True, extractor: Callable = extract_functional_pupil_parameters, continue_on_error: bool = True, **kwargs: Any) -> EyeResult
compare_functional_scalar_models ¶
compare_functional_scalar_models(x: Any, scalar_features: Sequence[str] = ('pupil_peak', 'pupil_auc', 'pupil_mean'), criterion: str | Sequence[str] = ('AIC', 'log_loss'), folds: int = 5, seed: int = 1) -> pd.DataFrame
advanced_validation_grid ¶
simulate_advanced_process_data ¶
simulate_advanced_process_data(n_person: int = 100, n_item: int = 20, n_time: int = 30, n_states: int = 3, ability_speed_correlation: float = -0.3, gaze_effect: float = 0.35, feature_reliability: float = 0.7, missing_process: float = 0, state_misclassification: float = 0, pupil_ar1: float = 0.6, luminance_effect: float = 0, dif_effect: float = 0, local_dependence: float = 0, seed: int = 1) -> EyeResult
plot_eye_functional_pupil_irt ¶
plot_eye_functional_pupil_sensitivity ¶
eyeprocess_api_version ¶
Return the frozen public API contract version (R: eyeprocess_api_version).
object_schema ¶
Describe a stable eyeprocess object schema.
validate_model_object ¶
Validate a fitted model against the stable 1.0.0 model contract.
upgrade_eyeprocess_model ¶
Upgrade a list-like legacy model to the stable eyeprocess model contract.
eyeprocess_deprecation ¶
eyeprocess_deprecation(old: Any, replacement: Any, since: Any, remove_after: Any, reason: str = '') -> pd.DataFrame
Return a structured deprecation record.
external_model_engines ¶
List frozen external-engine adapters and exact-engine availability.
engine_adapter_status ¶
Report one adapter's availability and stable contract.
fit_external_engine ¶
fit_external_engine(engine: str, data: Any, specification: Any = None, purpose: str | None = None, **kwargs: Any) -> EyeResult
Fit an exact external R engine through the frozen stable adapter contract.
In the pure-Python parity core these R engines are deliberately unavailable;
the function therefore returns a structured not_available result instead
of choosing a different estimator.
validate_engine_adapter ¶
Validate the stable external-engine adapter result contract.
compare_engine_adapters ¶
Compare multiple external-engine adapter results.
fit_mirt_adapter ¶
fit_tam_adapter ¶
fit_brms_adapter ¶
fit_lnirt_adapter ¶
fit_traminer_adapter ¶
fit_seqhmm_adapter ¶
fit_openmx_adapter ¶
fit_diffirt_engine_adapter ¶
fit_eyetrackingr_adapter ¶
fit_pupillometryr_adapter ¶
fit_gdina_adapter ¶
fit_gdina_adapter(data: Any, Q: Any, model: str = 'GDINA', purpose: str = 'cognitive diagnosis', **kwargs: Any) -> EyeResult
Final 0.11.1 GDINA adapter (the R/028 override of the older R/020 form).
as_procdata_sequence ¶
as_procdata_sequence(x: Any, source: str = 'visits', collapse_consecutive: bool = True) -> pd.DataFrame
as_traminer_sequence ¶
as_traminer_sequence(x: Any, source: str = 'visits', collapse_consecutive: bool = True, create_object: bool = False) -> pd.DataFrame
as_seqhmm_data ¶
fit_diffirt_adapter ¶
Strict legacy diffusion-IRT adapter from R/020.
fit_openmx_process_model ¶
fit_openmx_process_model(x: Any, model_builder: Callable, include_features: bool = True, **kwargs: Any) -> EyeResult
Strict legacy OpenMx process-model adapter from R/020.
compare_model_engines ¶
compare_model_engines(data: Any, engines: Mapping[str, Callable], extractors: Mapping[str, Callable] | Callable, reference: str | None = None, tolerance: float = 0.05) -> EyeResult
Compare estimates from named fitting functions against a reference engine.
plot_eye_engine_comparison ¶
Python counterpart of plot.eye_engine_comparison with plot-data attached.
process_measure_registry ¶
register_process_measure ¶
register_process_measure(registry: Any = None, name: Any = None, channel: Any = None, unit: Any = None, level: Any = None, interpretation: Any = None, guardrail: Any = None, status: Any = 'user_defined') -> pd.DataFrame
find_process_measures ¶
find_process_measures(registry: Any = None, channel: Any = None, level: Any = None, status: Any = None, query: str | None = None) -> pd.DataFrame
process_measure_coverage ¶
process_measure_lineage ¶
process_measure_lineage(measure: Any, inputs: Any, transformations: Any = (), output_level: Any = None) -> EyeResult
split_half_process_reliability ¶
split_half_process_reliability(data: Any, person: str, trial: str, measure: str, split: str = 'odd_even', repetitions: int = 100, seed: int = 1, aggregate_fun: Callable = np.mean) -> pd.DataFrame
process_bland_altman ¶
process_bland_altman(data: Any, person: str, session: str, measure: str, sessions: Any = None) -> EyeResult
process_reliability_profile ¶
process_temporal_stability ¶
process_temporal_stability(data: Any, person: str, session: str, measure: str, method: str = 'pearson') -> pd.DataFrame
bootstrap_process_reliability ¶
bootstrap_process_reliability(data: Any, person: str, session: str, measure: str, replications: int = 500, seed: int = 1) -> pd.DataFrame
estimate_calibration_error ¶
estimate_calibration_error(data: Any, gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', target_x: str = 'target_x', target_y: str = 'target_y', by: Any = None) -> pd.DataFrame
gaze_precision_rms_s2s ¶
gaze_precision_rms_s2s(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', time: str | None = None, by: Any = None) -> pd.DataFrame
effective_sampling_frequency ¶
effective_sampling_frequency(data: Any, time: str = 'timestamp_ms', unit: str = 'ms', by: Any = None) -> pd.DataFrame
audit_sampling_irregularity ¶
audit_sampling_irregularity(data: Any, time: str = 'timestamp_ms', unit: str = 'ms', by: Any = None, cv_threshold: float = 0.05) -> EyeResult
calibration_error_model ¶
calibration_error_model(data: Any, gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', target_x: str = 'target_x', target_y: str = 'target_y') -> EyeResult
gaze_uncertainty_ellipse ¶
propagate_calibration_uncertainty ¶
propagate_calibration_uncertainty(data: Any, model: Any, x: str = 'gaze_x', y: str = 'gaze_y', draws: int = 500, seed: int = 1) -> pd.DataFrame
probabilistic_aoi_assignment ¶
probabilistic_aoi_assignment(data: Any, aois: Any, model: Any, x: str = 'gaze_x', y: str = 'gaze_y', draws: int = 500, seed: int = 1, min_probability: float = 0.5) -> EyeResult
compare_hard_probabilistic_aoi ¶
compare_hard_probabilistic_aoi(data: Any, aois: Any, probabilistic: Any, x: str = 'gaze_x', y: str = 'gaze_y') -> pd.DataFrame
calibration_sensitivity_grid ¶
calibration_sensitivity_grid(offset_x: Any = (-0.02, 0, 0.02), offset_y: Any = (-0.02, 0, 0.02)) -> pd.DataFrame
fixation_boundary_uncertainty ¶
fixation_boundary_uncertainty(data: Any, aois: Any, x: str = 'gaze_x', y: str = 'gaze_y') -> pd.DataFrame
calibration_drift_profile ¶
calibration_drift_profile(data: Any, by: Any, gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', target_x: str = 'target_x', target_y: str = 'target_y') -> EyeResult
gaze_data_quality_profile ¶
gaze_data_quality_profile(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', time: str = 'timestamp_ms', target_x: str | None = None, target_y: str | None = None, valid: str | None = None, by: Any = None, time_unit: str = 'ms') -> EyeResult
plot_eye_process_reliability_profile ¶
plot_eye_process_reliability_profile(x: Any, y: Any = None, type: str = 'bland_altman', ax: Any = None)
plot_eye_calibration_error_model ¶
plot_eye_calibration_drift_profile ¶
plot_eye_data_quality_profile ¶
plot_eye_probabilistic_aoi_assignment ¶
plot_eye_sampling_irregularity_audit ¶
process_preflight_spec ¶
process_preflight_spec(min_gaze_validity: float = 0.8, min_pupil_validity: float = 0.7, max_gaze_missingness: float = 0.25, max_pupil_missingness: float = 0.3, min_valid_trial_fraction: float = 0.7, trial_gaze_validity_threshold: float = 0.75, min_rt_ms: float = 200, max_rt_ms: float = 10000, sampling_rate_tolerance: float = 0.2, blink_quantile: float = 0.95, caution_flags: int = 1, review_flags: int = 2) -> EyeResult
audit_biometric_preflight ¶
audit_biometric_preflight(data: Any, by: Sequence[str] = ('person_id',), spec: Any = None, valid_gaze_prop: str = 'valid_gaze_prop', valid_pupil_prop: str = 'valid_pupil_prop', missing_gaze: str = 'missing_gaze', missing_pupil: str = 'missing_pupil', rt_ms: str = 'rt_ms', blink_cluster_count: str = 'blink_cluster_count', sampling_rate_hz: str = 'sampling_rate_hz') -> EyeResult
apply_preflight_decision ¶
apply_preflight_decision(data: Any, audit: Any, keep_decisions: Sequence[str] = ('pass_preflight', 'use_with_caution')) -> pd.DataFrame
audit_process_anomalies ¶
audit_process_anomalies(data: Any, person: str = 'person_id', metrics: Sequence[str] | None = None, alpha: float = 0.975, aggregate: bool = True, ridge: float = 1e-06) -> EyeResult
audit_multivariate_process_quality ¶
audit_presentation_accessibility ¶
audit_presentation_accessibility(data: Any, person: str = 'person_id', rt: str = 'rt_ms', dwell: str = 'dwell_ms', revisits: str = 'revisits', entropy: str = 'aoi_entropy', pupil: str = 'pupil_peak', gaze_validity: str = 'valid_gaze_prop', review_quantile: float = 0.9) -> EyeResult
simulate_presentation_variants ¶
simulate_presentation_variants(audit: Any, line_spacing_multiplier: float = 1.25, key_term_highlighting: bool = True) -> pd.DataFrame
compare_presentation_fairness ¶
compare_presentation_fairness(data: Any, variant: str, outcome: str, person: str | None = None) -> EyeResult
process_drift_spec ¶
process_drift_spec(baseline: str = 'first_batch', difficulty_limit: float = 0.4, discrimination_limit: float = 0.35, gaze_validity_drop: float = 0.1, luminance_limit: float = 25, relative_metric_quantile: float = 0.9, min_batches: int = 2) -> EyeResult
audit_process_drift ¶
audit_process_drift(data: Any, item: str = 'item_id', batch: str = 'deployment_batch', metrics: Sequence[str] = ('irt_difficulty', 'irt_discrimination', 'rt_ms', 'dwell_ms', 'pupil_bc', 'valid_gaze_prop', 'screen_luminance'), spec: Any = None, reference_batch: Any = None, aggregate_fun: Callable[[Any], float] = _mean) -> EyeResult
compare_deployment_batches ¶
compare_deployment_batches(data: Any, batch: str = 'deployment_batch', batch_a: Any = None, batch_b: Any = None, metrics: Sequence[str] | None = None, item: str = 'item_id') -> pd.DataFrame
drift_by_device ¶
drift_by_stimulus_version ¶
drift_by_stimulus_version(data: Any, stimulus_version: str = 'stimulus_version', **kwargs: Any) -> pd.DataFrame
process_window_spec ¶
process_window_spec(width_ms: float = 1000, step_ms: float = 500, start_ms: float = 0, end_ms: float = 3000, align: str = 'stimulus', min_samples: int = 5) -> EyeResult
extract_process_windows ¶
extract_process_windows(data: Any, person: str = 'person_id', trial: str = 'trial_id', time: str = 'time_ms', spec: Any = None, align_time: str | None = None, pupil: str = 'pupil_bc', pupil_tonic: str = 'pupil_tonic', pupil_phasic: str = 'pupil_phasic', gaze_x: str = 'x', gaze_y: str = 'y', aoi: str = 'aoi', valid_gaze: str = 'valid_gaze_prop', valid_pupil: str = 'valid_pupil_prop', blink: str = 'blink', trackloss: str = 'trackloss') -> EyeResult
summarize_process_windows ¶
audit_process_window_sensitivity ¶
audit_process_window_sensitivity(data: Any, widths_ms: Sequence[float] = (250, 500, 1000, 1500), steps_ms: Sequence[float] = (100, 250, 500), metric: str = 'pupil_mean', grid: bool = True, **kwargs: Any) -> EyeResult
aoi_trajectory_features ¶
aoi_trajectory_features(data: Any, person: str = 'person_id', trial: str = 'trial_id', time: str = 'time_ms', aoi: str = 'aoi', bin_ms: float = 100, degree: int = 3, aois: Sequence[str] | None = None) -> EyeResult
fit_aoi_growth_curve ¶
pupil_band_power ¶
pupil_band_power(y: Any, sampling_rate_hz: float, lower_hz: float, upper_hz: float, detrend: bool = True) -> float
pupil_activity_index ¶
pupil_activity_index(y: Any, time_ms: Any = None, sampling_rate_hz: float | None = None, method: str = 'velocity', low_band: Sequence[float] = (0.05, 0.5), high_band: Sequence[float] = (0.5, 4.0), fast_window_ms: float = 250, slow_window_ms: float = 750) -> float
pupil_frequency_features ¶
pupil_frequency_features(data: Any, by: Sequence[str] = ('person_id', 'trial_id'), time: str = 'time_ms', pupil: str = 'pupil_bc', sampling_rate_hz: Any = 60, low_band: Sequence[float] = (0.05, 0.5), high_band: Sequence[float] = (0.5, 4.0)) -> EyeResult
audit_pupil_frequency_stability ¶
audit_pupil_frequency_stability(data: Any, windows_ms: Sequence[float] = (500, 1000, 2000), by: Sequence[str] = ('person_id', 'trial_id'), time: str = 'time_ms', pupil: str = 'pupil_bc', sampling_rate_hz: Any = 60) -> EyeResult
pupil_response_kernel ¶
pupil_response_kernel(time_since_event_ms: Any, tmax_ms: float = 930, shape: float = 10.1, normalize: bool = True) -> np.ndarray
pupil_event_regressor ¶
pupil_event_regressor(time_ms: Any, event_time_ms: float, tmax_ms: float = 930, shape: float = 10.1) -> np.ndarray
fit_pupil_event_deconvolution ¶
fit_pupil_event_deconvolution(data: Any, by: Sequence[str] = ('person_id', 'trial_id'), time: str = 'time_ms', pupil: str = 'pupil_bc', events: Mapping[str, Any] | None = None, tmax_ms: float = 930, shape: float = 10.1, min_samples: int = 20) -> EyeResult
compare_pupil_kernels ¶
compare_pupil_kernels(data: Any, tmax_values: Sequence[float] = (512, 930), **kwargs: Any) -> pd.DataFrame
fit_pupil_confound_model ¶
fit_pupil_confound_model(data: Any, pupil: str = 'pupil_peak', luminance: str = 'screen_luminance', trial_order: str = 'trial_sequence', theta: str | None = None, person: str = 'person_id', item: str = 'item_id', engine: str = 'auto') -> EyeResult
audit_pupil_fatigue_drift ¶
audit_pupil_fatigue_drift(data: Any, pupil: str = 'pupil_peak', trial_order: str = 'trial_sequence', person: str = 'person_id', luminance: str | None = None, difficulty: str | None = None, engine: str = 'auto') -> EyeResult
filter_eye_signal ¶
filter_eye_signal(signal: Any, width: int = 9, method: str = 'auto', online: bool = True) -> EyeResult
compare_signal_filters ¶
compare_signal_filters(signal: Any, widths: Sequence[int] = (5, 9, 15), methods: Sequence[str] = ('runmed', 'robfilter')) -> pd.DataFrame
plot_eye_process_drift_audit ¶
plot_eye_process_drift_audit(x: Any, type: str = 'trajectory', metric: str | None = None, item: Any = None, ax=None)
plot_eye_pupil_frequency_features ¶
plot_eye_pupil_frequency_stability ¶
plot_eye_pupil_deconvolution ¶
plot_eye_pupil_confound_model ¶
plot_eye_process_windows ¶
plot_eye_presentation_fairness_comparison ¶
plot_pupil_spectrum ¶
plot_pupil_spectrum(signal: Any, sampling_rate_hz: float, max_hz: float | None = None, **kwargs: Any)
plot_pupil_activity_windows ¶
plot_pupil_activity_sensitivity ¶
score_partial_response_pattern ¶
score_partial_response_pattern(model: Any, response_pattern: Any, method: str = 'MAP', **kwargs: Any) -> pd.DataFrame
Score a partial response pattern using the exact frozen mirt backend.
The R implementation delegates to mirt::fscores. No Python estimator is
labelled algorithmically identical, so this route is explicitly gated.
score_response_stream ¶
score_response_stream(model: Any, response_pattern: Any, observed_order: Any = None, method: str = 'MAP', **kwargs: Any) -> EyeResult
update_person_score ¶
update_person_score(model: Any, current_pattern: Any, item_position: int, response: Any, method: str = 'MAP', **kwargs: Any) -> dict[str, Any]
collect_validation_evidence ¶
collect_validation_evidence(*args: Any, model_name: str | None = None, notes: Any = None, **evidence: Any) -> EyeResult
export_validation_bundle ¶
export_validation_bundle(x: Any, directory: str | Path, overwrite: bool = False, include_rds: bool = True) -> EyeResult
preaction_process_features ¶
preaction_process_features(data: Any, by: Sequence[str] = ('person_id', 'trial_id'), time: str = 'time_ms', response_time: str = 'response_time_ms', windows_ms: Sequence[float] = (500, 1000, 2000), aoi: str = 'aoi', pupil: str = 'pupil_bc', blink: str = 'blink') -> EyeResult
addm_glam_proxy_features ¶
addm_glam_proxy_features(data: Any, by: Sequence[str] = ('person_id', 'trial_id'), time: str = 'time_ms', aoi: str = 'aoi', target_aoi: str = 'target', distractor_aoi: str = 'distractor', action_aoi: str = 'button') -> EyeResult
assign_process_feature_family ¶
process_feature_stability ¶
process_feature_stability(data: Any, feature: str = 'feature', split: str = 'split', importance: str = 'importance', top_n: int = 20) -> pd.DataFrame
plot_eye_preaction_process_features ¶
plot_process_feature_stability ¶
plot_process_feature_stability(data: Any, feature: str = 'feature', stability: str = 'selection_rate', top_n: int = 20, **kwargs: Any)
as_eye_dataset ¶
Coerce an object to :class:EyeDataset like R as_eye_dataset().
convert_xy ¶
convert_xy(x, y, from_, to, from_width=np.nan, from_height=np.nan, to_width=np.nan, to_height=np.nan, clip=False)
Convert x/y vectors between supported two-dimensional coordinate spaces.
synchronize_eye_biometrics ¶
synchronize_eye_biometrics(gaze, biometrics, source_markers=None, target_markers=None, method='linear', resolve_ids=False)
Synchronize biometric time to gaze time and combine two eye datasets.
audit_clock_sync ¶
Audit temporal overlap between gaze and biometric streams.
build_trials ¶
build_trials(x, start_events=('TRIAL_START', 'TRIALID', 'START_TRIAL'), end_events=('TRIAL_END', 'TRIAL_RESULT', 'END_TRIAL'), event_field='event_name', trial_id_pattern=None, close_open='recording_end', overwrite=False)
Reconstruct trial intervals from event markers.
build_stimulus_intervals ¶
Build contiguous stimulus/media intervals.
assign_trials ¶
Assign trial IDs to time-stamped tables from canonical intervals.
add_responses ¶
Add canonical response rows, optionally replacing matching response keys.
build_item_responses ¶
Create response rows from trial intervals when no responses exist.
new_aoi ¶
new_aoi(aoi_id, aoi_name=None, stimulus_id=pd.NA, shape='rectangle', x=np.nan, y=np.nan, width=np.nan, height=np.nan, polygon=None, coordinate_space_id='coord_display_normalized_top_left', valid_from=-np.inf, valid_to=np.inf, frame_id=pd.NA, visible=True, parent_aoi_id=pd.NA, source='user')
Construct one rectangle, circle, or polygon AOI.
register_aois ¶
Register one or more :class:EyeAOI definitions and geometries.
assign_aois ¶
Assign registered AOIs to gaze samples or episodes.
build_aoi_visits ¶
Aggregate contiguous AOI observations into canonical visit episodes.
store_quality ¶
Store quality rows in the canonical quality table.
audit_sampling_rate ¶
Audit observed gaze sampling rate against expected rate.
audit_signal_quality ¶
audit_signal_quality(x, minimum_valid_gaze=0.8, minimum_valid_pupil=0.7, by_trial=True, store=False)
Audit valid gaze and pupil fractions.
audit_pupil_quality ¶
Audit interpolation burden and optional plausible pupil range.
audit_episodes ¶
Summarize episode counts and basic structural issues by episode type.
audit_event_order ¶
Audit event timestamp order within each recording.
audit_trial_coverage ¶
Audit canonical trial intervals and attached observations.
audit_missingness ¶
Report missing/non-finite fractions by field and grouping key.
check_process_leakage ¶
Flag feature windows extending beyond their response timestamp.
check_feature_level ¶
Check required identifying keys for each feature aggregation level.
analysis_readiness ¶
Summarize readiness across schema, time, coordinates, trials, and quality.
compare_preprocessing ¶
compare_preprocessing(*xs, metrics=('valid_gaze_fraction', 'valid_pupil_fraction', 'fixation_count'))
Compare basic quality/feature summaries across preprocessing pipelines.
compare_aoi_definitions ¶
Compare AOI assignment counts across alternative definition sets.
sensitivity_process ¶
Return the frozen preprocessing-sensitivity summary contract.
preprocess_spec ¶
preprocess_spec(gaze_filter='none', gaze_window=5, pupil_interpolation='linear', pupil_max_gap_ms=150, pupil_filter='median', pupil_window=5, pupil_baseline='subtract', pupil_baseline_window=(-0.2, 0), fixation_algorithm='none', fixation_parameters=None, blink_detection=True, exclusions=None)
Create the frozen-R preprocessing specification.
rolling_apply ¶
Centered rolling apply matching R rolling_apply().
filter_gaze ¶
filter_gaze(x, method=('median', 'mean', 'moving_median', 'moving_average', 'none'), window=5, component='gaze_samples')
Filter gaze coordinates within recording using the frozen-R contract.
flag_gaze_outliers ¶
Flag gaze outliers using MAD, velocity, or coordinate-space bounds.
interpolate_pupil ¶
Interpolate bounded pupil gaps within recording and eye.
filter_pupil ¶
Filter pupil diameter within recording and eye.
baseline_pupil ¶
baseline_pupil(x, method=('subtract', 'divide', 'percent', 'zscore', 'none'), baseline_window=(-0.2, 0), anchor=('trial_start', 'recording_start'), minimum_samples=3)
Apply trial- or recording-anchored pupil baseline correction.
pupil_deconvolve ¶
Apply the frozen exploratory discrete pupil deconvolution.
detect_blinks ¶
detect_blinks(x, min_duration_ms=50, max_duration_ms=1000, source=('pupil_missing', 'validity'), overwrite=False)
Detect blink episodes from missing pupil or validity runs.
detect_fixations_ivt ¶
detect_fixations_ivt(x, velocity_threshold=30, minimum_duration_ms=60, maximum_gap_ms=75, coordinate_units=('degrees', 'pixels', 'normalized'), overwrite=False)
Detect I-VT fixations with frozen-R threshold semantics.
detect_fixations_idt ¶
detect_fixations_idt(x, dispersion_threshold=1, minimum_duration_ms=100, coordinate_units=('degrees', 'pixels', 'normalized'), overwrite=False)
Detect I-DT fixations using the frozen-R expanding-window algorithm.
detect_saccades ¶
Detect contiguous high-velocity saccade episodes.
feature_spec ¶
feature_spec(level=('trial', 'trial_aoi', 'recording', 'participant_item'), window=None, include_post_response=False, minimum_observed_fraction=0.5, gaze=('fixation_count', 'fixation_duration', 'dwell_time', 'first_fixation_latency', 'revisits', 'entropy'), pupil=('mean', 'peak', 'auc', 'slope', 'latency_peak'), response_time=True, biometrics=True)
Create the frozen-R feature specification.
summarize_fixations ¶
summarize_fixations(x, by=('recording_id', 'trial_id', 'aoi_id'), source=('all', 'vendor', 'eyeprocess'))
Summarize fixation episodes by requested grouping fields.
scanpath_sequence ¶
scanpath_sequence(x, trial_id=None, recording_id=None, source=('visits', 'fixations', 'samples'), collapse_consecutive=True)
Return AOI sequences by recording and trial.
transition_matrix ¶
transition_matrix(x, normalize=('none', 'row', 'all'), source=('visits', 'fixations', 'samples'), include_self=False)
Return AOI transition matrix from scanpath sequences.
gaze_entropy ¶
Compute Shannon entropy of AOI occupancy.
transition_entropy ¶
Compute row-wise entropy of the normalized AOI transition matrix.
derive_gaze_features ¶
derive_gaze_features(x, level=('trial_aoi', 'trial'), source=('fixations', 'visits', 'samples'), append=True)
Derive frozen-R gaze feature rows.
derive_pupil_features ¶
Derive trial-eye pupil features.
derive_rt_features ¶
Derive response-time and score feature rows.
derive_biometric_features ¶
Derive trial-channel biometric summary features.
derive_all_features ¶
Derive gaze, pupil, RT, and biometric features using a feature spec.
features_wide ¶
features_wide(x, id_cols=('recording_id', 'participant_id', 'trial_id', 'item_id', 'stimulus_id', 'aoi_id'), aggregate=np.mean)
Pivot long canonical feature rows to one wide row per identifier combination.
write_eye_dataset ¶
Write the canonical folder format; native RDS remains an explicit backend boundary.
read_eye_dataset ¶
Read the canonical folder format written by R/Python-compatible table serialization.
write_provenance ¶
Write provenance as CSV or JSON; native RDS is explicitly gated.
report_eye_dataset ¶
report_eye_dataset(x, path='eyeprocess-report.md', title='eyeprocess data and analysis report', include_plots=False, plot_directory=None)
Write the frozen-R dataset/readiness/quality/provenance Markdown report.
report_processirt ¶
Compatibility alias for :func:report_eye_dataset.
as_eye_biometrics ¶
Coerce an EyeDataset/DataFrame to the canonical biometrics table.
format_validation_spec ¶
format_validation_spec(min_detection_confidence=0.55, require_gaze=True, require_native_time=True, require_coordinate_space=True, require_provenance=True, require_raw_retention=False, run_roundtrip=True, numeric_tolerance=1e-08, strict=False)
Construct the frozen-R empirical source-format validation specification.
eye_format_profiles ¶
Return the frozen 12-row source-format support/validation profile.
format_compatibility_matrix ¶
Return declared format capabilities plus empirical corpus tallies.
inspect_eye_source ¶
Inspect file/folder structure, delimiters, columns, hashes, and format detection.
schema_coverage ¶
Audit population of every canonical field with frozen critical-field semantics.
schema_coverage_summary ¶
Summarize detailed canonical schema coverage by table.
source_preservation_audit ¶
Audit provenance, native/normalized time, coordinate, unit, metadata, and raw retention.
fingerprint_eye_dataset ¶
Compute deterministic per-table content fingerprints.
compare_eye_datasets ¶
Compare two canonical datasets table-by-table with numeric tolerance.
roundtrip_eye_dataset ¶
Write/read the canonical folder representation and compare all tables.
validate_tobii_export ¶
Validate basic Tobii Pro Lab delimited-export structure.
validate_pupillabs_export ¶
Validate Pupil Labs Neon/Core source shape without claiming an unavailable adapter.
validate_eyelink_export ¶
Validate EyeLink ASC/Data Viewer shape and explicitly flag EDF conversion.
validate_smi_export ¶
Validate SMI/BeGaze textual exports; proprietary IDF remains unsupported.
validate_generic_export ¶
Validate readability and inferability of a generic mapped delimited export.
validate_eye_source ¶
validate_eye_source(path, vendor='auto', spec=None, import_args=None, retain_dataset=False, case_id=None)
Run frozen-R source inspection, import, canonical audits, and round-trip checks.
validation_manifest ¶
validation_manifest(paths, vendor='auto', format_family=pd.NA, software_version=pd.NA, device_model=pd.NA, expected_import=True, require_gaze=True, require_native_time=True, require_coordinate_space=True, require_provenance=True, require_raw_retention=False, run_roundtrip=True, case_id=None, notes=pd.NA)
Construct an empirical validation-corpus manifest.
read_validation_manifest ¶
Read and validate a corpus manifest, resolving relative source paths.
init_validation_corpus ¶
Initialize the private real-export validation-corpus template.
discover_validation_cases ¶
Discover file/directory validation cases under a corpus directory.
validate_eye_corpus ¶
validate_eye_corpus(manifest, spec=None, import_args=None, retain_datasets=False, stop_on_failure=False)
Validate every real-export case in a manifest/corpus.
anonymize_eye_dataset ¶
anonymize_eye_dataset(x, drop_raw=True, strip_source_paths=True, redact_free_text=True, anonymize_aois=True, retain_map=False, participant_prefix='P', recording_prefix='R', session_prefix='S')
Linked-identifier anonymization matching the frozen R table/linkage policy.
write_format_validation_report ¶
Write a Markdown report for one validation result or a validation corpus.
create_validation_bundle ¶
create_validation_bundle(x, path='eyeprocess-validation-bundle.zip', include_dataset=True, anonymize=True, overwrite=False)
Create the frozen validation evidence bundle as a ZIP archive.
read_gazepoint_summary ¶
Parse a Gazepoint Analysis Data Summary export.
Ports frozen R read_gazepoint_summary(): the first two metadata lines
are retained, and the AOI Summary and AOI Statistics (for each user)
CSV blocks are returned separately without collapsing vendor columns.
read_gazepoint_aoi_statistics ¶
read_gazepoint_aoi_statistics(path: str | Path, participant_id: str | None = None, recording_id: str | None = None, session_id: str = 'S001', keep_raw: bool = True, quiet: bool = False, **kwargs: Any)
Import Gazepoint AOI statistics or a Gazepoint Data Summary export.
gazepoint_workflow_spec ¶
gazepoint_workflow_spec(expected_sampling_rate=60, sampling_tolerance_hz=5, minimum_valid_gaze=0.8, minimum_valid_pupil=0.7, pupil_interpolation='linear', pupil_max_gap_ms=150, pupil_filter='median', pupil_window=5, pupil_baseline='none', pupil_baseline_window=(0, 0.5), detect_blinks=True, biometric_channels=('eda', 'skin_conductance_level', 'skin_conductance_response', 'heart_rate', 'interbeat_interval', 'engagement_dial'), create_plots=True, create_html_report=True, retain_raw=True)
Create the declarative integrated Gazepoint workflow specification.
build_gazepoint_media_trials ¶
Reconstruct contiguous Gazepoint media presentations as trial intervals.
derive_gazepoint_workflow_features ¶
Derive the frozen R workflow's trial/AOI/process feature collection.
gazepoint_analysis_tables ¶
Build person-by-item-by-trial analysis tables.
gazepoint_irt_tables ¶
Create response/process tables without fitting an IRT model.
plot_gazepoint_workflow ¶
Create the workflow plot suite and return a plot manifest.
write_gazepoint_workflow_report ¶
Write the reproducible workflow Markdown report and optional HTML copy.
validate_gazepoint_workflow ¶
Validate structural and reproducibility invariants of workflow output.
run_gazepoint_workflow ¶
run_gazepoint_workflow(path, output_dir=None, responses=None, score_key=None, item_map=None, spec=None, overwrite=False, quiet=False)
Run the complete frozen-R Gazepoint downstream workflow.
eye_storage_spec ¶
eye_storage_spec(path, format=('rds', 'parquet', 'arrow_dataset'), tables=None, partitioning=None, compression='zstd')
Specify disk-backed storage using the frozen R/020 contract.
write_eye_storage ¶
write_eye_storage(x, path, format=('rds', 'parquet', 'arrow_dataset'), tables=None, partitioning=None, compression='zstd', overwrite=False, retain_metadata=True)
Write canonical tables to Parquet/Arrow storage.
The R rds route is an explicit backend boundary in Python.
open_eye_storage ¶
Open a storage handle without collecting all canonical tables.
collect_eye_storage ¶
Collect a disk-backed storage handle into an EyeDataset.
export_eye_bids ¶
export_eye_bids(x, path, task='task', dataset_name='eyeprocess eye-tracking dataset', overwrite=False, screen_distance_m=None, screen_size_m=None)
Export Eye-Tracking-BIDS physiological files and sidecars.
import_eye_bids ¶
Import Eye-Tracking-BIDS physiological recordings.
vendor_validation_spec ¶
vendor_validation_spec(required_vendors=('gazepoint', 'tobii', 'pupillabs', 'eyelink', 'smi'), min_cases_per_vendor=2, min_pass_rate=0.95, require_versions=True, require_devices=True, require_independent_sources=True, require_licence_reviewed=True)
Specify multi-vendor empirical validation requirements.
audit_vendor_validation ¶
Audit a multi-vendor validation corpus using the frozen R rules.
write_vendor_validation_report ¶
Write the frozen multi-vendor validation Markdown report.
model_validation_spec ¶
model_validation_spec(replications=100, confidence=0.95, max_abs_bias=0.1, min_coverage=0.9, max_failure_rate=0.05)
Specify a Monte Carlo model-validation programme.
run_model_validation ¶
run_model_validation(simulator: Callable[..., Any], fitter: Callable[[Any], Any], extractor: Callable[[Any], Any], truth_extractor: Callable[[Any], Any], grid=None, spec=None, seed=1, continue_on_error=True)
Run parameter recovery, coverage, and failure validation.
model_validation_summary ¶
Summarize scenario-by-parameter model-validation metrics.
advanced_model_evidence_spec ¶
advanced_model_evidence_spec(models=_DEFAULT_ADVANCED_MODELS, require_recovery=True, require_calibration=True, require_misspecification=True, require_grouped_validation=True, require_engine_equivalence=True, require_empirical_reproduction=True, require_sensitivity=True)
Specify evidence required to promote advanced model interfaces.
audit_advanced_model_evidence ¶
Audit the independent evidence required for advanced-model promotion.
write_advanced_model_evidence_report ¶
Write the frozen advanced-model scientific-evidence Markdown report.
simulation_based_calibration ¶
simulation_based_calibration(simulator: Callable[..., Any], fitter: Callable[[Any], Any], posterior_draws: Callable[[Any], Any], truth_extractor: Callable[[Any], Any], replications=100, seed=1, **kwargs)
Run the frozen simulation-based calibration harness.
raven_reproduction_spec ¶
raven_reproduction_spec(data_path, response, strategy_features, published_targets=None, licence_reviewed=False, citation='10.1016/j.intell.2023.101782')
Specify the licence-gated published Raven strategy reproduction.
run_raven_reproduction ¶
run_raven_reproduction(spec, importer: Callable[[str], Any], fitter: Callable[[Any, _RavenReproductionSpec], Any], extractor: Callable[[Any], Any], tolerance=0.05)
Execute a licensed published-model reproduction.
grouped_folds ¶
Create grouped folds so declared independent groups never cross folds.
grouped_cv ¶
grouped_cv(data: DataFrame, formula, family=None, group='participant_id', v=5, metric='log_loss', seed=1)
Evaluate a GLM with grouped cross-validation.
crossed_grouped_folds ¶
Create cross-classified folds with a deliberate mixed-level buffer.
crossed_grouped_cv ¶
crossed_grouped_cv(data: DataFrame, formula, family=None, groups=('participant_id', 'item_id'), v=5, metric='log_loss', seed=1)
Evaluate a GLM with cross-classified grouped cross-validation.
quantify_process_leakage ¶
quantify_process_leakage(data: DataFrame, formula, group=('participant_id', 'item_id'), v=5, seed=1)
Compare row-wise and progressively stricter grouped validation schemes.
preprocessing_multiverse ¶
Run the frozen-R preprocessing/AOI multiverse contract.
benchmark_eyeprocess ¶
Benchmark a zero-argument operation using elapsed time and result size.
reporting_guideline_audit ¶
Audit the twelve frozen eye-tracking reporting-guideline sections.
write_reporting_guideline_report ¶
Write the frozen reporting-guideline Markdown audit.
create_public_benchmark ¶
Create the frozen de-identified canonical public benchmark bundle.
write_software_paper_scaffold ¶
write_software_paper_scaffold(path, title='eyeprocess: Reproducible Psychometric Process Modelling in R', author='Stefanos Balaskas')
Write the frozen methodological software-paper R Markdown scaffold.
run_eyeprocess_validation_program ¶
run_eyeprocess_validation_program(corpus, output_dir, model_jobs=None, sbc_jobs=None, engine_jobs=None, reproduction_jobs=None, grouped_jobs=None, leakage_jobs=None, multiverse_jobs=None, benchmark_jobs=None, reporting_dataset=None, public_benchmark_dataset=None, public_benchmark_include_samples=False, advanced_evidence=None, evidence_spec=None, overwrite=False)
Run the complete frozen R/021 validation-release programme.
R's internal saveRDS checkpoints are emitted as transparent JSON
snapshots in Python. No non-R data is written under an .rds extension.
validation_seed ¶
Allocate a deterministic validation seed from design contents.
validation_job_plan ¶
validation_job_plan(grid=None, replications=100, base_seed=1, model_family='unspecified', plan_id=None, chunk_size=1, metadata=None)
Create a deterministic research-scale validation job plan.
write_validation_job_manifest ¶
Write the validation manifest using transparent Python JSON.
read_validation_job_manifest ¶
Read a Python validation manifest created by this source port.
split_validation_plan ¶
Split a validation plan into independent chunk-specific plans.
run_validation_jobs ¶
run_validation_jobs(plan, simulator, fitter, extractor, truth_extractor, output_dir, workers=1, backend=('auto', 'sequential', 'future'), isolation=('auto', 'in_process', 'callr'), timeout_seconds=math.inf, memory_limit_mb=math.inf, stale_lock_seconds=3600, overwrite=False, fail_fast=False, progress=False, job_ids=None, chunks=None, simulation_args=None, fit_args=None, diagnostics_extractor=None, draws_extractor=None, predictions_extractor=None, confidence=0.95, run_metadata=None)
Run deterministic validation jobs with checkpointing and resume safety.
resume_validation_jobs ¶
resume_validation_jobs(plan, output_dir, retry=('missing', 'failed', 'nonconverged', 'locked', 'corrupt'), **kwargs)
Resume only missing or explicitly retryable validation jobs.
collect_validation_jobs ¶
Collect JSON validation checkpoints from one or more directories.
prune_validation_checkpoints ¶
Report or delete checkpoints with selected execution statuses.
validation_recovery_summary ¶
Summarize parameter bias, RMSE, coverage, and standard-error recovery.
validation_failure_summary ¶
Summarize execution failures, nonconvergence, locks, and warnings.
validation_runtime_summary ¶
Summarize validation runtime by model family/scenario.
validation_calibration_summary ¶
Summarize binary prediction calibration, Brier/log loss, and ECE.
validation_sbc_summary ¶
Summarize simulation-based-calibration scaled ranks.
validation_thresholds ¶
validation_thresholds(required_replications=100, max_failure_rate=0.05, max_absolute_bias=0.1, max_rmse=math.inf, min_coverage=0.9, max_coverage=0.99, max_rhat=1.01, min_ess_bulk=400, max_divergence_rate=0.01, require_sbc=True, require_empirical_reproduction=True)
Specify completion and scientific-promotion thresholds.
audit_validation_completion ¶
Audit whether the validation programme passes frozen completion gates.
plot_parameter_recovery ¶
Plot estimated versus true parameter values.
plot_interval_coverage ¶
Plot observed interval coverage against a nominal target.
plot_sbc_rank ¶
Plot simulation-based-calibration scaled-rank histograms.
plot_validation_failures ¶
Plot validation failure rates.
plot_validation_runtime ¶
Plot per-job validation runtime.
model_promotion_spec ¶
model_promotion_spec(model_families=('dynamic_irtree', 'functional_pupil_irt', 'theory_strategy_irt', 'gaze_diffusion_irt'), require_completion=True, require_sbc=True, require_misspecification=True, require_grouped_validation=True, require_engine_equivalence=True, require_empirical_reproduction=True, require_preprocessing_sensitivity=True, require_multi_vendor=False)
Declare required scientific evidence before model promotion.
audit_model_promotion ¶
Audit promotion readiness for each declared advanced-model family.
write_validation_release_report ¶
write_validation_release_report(x, path, completion=None, promotion=None, title='eyeprocess validation release report', include_session=True)
Write the frozen validation release-report structure as Markdown.
write_model_promotion_report ¶
Write a Markdown report for an advanced-model promotion audit.
partition_eye_storage ¶
partition_eye_storage(by=('participant_id', 'session_id', 'recording_id'), format=('parquet', 'csv', 'rds'), compression='zstd', max_rows=1000000)
Create a partition specification using frozen R/028 semantics.
upgrade_eye_dataset ¶
Upgrade a legacy EyeDataset to the stable 2.0.0 object contract.
write_partitioned_eye_storage ¶
Write named tables as fingerprinted, atomically committed partitions.
open_partitioned_eye_storage ¶
Open a partitioned storage handle without collecting its tables.
query_eye_storage ¶
Query one partitioned table, returning a lazy Dataset when requested.
validate_eye_storage_metadata ¶
Validate partition existence, byte sizes, and MD5 fingerprints.
detect_corrupt_partitions ¶
Return partitions that are missing, truncated, or fingerprint-modified.
storage_transaction_manifest ¶
Return a copy of the storage transaction manifest.
migrate_eye_storage_schema ¶
migrate_eye_storage_schema(storage, target_path, target_version='2.0.0', format=None, overwrite=False)
Collect a store and atomically rewrite it under storage schema 2.0.0.
benchmark_eye_storage ¶
benchmark_eye_storage(x, formats=('rds', 'csv', 'parquet'), partition_by=('participant_id', 'recording_id'), repetitions=3, directory=None)
Benchmark supported partitioned-storage routes.
Python deliberately excludes native RDS from execution rather than benchmarking a non-R serialization under an RDS label.
eyeprocess_benchmark_study ¶
Locate the frozen synthetic multimodal benchmark and read its manifest.
read_benchmark_table ¶
read_benchmark_table(study: EyeBenchmarkStudy | str | Path | None = None, table: str | None = None) -> pd.DataFrame
Read one benchmark table with stable logical-column restoration.
benchmark_expected_outputs ¶
Read frozen benchmark reproduction targets and tolerances.
import_benchmark_study ¶
Import benchmark tables, preferring the canonical EyeDataset constructor when compatible.
validate_benchmark_study ¶
validate_benchmark_study(study: EyeBenchmarkStudy | str | Path | None = None, verify_hashes: bool = True) -> EyeBenchmarkValidation
Validate benchmark file integrity, fingerprints, and cross-table relations.
run_benchmark_reproduction ¶
run_benchmark_reproduction(study: EyeBenchmarkStudy | str | Path | None = None) -> EyeBenchmarkReproduction
Recompute the frozen deterministic benchmark summary and compare it with reference outputs.
write_benchmark_data_dictionary ¶
write_benchmark_data_dictionary(study: EyeBenchmarkStudy | str | Path | None = None, path: str | Path = 'benchmark-data-dictionary.md') -> str
Write the benchmark data dictionary as Markdown.
package_reproducibility_manifest ¶
package_reproducibility_manifest(paths: str | Path | Iterable[str | Path], include_session: bool = True) -> EyeReproducibilityManifest
Fingerprint files and capture a Python runtime/session record for reproducibility.
verify_reproducibility_manifest ¶
verify_reproducibility_manifest(manifest: EyeReproducibilityManifest | Mapping[str, object]) -> pd.DataFrame
Verify that every file recorded in a reproducibility manifest is unchanged.
write_software_paper_reproduction ¶
write_software_paper_reproduction(directory: str | Path, study: EyeBenchmarkStudy | str | Path | None = None, overwrite: bool = False) -> EyeReproducibilityManifest
Create a self-contained Python reproduction scaffold around the frozen benchmark.
audit_benchmark_release ¶
Audit whether benchmark assets are ready for public release.
is_tobii_export ¶
Return a confidence score for Tobii Pro Lab-style delimited exports.
read_tobii ¶
read_tobii(path, participant_id=None, recording_id=None, session_id='S001', time_unit='microseconds', coordinate_space='display_pixels_top_left', screen_width=np.nan, screen_height=np.nan, keep_raw=True, quiet=False, **kwargs)
Import a Tobii Pro Lab delimited export.
is_pupil_labs_export ¶
Return a confidence score for Pupil Labs Neon/Core exports.
read_pupillabs ¶
Dispatch to Pupil Labs Neon or Core importers.
read_pupil_neon ¶
read_pupil_neon(path, participant_id='P001', session_id='S001', recording_id=None, keep_raw=True, quiet=False, **kwargs)
Import Pupil Labs Neon gaze plus optional companion exports.
read_pupil_core ¶
read_pupil_core(path, participant_id='P001', session_id='S001', recording_id=None, keep_raw=True, quiet=False, **kwargs)
Import Pupil Labs Core gaze plus pupil/fixation companions.
is_eyelink_export ¶
Return a confidence score for EyeLink EDF/ASC/report exports.
read_eyelink_asc ¶
read_eyelink_asc(path, participant_id='P001', session_id='S001', recording_id=None, coordinate_space='display_pixels_top_left', screen_width=np.nan, screen_height=np.nan, keep_raw=True, quiet=False)
Import an EyeLink ASC text export.
read_eyelink_report ¶
read_eyelink_report(path, mapping=None, time_unit='milliseconds', coordinate_space='display_pixels_top_left', **kwargs)
Import an EyeLink Data Viewer delimited report.
read_eyelink_edf ¶
Convert an EDF with SR Research EDF2ASC, then import its ASC output.
is_smi_export ¶
Return a confidence score for SMI BeGaze text exports.
read_smi ¶
read_smi(path, participant_id=None, recording_id=None, session_id='S001', time_unit='microseconds', coordinate_space='display_pixels_top_left', keep_raw=True, quiet=False, **kwargs)
Import an SMI BeGaze text/ASCII export.
read_smi_raw_export ¶
Alias of :func:read_smi for SMI raw-text exports.
read_smi_event_export ¶
Alias of :func:read_smi for SMI event exports.
read_smi_aoi_export ¶
Alias of :func:read_smi for SMI AOI exports.
init_vendor_corpus ¶
Create or validate a multi-vendor validation-corpus directory.
read_vendor_registry ¶
Read the version-specific multi-vendor case registry.
write_vendor_registry ¶
Write a vendor registry using the frozen canonical column order.
fingerprint_validation_case ¶
Fingerprint every file in a real-export validation case.
register_validation_case ¶
register_validation_case(corpus_path, source_path, vendor, device_model, software_name, software_version, hardware_version=pd.NA, export_profile=pd.NA, sampling_rate_hz=np.nan, coordinate_system=pd.NA, timebase=pd.NA, event_semantics=pd.NA, ocular_structure=pd.NA, missingness_convention=pd.NA, vendor_fixations=pd.NA, package_transformations=pd.NA, unsupported_fields=pd.NA, independent_source=True, licence_reviewed=False, redistribution_allowed=False, support_level=('declared', 'fixture-tested', 'empirically-validated'), mode=('reference', 'copy'), case_id=None, notes=pd.NA)
Register a version-specific independent vendor validation case.
redact_validation_case ¶
redact_validation_case(source_path, output_path, id_columns=('participant_id', 'subject', 'participant', 'recording_id', 'session_id'), remove_columns=('name', 'email', 'address', 'birthdate', 'date_of_birth'), text_redactor: Callable[[Series, str], Any] | None = None, salt=None, copy_non_tabular=False, overwrite=False)
Redact a validation case without inventing replacement data.
register_vendor_semantics ¶
register_vendor_semantics(corpus_path, vendor, native_field, native_meaning, canonical_table, canonical_field, unit=pd.NA, transformation='identity', loss_risk=('none', 'low', 'moderate', 'high', 'unsupported'), evidence_case_id=pd.NA)
Register or update a native-to-canonical vendor semantic mapping.
compare_vendor_semantics ¶
Compare semantic mappings and report maximum canonical loss risk.
audit_roundtrip_loss ¶
Audit canonical table/field loss across an import-export round trip.
audit_vendor_field_coverage ¶
Audit vendor coverage of required canonical table/field pairs.
promote_vendor_support ¶
promote_vendor_support(corpus_path, case_id, level=('fixture-tested', 'empirically-validated'), validation=None, reviewer=None, notes=pd.NA)
Promote a case only when the required validation evidence passes.
build_compatibility_matrix ¶
build_compatibility_matrix(x, required_vendors=('gazepoint', 'tobii', 'pupillabs', 'eyelink', 'smi'), min_empirical_cases=2)
Build evidence-tiered vendor compatibility claims.
write_vendor_case_report ¶
Write a Markdown evidence report for one registered vendor case.
plot_eye_overview ¶
Plot canonical table counts, matching frozen plot_eye_overview.
plot_eye_trace ¶
plot_eye_trace(x, trial_id=None, recording_id=None, valid_only=True, reverse_y=True, main='Gaze trace', ax=None, **kwargs)
Plot selected gaze samples in timestamp order.
plot_fixations ¶
plot_fixations(x, trial_id=None, recording_id=None, source=('all', 'vendor', 'eyeprocess'), scale=0.03, reverse_y=True, main='Fixations', ax=None, **kwargs)
Plot fixation centroids with duration-scaled markers.
plot_scanpath ¶
plot_scanpath(x, trial_id=None, recording_id=None, reverse_y=True, label=True, main='Scanpath', ax=None, **kwargs)
Plot ordered AOI visits or, when unavailable, fixation centroids.
plot_gaze_heatmap ¶
plot_gaze_heatmap(x, trial_id=None, recording_id=None, bins=(50, 50), valid_only=True, main='Gaze density', ax=None, **kwargs)
Plot a two-dimensional gaze-density histogram.
plot_aoi_dwell ¶
plot_aoi_dwell(x, feature=('dwell_time_ms', 'dwell_proportion'), aggregate: Callable = np.mean, main=None, ax=None, **kwargs)
Plot AOI-level dwell feature aggregates.
plot_transition_matrix ¶
plot_transition_matrix(x, normalize=('row', 'none', 'all'), source=('visits', 'fixations', 'samples'), main='AOI transition matrix', ax=None, **kwargs)
Plot the canonical AOI transition matrix.
plot_pupil_timeseries ¶
plot_pupil_timeseries(x, trial_id=None, recording_id=None, eye=None, column='pupil_diameter', main='Pupil time series', ax=None, **kwargs)
Plot pupil observations by recording × eye group.
plot_biometrics ¶
plot_biometrics(x, channels=None, trial_id=None, recording_id=None, main='Biometric streams', ax=None, **kwargs)
Plot selected biometric channels on a shared time axis.
plot_signal_quality ¶
Plot signal-quality fractions returned by audit_signal_quality.
plot_sampling_rate ¶
Plot estimated gaze sampling rates.
plot_missingness ¶
plot_missingness(x, component=('gaze_samples', 'eye_samples', 'biometrics'), top=20, main=None, ax=None, **kwargs)
Plot mean missing fraction by field for one canonical component.
plot_trial_timeline ¶
Plot trial start/end intervals.
plot_feature_distribution ¶
Plot one feature as a histogram or grouped boxplot.
plot_feature_correlation ¶
Plot pairwise feature correlations from features_wide.
plot_coordinate_spaces ¶
Plot canonical coordinate-space usage counts.
plot_clock_alignment ¶
Plot gaze and biometric clock overlap by recording.
plot_item_difficulty ¶
Plot item difficulty from an eyeprocess model.
plot_model_diagnostics ¶
Plot generic fitted-versus-residual diagnostics when available.
eye_plot_spec ¶
eye_plot_spec(type='default', title=None, xlab=None, ylab=None, caption=None, show_uncertainty=True, show_raw=True, facet_by=None, label_items=False, interactive=False)
Create the frozen shared eyeprocess plot specification.
plot_diagnostics ¶
Plot diagnostic evidence, using class-specific dispatch when available.
plot_evidence ¶
Plot scientific evidence, using class-specific dispatch when available.
plot_sensitivity ¶
Plot sensitivity evidence, using class-specific dispatch when available.
autoplot_eyeprocess ¶
Autoplot-compatible wrapper around eyeprocesspy plot dispatch.
assign_aois_probabilistic ¶
assign_aois_probabilistic(x, aois, error_model=('empirical', 'gaussian', 'ellipse'), accuracy=None, precision=None, x_col=None, y_col=None, id_cols=None)
Assign gaze samples to rectangular AOIs probabilistically.
audit_aoi_separation ¶
Audit pairwise AOI overlap, touching boundaries, and separation.
summarise_aoi_membership ¶
Summarise mean AOI membership probabilities.
propagate_aoi_uncertainty ¶
propagate_aoi_uncertainty(x, metrics=('dwell', 'ttff', 'transitions', 'entropy'), draws=500, time_col=None, duration_col=None, seed=20260807)
Propagate probabilistic AOI membership to process metrics by Monte Carlo.
plot_aoi_probability_map ¶
Plot gaze samples with AOI rectangles and membership certainty.
plot_aoi_boundary_risk ¶
Plot mean assignment ambiguity or AOI-pair overlap area.
plot_probabilistic_scanpath ¶
Plot the gaze trajectory underlying a probabilistic AOI fit.
plot_fuzzy_transition_matrix ¶
Plot expected adjacent-state transitions under AOI uncertainty.
plot_aoi_metric_uncertainty ¶
Plot Monte Carlo distributions for propagated AOI process metrics.
derive_aoi_composition ¶
derive_aoi_composition(x, aois, denominator=('total_aoi_dwell', 'trial_duration'), zero_method=('multiplicative', 'bayesian'), id_cols=None, aoi_col='aoi', value_col='dwell_ms', trial_duration_col=None)
Derive a closed AOI dwell composition from wide or long data.
transform_aoi_composition ¶
Transform a composition using ILR, CLR, or ALR coordinates.
fit_aoi_compositional_model ¶
Fit the frozen fixed-effects compositional AOI regression contract.
compare_aoi_compositions ¶
compare_aoi_compositions(x, group, method=('permanova', 'compositional_manova'), permutations=499, seed=20260807)
Compare AOI compositions with the frozen pseudo-F permutation scheme.
aoi_balance_coordinates ¶
Calculate user-defined AOI balance coordinates.
plot_aoi_ternary ¶
Plot a three-part AOI dwell composition on a ternary simplex.
plot_aoi_balance_biplot ¶
Plot a CLR-PCA compositional balance biplot.
plot_aoi_variation_matrix ¶
Plot pairwise variance of AOI log-ratios.
plot_compositional_group_difference ¶
Plot group centroid differences from a composition comparison.
plot_aoi_composition_trajectory ¶
Plot ordered AOI composition trajectories.
plot_pupil_preprocessing_audit ¶
plot_pupil_preprocessing_audit(data, time='time_ms', signals=('pupil_raw', 'pupil_interpolated', 'pupil_smoothed', 'pupil_bc'), ax=None, **kwargs)
Plot frozen raw-to-processed pupil preprocessing stages.
plot_pupil_components ¶
plot_pupil_components(data, time='time_ms', smoothed='pupil_smoothed', tonic='pupil_tonic', phasic='pupil_phasic', ax=None, **kwargs)
Plot tonic/phasic pupil components via the frozen preprocessing helper.
plot_aoi_transition_matrix ¶
Plot the frozen AOI transition matrix representation.
plot_aoi_transition_rank ¶
plot_aoi_transition_rank(data, from_col='from', to_col='to', normalize='from', top_n=20, ax=None, **kwargs)
Plot the highest-ranked AOI transitions by probability or count.
plot_process_channel_ablation_delta ¶
plot_process_channel_ablation_delta(x=None, table=None, channel_col='channel', metric_col='metric', value_col='value', full_label='full', metric=None, ax=None, **kwargs)
Plot frozen channel-ablation differences from a full/reference model.
simulation_rank_statistic ¶
Compute the frozen simulation-based calibration rank statistic.
Ties are randomized uniformly over ranks less through
less + equal. Seeded NumPy draws preserve the frozen algorithm and
seed contract, but are not claimed to reproduce R's RNG stream exactly.
sbc_rank_diagnostics ¶
Build frozen SBC rank diagnostics.
sbc_ecdf_deviation ¶
Return the frozen maximum ECDF deviation for SBC ranks.
coverage_calibration_curve ¶
Build the frozen interval coverage calibration curve.
measurement_error_budget ¶
measurement_error_budget(accuracy=math.nan, precision=math.nan, data_loss=math.nan, effective_hz=math.nan, calibration_drift=math.nan, units=None)
Build the frozen non-collapsed measurement-error budget.
analysis_resolution_guard ¶
analysis_resolution_guard(event_duration_ms, effective_hz, spatial_feature_size=math.nan, radial_error=math.nan, min_samples=3, max_error_fraction=0.5)
Audit compatibility between measurement resolution and analysis target.
audit_pupil_preprocessing_order ¶
audit_pupil_preprocessing_order(steps, cleaning_patterns=('blink', 'missing', 'interpol', 'artifact', 'smooth', 'filter'), baseline_pattern='baseline')
Audit the declared order of pupil preprocessing steps.
pupil_baseline_sensitivity ¶
pupil_baseline_sensitivity(data, time='time_ms', pupil='pupil', windows=None, by=None, correction='subtractive')
Evaluate frozen pupil baseline-window sensitivity.
process_feature_time_provenance ¶
process_feature_time_provenance(feature, available_at, outcome_at, source=None, transformation=None, unit='ms')
process_negative_control_permute ¶
run_process_negative_controls ¶
run_process_negative_controls(data, outcome, analysis_fun, controls=('permutation', 'shift'), replications=100, seed=1, extract_fun=None, shift_lags=(-3, -2, -1, 1, 2, 3), within=None)
summarise_process_negative_controls ¶
eye_benchmark_design ¶
Define a computational benchmark design.
run_eye_benchmark ¶
Run the frozen computational scaling-benchmark workflow.
summarise_eye_benchmark ¶
Summarise benchmark timing and memory by problem size.
benchmark_scaling_curve ¶
Estimate the log-log scaling exponent from benchmark results.
benchmark_memory_estimate ¶
Estimate recursive Python memory for an object or generated size.
synthetic_corruption_plan ¶
synthetic_corruption_plan(missingness=0, pupil_dropout=0, gaze_offset_x=0, gaze_offset_y=0, sampling_jitter_sd=0, aoi_label_noise=0, device_shift=0, trial_drop=0, seed=1)
Define explicit synthetic measurement corruptions.
inject_eye_missingness ¶
Inject generic missingness into selected columns.
inject_pupil_dropout ¶
Inject pupil dropout.
inject_calibration_offset ¶
Inject additive gaze calibration offset.
inject_sampling_jitter ¶
Inject Gaussian timestamp jitter.
inject_aoi_label_noise ¶
Randomly reassign a proportion of observed AOI labels.
inject_device_shift ¶
Inject an additive device/site shift in a numeric feature.
inject_trial_imbalance ¶
Inject row/trial imbalance by dropping observations.
apply_synthetic_corruption ¶
apply_synthetic_corruption(data, plan, gaze_columns=('gaze_x', 'gaze_y'), pupil='pupil', time='timestamp_ms', aoi=None, device_column=None)
Apply one explicit synthetic corruption plan.
stress_test_process_pipeline ¶
Stress-test an analysis under explicit synthetic corruptions.
stress_tolerance_frontier ¶
Identify the empirical stress frontier for a metric.
file_hash_manifest ¶
Build a file hash manifest.
analysis_environment_snapshot ¶
Snapshot the active Python analysis environment.
eye_session_manifest ¶
eye_session_manifest(data=None, files=None, adapter=None, decisions=None, pipeline=None, seeds=None, notes=None)
Create a session-level provenance manifest.
eye_reproducibility_fingerprint ¶
eye_reproducibility_fingerprint(data=None, analysis_spec=None, model_spec=None, decisions=None, result=None, files=None, seeds=None, label='eyeprocess_analysis')
Construct a reproducibility fingerprint.
compare_reproducibility_fingerprints ¶
Compare two reproducibility fingerprints.
verify_reproducibility_fingerprint ¶
Verify an internally stored fingerprint hash.
write_reproducibility_fingerprint ¶
Write a fingerprint; JSON is native, RDS/dput remain R-specific.
read_reproducibility_fingerprint ¶
Read a JSON fingerprint; RDS/dput inputs remain R-specific.
provenance_lineage_table ¶
Build a provenance lineage node table.
provenance_edge_table ¶
Build a provenance edge table.
eye_prov_graph ¶
Construct a lightweight provenance graph.
export_ro_crate_metadata ¶
export_ro_crate_metadata(path='ro-crate-metadata.json', name='eyeprocess analysis', description='Reproducible eyeprocess analysis crate', files=None, creator=None, license=None, doi=None)
Export minimal RO-Crate 1.3 metadata.
software_paper_evidence_bundle ¶
software_paper_evidence_bundle(claims=None, validation=None, examples=None, articles=None, benchmarks=None, reproducibility=None, metadata=None)
Construct a software-paper evidence bundle.
software_paper_claim_matrix ¶
software_paper_claim_matrix(claim, evidence_id=None, evidence_type=None, status='pending', scope=None, source=None)
Create or normalize a software-paper claim matrix.
software_paper_validation_table ¶
Summarise validation evidence for a software paper.
software_paper_coverage ¶
Compute descriptive evidence coverage.
software_paper_readiness ¶
software_paper_readiness(x, required_statuses=('supported', 'qualified'), require_validation=True, require_reproducibility=True, require_examples=True, require_articles=True)
Run the frozen descriptive readiness completeness audit.
software_paper_gap_analysis ¶
Identify gaps in a software-paper evidence bundle.
freeze_software_paper_evidence ¶
Freeze evidence as Python-native JSON and return its MD5 manifest.
write_software_paper_evidence ¶
Write the frozen human-readable evidence audit report.
paper_reproducibility_manifest ¶
Create the compact frozen paper reproducibility manifest.
eyeprocess_validation_plan ¶
eyeprocess_validation_plan(families=_ALLOWED_FAMILIES, sample_size=(250, 750), n_items=(12, 24), missing_rate=(0.0, 0.15), noise_level=('reference', 'elevated'), specification=_ALLOWED_SPECIFICATION, replications=20, seed=20260811, label='eyeprocess-0.9-m2')
Declare the frozen deterministic validation-evidence plan.
validate_eyeprocess_validation_plan ¶
Validate the structural contract of a validation-evidence plan.
eyeprocess_validation_seed ¶
Derive the frozen deterministic bounded validation seed.
expand_eyeprocess_validation_plan ¶
Expand a validation plan using R expand.grid row ordering.
validation_acceptance_rule ¶
Define one frozen validation acceptance rule.
evaluate_validation_acceptance ¶
Evaluate one value against a frozen acceptance rule.
validation_acceptance_matrix ¶
Evaluate a validation summary table against named rules.
summarise_validation_acceptance ¶
Summarise a frozen acceptance matrix.
validation_mcse_profile ¶
Estimate Monte Carlo uncertainty for validation summaries.
validation_replication_budget ¶
Compute the frozen replication budget from target MCSE.
validation_scenario_manifest ¶
Create a frozen validation scenario manifest.
write_validation_scenario_manifest ¶
Persist a validation scenario manifest as Python-native JSON.
read_validation_scenario_manifest ¶
Read a Python-native validation scenario manifest.
eyeprocess_validation_evidence_grade ¶
eyeprocess_validation_evidence_grade(components, required=('design', 'execution', 'summary', 'provenance', 'hash'))
Grade completeness of declared validation-evidence components.
eyeprocess_stress_evidence_plan ¶
eyeprocess_stress_evidence_plan(missing_gaze=(0, 0.05, 0.15, 0.3), pupil_dropout=(0, 0.05, 0.15), calibration_offset=(0, 0.01, 0.03, 0.06), sampling_jitter=(0, 0.05, 0.15), aoi_label_noise=(0, 0.02, 0.1), device_shift=(0, 0.02, 0.05), trial_imbalance=(0, 0.1, 0.25), seed=20260811)
Declare the frozen one-factor-at-a-time stress-evidence plan.
expand_eyeprocess_stress_evidence_plan ¶
Expand a stress plan in frozen R family/value order.
eyeprocess_reliability_evidence_plan ¶
Declare frozen reliability-evidence targets.
eyeprocess_negative_control_evidence_plan ¶
eyeprocess_negative_control_evidence_plan(controls=_NEGATIVE_CONTROLS, replications=100, seed=20260811)
Declare frozen negative-control evidence targets.
eyeprocess_validation_claim_matrix ¶
eyeprocess_validation_claim_matrix(claim_id, claim, evidence_id, evidence_type, status='qualified', boundary=None)
Build the frozen machine-readable claim/evidence matrix.
eyeprocess_validation_evidence_manifest ¶
eyeprocess_validation_evidence_manifest(files=(), objects=(), source_commit=None, label='eyeprocess-0.9-m2')
Create the frozen evidence manifest from files and objects.
freeze_eyeprocess_validation_evidence ¶
freeze_eyeprocess_validation_evidence(design, recovery=None, sbc=None, stress=None, reliability=None, negative_controls=None, irt=None, claims=None, provenance=None, source_commit=None)
Freeze a complete validation-evidence bundle with integrity hash.
verify_eyeprocess_validation_evidence ¶
Verify the integrity hash of a frozen evidence bundle.
write_eyeprocess_validation_evidence ¶
Write frozen validation evidence as deterministic JSON.
read_eyeprocess_validation_evidence ¶
Read a Python-native frozen validation-evidence JSON file.
eyeprocess_validation_readiness ¶
eyeprocess_validation_readiness(x, required=('design', 'recovery', 'stress', 'reliability', 'negative_controls', 'claims', 'provenance'))
Evaluate readiness of a frozen validation-evidence bundle.
eyeprocess_validation_release_gate ¶
Apply the frozen conservative software-release evidence gate.
run_eyeprocess_stress_evidence ¶
Execute the frozen measurement-stress evidence programme.
summarise_eyeprocess_stress_evidence ¶
Summarise executed measurement-stress evidence.
event_marker_qc ¶
event_marker_qc(offsets: Sequence[float], *, tolerance: float, expected_direction: str | None = None, effects: Sequence[float] | None = None, min_corroborating: int = 2) -> dict
Assess event-marker plausibility from independent channel offsets.
This is annotation/event plausibility QC, not hardware-clock synchronization. It reports consensus offset and uncertainty without modifying timestamps.
pupil_latency_sensitivity ¶
pupil_latency_sensitivity(time: Sequence[float], pupil: Sequence[float], *, event_time: float = 0.0, baseline_window: tuple[float, float] = (-0.5, 0.0), search_window: tuple[float, float] = (0.0, 2.0), direction: str = 'constriction', threshold_sigma: float = 3.0, sustain_ms: float = 40.0, simulations: int = 200, seed: int = 1) -> dict
Estimate pupil-response latency with estimator-disagreement diagnostics.
Returns several defensible onset estimates rather than presenting one latency as hardware- and algorithm-independent. A parametric resampling audit then characterizes resolvability under the observed sampling/noise regime.
validation_ladder ¶
Summarize evidence from acquisition QC through held-out-person validation.
eyeprocess_recovery_evidence_table ¶
Build the frozen paper-ready parameter-recovery table.
eyeprocess_sbc_evidence_table ¶
Build the frozen paper-ready simulation-calibration table.
eyeprocess_stress_evidence_table ¶
Build the frozen paper-ready stress-test table.
eyeprocess_reliability_evidence_table ¶
Build the frozen paper-ready reliability table.
eyeprocess_negative_control_evidence_table ¶
Build the frozen paper-ready negative-control table.
eyeprocess_irt_precision_evidence_table ¶
Build the frozen IRT information/precision evidence table.
eyeprocess_irt_engine_evidence_table ¶
Build the frozen external-engine capability table.
eyeprocess_validation_evidence_index ¶
Create the frozen index over validation evidence artifacts.
eyeprocess_validation_evidence_atlas ¶
eyeprocess_validation_evidence_atlas(claims, recovery=None, sbc=None, stress=None, reliability=None, negative_controls=None, irt=None, provenance=None, artifacts=None)
Assemble the frozen organizational validation evidence atlas.
eyeprocess_validation_atlas_gaps ¶
Summarize missing components and unresolved claims.
freeze_eyeprocess_validation_atlas ¶
Freeze an evidence atlas with a deterministic integrity hash.
verify_eyeprocess_validation_atlas ¶
Verify a frozen validation atlas integrity hash.
write_eyeprocess_validation_report ¶
Write the frozen compact Markdown validation report.