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.
CANONICAL_GAZE_SURVIVAL_COLUMNS
module-attribute
¶
CANONICAL_GAZE_SURVIVAL_COLUMNS = ['participant_id', 'trial_id', 'stimulus_id', 'condition', 'target_aoi', 'time_origin', 'event_time', 'censor_time', 'analysis_time', 'event_observed', 'event_type', 'n_valid_samples', 'valid_data_fraction', 'trial_duration']
__all__
module-attribute
¶
__all__ = ['exceptions', 'schema', 'dataset', 'mapping', 'timebase', 'importers', 'adapters', 'combine_eye_datasets', 'detect_eye_format', 'read_eye_export', 'read_eye_folder', 'register_eye_adapter', 'remap_recording_ids', 'supported_eye_formats', 'unregister_eye_adapter', 'coordinates', 'audit_coordinate_spaces', 'convert_coordinates', 'coordinate_space', 'register_coordinate_space', 'EyeDataset', 'add_provenance', 'append_eye_table', 'compact_eye_dataset', 'get_eye_table', 'is_eye_dataset', 'new_eye_dataset', 'provenance_manifest', 'set_eye_table', 'validate_eye_dataset', 'foundation_09', 'preprocess_features_09', 'detector_multiverse', 'DetectorInferenceResult', 'DetectorMultiverse', 'DetectorMultiverseResult', 'EventDetectorSpec', 'assess_detector_inference_stability', 'compare_event_catalogues', 'create_detector_multiverse', 'define_event_detector_spec', 'detect_events_with_spec', 'estimate_detector_agreement', 'import_external_detector_events', 'match_detected_events', 'plot_detector_agreement', 'plot_detector_coefficient_stability', 'plot_detector_event_timeline', 'plot_detector_feature_distributions', 'plot_detector_multiverse', 'propagate_detector_to_aoi', 'propagate_detector_to_features', 'report_detector_multiverse', 'run_detector_inference_multiverse', 'run_detector_multiverse', 'simulate_detector_multiverse_data', 'summarise_detector_disagreement', 'summarise_detector_events', 'summarise_detector_robustness', 'validate_event_detector_spec', 'EyeProcessError', 'EyeProcessValidationError', 'EyeProcessSchemaError', 'EyeProcessTimebaseError', 'EyeProcessCoordinateError', 'EyeProcessBackendError', 'EyeProcessModelError', 'EyeProcessGovernanceError', 'gazepoint', 'gp_audit_file_pairs', 'gp_identify_export_type', 'gp_list_export_fields', 'gp_match_biometrics', 'gp_match_recordings', 'gp_pair_exports', 'gp_parse_media_events', 'gp_parse_user_events', 'gp_profile_export', 'gp_validate_export', 'is_gazepoint_export', 'read_gazepoint', 'read_gazepoint_biometrics', 'read_gazepoint_combined', 'read_gazepoint_events', 'read_gazepoint_fixations', 'read_gazepoint_folder', 'read_gazepoint_gaze', 'infer_eye_mapping', 'read_eye_generic', 'validate_eye_mapping', 'eye_mapping', 'canonical_table_names', 'empty_eye_table', 'eye_schema', 'new_coordinate_space', 'schema_table', 'standardize_eye_table', 'validate_eye_table', 'EyeClockTransform', 'align_clock', 'apply_clock_transform', 'audit_timebase', 'estimate_clock_transform', 'estimate_sampling_rate', 'normalize_timebase', 'irt', 'eyeprocess_irt_model_spec', 'validate_eyeprocess_irt_model_spec', 'eyeprocess_irt_identification_audit', 'eyeprocess_irt_sparse_design_audit', 'eyeprocess_irt_2pl_probability', 'eyeprocess_irt_3pl_probability', 'eyeprocess_irt_4pl_probability', 'eyeprocess_irt_grm_probability', 'eyeprocess_irt_gpcm_probability', 'eyeprocess_irt_nominal_probability', 'eyeprocess_irt_item_information', 'eyeprocess_irt_test_information', 'eyeprocess_irt_conditional_sem', 'eyeprocess_irt_expected_score', 'eyeprocess_irt_test_characteristic_curve', 'eyeprocess_irt_information_area', 'eyeprocess_irt_measurement_precision_profile', 'eyeprocess_irt_item_fit_residuals', 'eyeprocess_irt_person_fit_residuals', 'eyeprocess_irt_q3', 'eyeprocess_irt_local_dependence_pairs', 'eyeprocess_irt_extreme_score_audit', 'eyeprocess_irt_threshold_order_audit', 'eyeprocess_irt_monotonicity_audit', 'eyeprocess_irt_category_function_audit', 'eyeprocess_irt_parameter_plausibility_audit', 'eyeprocess_irt_ppc_discrepancy', 'eyeprocess_irt_fit_dashboard', 'eyeprocess_irt_eap_score', 'eyeprocess_irt_map_score', 'eyeprocess_irt_mle_score', 'eyeprocess_irt_score_table', 'eyeprocess_irt_plausible_values', 'eyeprocess_irt_marginal_reliability', 'eyeprocess_irt_score_uncertainty', 'eyeprocess_irt_information_targeting', 'eyeprocess_irt_item_bank', 'validate_eyeprocess_irt_item_bank', 'eyeprocess_irt_item_selection', 'eyeprocess_irt_stopping_rule', 'eyeprocess_irt_exposure_summary', 'eyeprocess_irt_content_balance_audit', 'eyeprocess_irt_adaptive_trace', 'eyeprocess_irt_information_gain', 'eyeprocess_irt_process_aware_selection_penalty', 'eyeprocess_irt_mean_sigma_link', 'eyeprocess_irt_mean_mean_link', 'eyeprocess_irt_apply_link', 'eyeprocess_irt_stocking_lord_link', 'eyeprocess_irt_haebara_link', 'eyeprocess_irt_link_stability', 'eyeprocess_irt_anchor_audit', 'eyeprocess_irt_anchor_purification', 'eyeprocess_irt_dif_effect_curve', 'eyeprocess_irt_dtf_curve', 'eyeprocess_irt_functioning_effect_summary', 'eyeprocess_irt_process_dif_concordance', 'eyeprocess_irt_session_drift', 'eyeprocess_irt_device_drift', 'eyeprocess_irt_invariance_evidence', 'eyeprocess_joint_process_irt_spec', 'validate_eyeprocess_joint_process_irt_spec', 'eyeprocess_process_irt_data_bundle', 'eyeprocess_response_time_profile', 'eyeprocess_speed_accuracy_profile', 'eyeprocess_process_item_profile', 'eyeprocess_process_person_profile', 'eyeprocess_irt_process_alignment', 'eyeprocess_process_missingness_pattern', 'eyeprocess_multichannel_measurement_map', 'eyeprocess_irt_engine_registry', 'eyeprocess_irt_engine_status', 'fit_eyeprocess_mirt', 'fit_eyeprocess_tam', 'fit_eyeprocess_gdina', 'fit_eyeprocess_lnirt', 'fit_eyeprocess_erm', 'simulate_eyeprocess_catr', 'run_eyeprocess_equateirt', 'run_eyeprocess_mirtcat', 'validate_eyeprocess_external_irt_fit', 'simulate_eyeprocess_irt_binary', 'eyeprocess_irt_recovery_design', 'run_eyeprocess_irt_recovery', 'eyeprocess_irt_recovery_summary', 'eyeprocess_irt_recovery_failures', 'eyeprocess_irt_sbc_ranks', 'eyeprocess_irt_sbc_summary', 'run_eyeprocess_irt_ability_sbc', 'eyeprocess_irt_misspecification_suite', 'eyeprocess_irt_misspecification_metrics', 'freeze_eyeprocess_irt_reference', 'eyeprocess_mirt_loading_spec', 'eyeprocess_mirt_loading_audit', 'eyeprocess_mirt_directional_information', 'eyeprocess_mirt_information_matrix', 'eyeprocess_irt_testlet_spec', 'eyeprocess_irt_testlet_audit', 'eyeprocess_irt_latent_regression_design', 'eyeprocess_cdm_qmatrix_audit', 'eyeprocess_cdm_attribute_profiles', 'eyeprocess_cdm_dina_ideal_response', 'eyeprocess_cdm_dina_probability', 'eyeprocess_cdm_classification_uncertainty', 'eyeprocess_irt_infit_outfit', 'eyeprocess_irt_person_fit_lz', 'eyeprocess_irt_bank_coverage', 'eyeprocess_irt_targeting_gap', 'eyeprocess_irt_classification_precision', 'eyeprocess_irt_missing_by_design_audit', 'eyeprocess_irt_prior_spec', 'eyeprocess_irt_prior_sensitivity_grid', 'eyeprocess_irt_prior_sensitivity_summary', 'eyeprocess_irt_model_card', 'eyeprocess_irt_model_card_audit', 'measurement_intelligence', 'fit_device_linking', 'apply_device_linking', 'audit_device_equivalence', 'estimate_device_specific_error', 'plot_device_agreement', 'plot_device_bias_by_magnitude', 'plot_device_transfer_curve', 'plot_device_equivalence_intervals', 'plot_cross_vendor_metric_matrix', 'item_objective_spec', 'item_pareto_front', 'optimize_item_bank', 'audit_bank_decision_stability', 'plot_item_pareto', 'plot_objective_tradeoffs', 'plot_bank_information_coverage', 'plot_decision_stability', 'plot_selected_bank_profile', 'fit_process_dif', 'monitor_dif_drift', 'decompose_dif_evidence', 'audit_fairness_transportability', 'plot_group_icc_process_overlay', 'plot_process_dif_forest', 'plot_dif_drift_heatmap', 'plot_fairness_transport_matrix', 'plot_item_group_process_curves', 'fit_process_norms', 'predict_process_centiles', 'score_process_deviation', 'audit_norm_transportability', 'plot_process_centiles', 'plot_normative_fan', 'plot_person_normative_profile', 'plot_item_normative_deviation', 'plots_irt', 'plot_eye_irt_information_profile', 'plot_eye_irt_test_characteristic_curve', 'plot_eye_irt_identification_audit', 'plot_eye_irt_sparse_design_audit', 'plot_eye_irt_q3_matrix', 'plot_eye_irt_item_fit', 'plot_eye_irt_person_fit', 'plot_eye_irt_fit_dashboard', 'plot_eye_irt_score_uncertainty', 'plot_eye_irt_adaptive_trace', 'plot_eye_irt_link_stability', 'plot_eye_irt_dif_curve', 'plot_eye_irt_dtf_curve', 'plot_eye_irt_process_alignment', 'plot_eye_irt_recovery_result', 'plot_eye_irt_sbc_evidence', 'plot_eye_cdm_qmatrix_audit', 'plot_eye_irt_bank_coverage', 'plot_eye_irt_targeting_gap', 'plot_eye_irt_missing_design_audit', 'plot_eye_irt_prior_sensitivity', 'dynamic_irt', 'dynamic_irtree_spec', 'prepare_dynamic_irtree_data', 'structural_transition_mask', 'dynamic_transition_design', 'fit_multinomial_transition', 'fit_dynamic_irtree_stan', 'decode_dynamic_states', 'dynamic_posterior_predictive_check', 'transition_residual_diagnostics', 'compare_dynamic_transition_models', 'simulate_dynamic_irtree_data', 'dynamic_irtree_recovery', 'fit_dynamic_irtree', 'theory_strategy_spec', 'prepare_strategy_mixture_data', 'fit_strategy_mixture_em', 'fit_strategy_mixture_stan', 'fit_theory_strategy_irt', 'strategy_posterior_probabilities', 'strategy_classification_uncertainty', 'strategy_label_switching_diagnostics', 'strategy_aoi_sensitivity', 'validate_strategy_manipulation', 'compare_strategy_heterogeneity', 'simulate_strategy_mixture_data', 'gaze_diffusion_spec', 'prepare_gaze_diffusion_data', 'fit_gaze_diffusion_stan', 'fit_gaze_diffusion_irt', 'extract_diffusion_parameters', 'diffusion_parameter_diagnostics', 'diffusion_posterior_predictive', 'compare_diffusion_accuracy_rt', 'simulate_gaze_diffusion_data', 'diffusion_identification_study', 'process_irt_07', 'irt_response_channel', 'irt_rt_channel', 'irt_count_channel', 'irt_survival_channel', 'irt_nominal_channel', 'irt_compositional_channel', 'irt_sequence_channel', 'irt_functional_channel', 'irt_model_spec', 'register_irt_model', 'list_irt_models', 'get_irt_model', 'fit_irt_model', 'simulate_irt_model', 'validate_irt_model', 'compare_irt_models', 'promote_irt_model', 'fit_joint_gaze_rt_irt', 'fit_speed_accuracy_engagement_irt', 'fit_joint_graded_rt_process_irt', 'fit_nominal_gaze_irt', 'option_process_information', 'distractor_process_map', 'audit_distractor_attention', 'classify_item_missingness', 'estimate_visual_exposure_probability', 'fit_omission_survival_irt', 'fit_manyfacet_process_irt', 'facet_effects', 'audit_process_measurement_invariance', 'detect_irt_changepoints', 'fit_changepoint_rt_irt', 'fit_changepoint_multimodal_irt', 'recalibrate_after_changepoint', 'irt_continuous_channel', 'fit_censored_normal_process_irt', 'predict_eye_censored_normal_process_irt', 'process_dependent_discrimination_audit', 'process_channel_ablation', 'fit_multimodal_trait_irt', 'generalizability_process_study', 'cross_device_process_equating_audit', 'encode_response_combinations', 'audit_process_local_dependence', 'fit_multiple_response_process_irt', 'fit_revisit_process_cdm', 'plot_eye_process_dependent_discrimination', 'plot_eye_process_channel_ablation', 'plot_eye_process_g_study', 'plot_eye_process_local_dependence_audit', 'advanced_process_irt_07', 'fit_process_hmm_irt', 'process_state_occupancy', 'process_state_transition_summary', 'fit_cognitive_diagnosis_process', 'fit_latent_class_process_irt', 'fit_crossclassified_process_irt', 'fit_latent_space_irt', 'process_residual_map', 'validate_latent_space_process_similarity', 'equate_irt_scales', 'process_person_fit', 'process_dif_nuisance_surrogate', 'audit_process_adjusted_dif', 'process_ngram_features', 'process_sequence_embedding', 'fit_response_process_embedding_irt', 'fit_gpirt', 'compare_parametric_nonparametric_irf', 'audit_irf_shape', 'fit_dynamic_gpirt', 'fit_continuous_time_irt', 'latent_trait_trajectory', 'predict_theta_at_time', 'fit_flow_mirt', 'fit_variational_irt', 'process_item_information', 'expected_process_information', 'select_next_item_process', 'simulate_process_cat', 'irt_validation_07', 'irt_validation_spec', 'as_irt_recovery_results', 'summarize_parameter_recovery', 'audit_bias', 'audit_rmse', 'audit_coverage', 'audit_interval_width', 'audit_convergence', 'validation_failure_taxonomy', 'audit_identifiability', 'validation_mcse', 'recommended_validation_replications', 'run_sbc', 'posterior_sbc_contract', 'run_posterior_sbc', 'audit_sbc', 'posterior_predictive_discrepancies', 'stress_test_misspecification', 'stress_test_latent_distribution', 'stress_test_local_dependence', 'stress_test_speededness', 'stress_test_missingness', 'stress_test_preprocessing', 'external_validate_irt', 'leave_device_out_validation', 'leave_session_out_validation', 'leave_site_out_validation', 'leave_item_out_validation', 'audit_measurement_transportability', 'compare_validation_engines', 'audit_channel_incremental_information', 'negative_control_process_test', 'calibration_transfer_audit', 'grade_model_evidence', 'plots_process_irt_07', 'plot_eye_joint_gaze_rt_irt', 'plot_eye_joint_graded_rt_process_irt', 'plot_eye_nominal_gaze_irt', 'plot_eye_omission_survival_irt', 'plot_eye_manyfacet_process_irt', 'plot_eye_irt_changepoints', 'plot_eye_process_hmm_irt', 'plot_eye_latent_space_irt', 'plot_eye_process_person_fit', 'plot_eye_irt_equating', 'plot_eye_gpirt', 'plot_eye_process_cat_simulation', 'plot_eye_irt_recovery_summary', 'plot_eye_irt_sbc', 'plot_eye_sbc_audit', 'plot_eye_irt_ppc', 'plot_eye_incremental_information_audit', 'plot_eye_process_negative_control', 'semantic_validation_07', 'requested_api_07', 'plot_distractor_information', 'fit_gaze_informed_missingness_irt', 'device_facet_effects', 'session_facet_effects', 'algorithm_facet_effects', 'detect_process_changepoint', 'plot_process_changepoint', 'plot_person_item_space', 'explain_latent_interaction', 'plot_irf_uncertainty', 'audit_latent_distribution', 'compare_latent_distribution_models', 'latent_distribution_stress_test', 'fit_event_time_irt', 'simulate_from_model', 'extract_parameter_truth', 'fit_validation_replicate', 'vendor_schema_contract', 'validate_vendor_semantics', 'event_roundtrip_audit', 'roundtrip_eye_bids', 'cross_version_adapter_regression', 'validation_evidence_levels', 'semantic_fidelity_spec', 'field_fidelity_report', 'timestamp_fidelity_audit', 'coordinate_fidelity_audit', 'pupil_unit_fidelity_audit', 'eye_stream_fidelity_audit', 'event_semantics_audit', 'validate_hed_event_semantics', 'validate_bids_eye_semantics', 'semantic_roundtrip_audit', 'semantic_loss_map', 'public_validation_corpus', 'compatibility_evidence_matrix', 'validate_vendor_timestamp_semantics', 'plot_eye_semantic_roundtrip', 'plot_eye_compatibility_evidence_matrix', 'bayesian_3pl_08', 'bayesian_process_diagnostics_dashboard', 'bayesian_process_diagnostic_flags', 'fit_gaze_anchored_3pl_audit', 'gaze_anchored_3pl_alignment', 'audit_3pl_process_signatures', 'context_structure_08', 'visual_context_registry', 'fit_visual_context_irt', 'compare_visual_context_irt', 'context_factor_effects', 'audit_visual_context_dependence', 'process_feature_blocks', 'fit_multiblock_process_map', 'multiblock_contributions', 'multiblock_person_coordinates', 'multiblock_variable_coordinates', 'fit_process_profile_mixture', 'process_profile_probabilities', 'process_profile_summary', 'compare_process_profile_solutions', 'audit_process_external_validity', 'process_criterion_associations', 'incremental_process_validity', 'compare_process_criterion_models', 'fit_item_parameter_seed_model', 'predict_item_parameter_priors', 'audit_candidate_item_bank', 'frontier_08', 'fit_kde_latent_distribution_irt', 'fit_persistence_gaze_diffusion_irt', 'fit_nonignorable_missing_irt', 'prepare_structured_unstructured_process_features', 'fit_crossclassified_process_irt_mhrm', 'audit_frontier_model_contract', 'plots_irt_08', 'plot_eye_gated_process_model', 'plot_eye_mixture_irt_process', 'plot_eye_latent_process_alignment', 'plot_eye_nonparametric_rasch_audit', 'plot_eye_item_reduction_sensitivity', 'plot_eye_biometric_imputation_sensitivity', 'plot_eye_process_rasch_tree', 'plot_eye_bayesian_process_dashboard', 'plot_eye_gaze_anchored_3pl_audit', 'plot_eye_multiblock_process_map', 'plot_eye_process_profile_mixture', 'plot_eye_process_external_validity', 'plot_eye_item_parameter_seed', 'plot_eye_candidate_item_bank_audit', 'plot_eye_visual_context_irt', 'sensitivity_08', 'fit_mixture_irt_process_classes', 'map_latent_classes_to_process_profiles', 'audit_nonparametric_rasch', 'audit_item_reduction_sensitivity', 'biometric_imputation_sensitivity', 'audit_biometric_imputation', 'fit_process_rasch_tree', 'compare_bayesian_process_models', 'legacy_models', 'response_matrix', 'response_time_matrix', 'align_response_matrices', 'model_data', 'fit_irt', 'fit_explanatory_irt', 'fit_accuracy_rt', 'fit_dif', 'fit_shared_process_factor', 'item_parameters', 'person_scores', 'model_fit_statistics', 'check_local_dependence', 'fit_joint_process_model', 'fit_dynamic_aoi_model', 'simulate_eye_dataset', 'simulate_process_irt', 'parameter_recovery', 'power_process_simulation', 'process_irt_spec', 'fit_process_irt', 'fit_gaze_informed_irt', 'fit_pupil_informed_irt', 'fit_multimodal_irt', 'process_irt_diagnostics', 'functional_pupil_features', 'fit_strategy_mixture', 'estimate_ez_diffusion', 'fit_gaze_weighted_choice', 'model_missing_process', 'sensitivity_missing_process', 'multimodal_staged', 'prepare_multimodal_irt_data', 'audit_multimodal_measurement', 'multimodal_irt_spec', 'simulate_multimodal_irt', 'process_information', 'ablate_multimodal_channels', 'multimodal_backend_status', 'multimodal_ppc', 'validate_multimodal_irt', 'audit_multimodal_identifiability', 'multimodal_m2_spec', 'fit_multimodal_m2', 'audit_multimodal_m2_identifiability', 'multimodal_m2_ppc', 'validate_multimodal_m2', 'multimodal_m2_ablation', 'multimodal_m2_process_information', 'multimodal_m2_negative_controls', 'simulate_multimodal_m2', 'multimodal_m2_recovery', 'multimodal_m3_spec', 'fit_multimodal_m3', 'audit_multimodal_m3_identifiability', 'multimodal_m3_ppc', 'multimodal_m3_ablation', 'multimodal_m3_process_information', 'multimodal_m3_negative_controls', 'multimodal_m3_functional_bridge', 'validate_multimodal_m3', 'simulate_multimodal_m3', 'multimodal_m3_recovery', 'multimodal_m4_spec', 'fit_multimodal_m4', 'audit_multimodal_m4_identifiability', 'multimodal_m4_state_diagnostics', 'multimodal_m4_ppc', 'multimodal_m4_ablation', 'multimodal_m4_process_information', 'multimodal_m4_negative_controls', 'multimodal_m4_sensitivity', 'validate_multimodal_m4', 'simulate_multimodal_m4', 'multimodal_m4_recovery', 'plots_legacy_models', 'plot_eye_parameter_recovery', 'plots_multimodal_staged', 'plot_eye_multimodal_measurement', 'plot_eye_multimodal_simulation', 'plot_eye_process_information', 'plot_eye_multimodal_validation', 'plot_eye_multimodal_m2_simulation', 'plot_eye_multimodal_m2_fit', 'plot_eye_multimodal_m2_ppc', 'plot_eye_multimodal_m2_information', 'plot_eye_multimodal_m2_validation', 'plot_eye_multimodal_m2_recovery', 'plot_eye_multimodal_m2_negative_controls', 'plot_eye_multimodal_m3_simulation', 'plot_eye_multimodal_m3_fit', 'plot_eye_multimodal_m3_ppc', 'plot_eye_multimodal_m3_information', 'plot_eye_multimodal_m3_validation', 'plot_eye_multimodal_m3_recovery', 'plot_eye_multimodal_m3_negative_controls', 'plot_eye_multimodal_m3_identifiability', 'plot_eye_multimodal_m4_simulation', 'plot_eye_multimodal_m4_fit', 'plot_eye_multimodal_m4_states', 'plot_eye_multimodal_m4_identifiability', 'plot_eye_multimodal_m4_ppc', 'plot_eye_multimodal_m4_information', 'plot_eye_multimodal_m4_negative_controls', 'plot_eye_multimodal_m4_sensitivity', 'plot_eye_multimodal_m4_recovery', 'plot_eye_multimodal_m4_validation', 'functional_pupil', 'functional_pupil_irt_spec', 'fit_joint_functional_pupil_irt', 'advanced_validation_grid', 'simulate_advanced_process_data', 'functional_pupil_basis', 'prepare_functional_pupil_data', 'fit_functional_pupil_stan', 'extract_functional_pupil_parameters', 'functional_pupil_diagnostics', 'pupil_preprocessing_grid', 'pupil_preprocessing_sensitivity', 'compare_functional_scalar_models', 'plots_functional_pupil', 'plot_eye_functional_pupil_irt', 'plot_eye_functional_pupil_diagnostics', 'plot_eye_functional_pupil_sensitivity', 'engine_adapters', 'eyeprocess_api_version', 'object_schema', 'validate_model_object', 'upgrade_eyeprocess_model', 'eyeprocess_deprecation', 'external_model_engines', 'engine_adapter_status', 'fit_external_engine', 'validate_engine_adapter', 'compare_engine_adapters', 'fit_mirt_adapter', 'fit_tam_adapter', 'fit_brms_adapter', 'fit_lnirt_adapter', 'fit_traminer_adapter', 'fit_seqhmm_adapter', 'fit_gdina_adapter', 'fit_openmx_adapter', 'fit_diffirt_engine_adapter', 'fit_eyetrackingr_adapter', 'fit_pupillometryr_adapter', 'as_procdata_sequence', 'as_traminer_sequence', 'as_seqhmm_data', 'fit_diffirt_adapter', 'fit_openmx_process_model', 'compare_model_engines', 'plot_eye_engine_comparison', 'plots_process_quality_09', 'plot_eye_process_reliability_profile', '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_quality_09', 'process_measure_registry', 'validate_process_measure_registry', 'register_process_measure', 'find_process_measures', 'process_measure_card', 'process_measure_guardrails', 'process_measure_coverage', 'process_measure_lineage', 'process_measure_units', 'split_half_process_reliability', 'process_icc', 'process_bland_altman', 'process_reliability_profile', 'process_temporal_stability', 'bootstrap_process_reliability', 'estimate_calibration_error', 'gaze_precision_rms_s2s', 'effective_sampling_frequency', 'audit_sampling_irregularity', 'calibration_error_model', 'gaze_uncertainty_ellipse', 'propagate_calibration_uncertainty', 'aoi_membership_probability', 'probabilistic_aoi_assignment', 'compare_hard_probabilistic_aoi', 'calibration_sensitivity_grid', 'fixation_boundary_uncertainty', 'calibration_drift_profile', 'gaze_data_quality_profile', 'data_quality_reporting_table', 'process_dynamics', 'pupil_missingness', 'evidence_graph', 'annotations', 'cross_recurrence', 'recurrence_features', 'fit_process_observation_model', 'build_evidence_graph', 'trace_item_decision', 'compare_decision_provenance', 'audit_evidence_dependencies', 'plot_evidence_graph', 'plot_item_decision_path', 'plot_metric_dependency_graph', 'plot_model_decision_impact', 'fit_process_missingness_model', 'crossmodal_recurrence_model', 'plot_crossmodal_recurrence_model', 'plot_eye_evidence_graph', 'plot_eye_decision_trace', 'plot_eye_provenance_comparison', 'plot_eye_crossmodal_recurrence_model', 'measurement_quality_legacy', 'process_uncertainty_spec', 'estimate_process_uncertainty', 'propagate_process_uncertainty', 'uncertainty_budget', 'compare_uncertainty_budgets', 'plot_uncertainty_waterfall', 'plot_uncertainty_tornado', 'plot_uncertainty_by_item', 'plot_uncertainty_by_stage', 'detect_calibration_drift', 'fit_offline_recalibration', 'apply_offline_recalibration', 'audit_recalibration', 'plot_calibration_vector_field', 'plot_calibration_error_ellipses', 'plot_drift_over_time', 'plot_recalibration_before_after', 'plot_screen_coverage', 'fit_process_gstudy', 'process_variance_components', 'design_process_dstudy', 'audit_process_reliability', 'plot_variance_components', 'plot_dependability_surface', 'plot_reliability_by_metric', 'plot_session_stability', 'plot_item_sampling_reliability', 'plot_eye_process_uncertainty', 'plot_eye_process_uncertainty_propagation', 'plot_eye_uncertainty_budget_comparison', 'plot_eye_calibration_drift', 'plot_eye_recalibration_audit', 'plot_eye_process_gstudy', 'plot_eye_process_dstudy', 'plot_eye_process_reliability_audit', 'gaze_recurrence', 'windowed_recurrence', 'plot_recurrence_matrix', 'plot_windowed_recurrence', 'plot_diagonal_recurrence_profile', 'plot_crossmodal_recurrence', 'plot_recurrence_network', 'fit_fixation_point_process', 'fit_marked_gaze_process', 'predict_fixation_intensity', 'diagnose_gaze_point_process', 'plot_fixation_intensity', 'plot_spatial_residuals', 'plot_temporal_excitation_kernel', 'plot_covariate_effect_surface', 'plot_observed_expected_fixations', 'representative_scanpath', 'scanpath_dispersion', 'compare_scanpath_distributions', 'bootstrap_representative_scanpath', 'plot_scanpath_atlas', 'plot_representative_scanpath', 'plot_scanpath_dispersion', 'plot_group_scanpath_transport', 'plot_scanpath_similarity_matrix', 'detect_process_changepoints', 'segment_process_episodes', 'label_process_episodes', 'compare_episode_structure', 'plot_process_episodes', 'plot_changepoint_ribbons', 'plot_episode_waterfall', 'plot_episode_transition_graph', 'plot_episode_duration_distribution', 'plot_eye_recurrence', 'plot_eye_cross_recurrence', 'plot_eye_windowed_recurrence', 'plot_eye_fixation_point_process', 'plot_eye_gaze_point_process_diagnostics', 'plot_eye_scanpath_representative', 'plot_eye_scanpath_comparison', 'plot_eye_scanpath_bootstrap', 'plot_eye_process_changepoints', 'plot_eye_process_episodes', 'plot_eye_episode_comparison', 'register_pupil_curves', 'decompose_pupil_phase_amplitude', 'fit_phase_amplitude_irt', 'audit_pupil_registration', 'plot_pupil_registration', 'plot_warping_functions', 'plot_phase_amplitude_scores', 'plot_item_phase_delay', 'plot_registered_pupil_effects', 'fit_joint_signal_missingness', 'process_pattern_mixture', 'sensitivity_mnar_process', 'plot_observation_probability', 'plot_missingness_by_time', 'plot_missingness_by_aoi', 'plot_mnar_tipping_point', 'plot_complete_case_sensitivity', 'plot_eye_pupil_registration', 'plot_eye_pupil_phase_amplitude', 'plot_eye_phase_amplitude_irt', 'plot_eye_process_observation_model', 'plot_eye_mnar_sensitivity', 'plot_eye_mnar_tipping_point', 'process_governance_08', 'process_preflight_spec', 'audit_biometric_preflight', 'preflight_decisions', 'preflight_failures', 'preflight_passed', 'preflight_exclusion_manifest', 'apply_preflight_decision', 'audit_process_anomalies', 'audit_multivariate_process_quality', 'process_anomaly_distance', 'audit_presentation_accessibility', 'simulate_presentation_variants', 'compare_presentation_fairness', 'process_drift_spec', 'audit_process_drift', 'process_drift_alerts', 'compare_deployment_batches', 'drift_by_device', 'drift_by_site', 'drift_by_vendor', 'drift_by_stimulus_version', 'process_window_spec', 'extract_process_windows', 'summarize_process_windows', 'bind_process_windows', 'validate_process_windows', 'audit_process_window_sensitivity', 'aoi_trajectory_features', 'fit_aoi_growth_curve', 'predict_aoi_trajectory', 'compare_aoi_trajectories', 'pupil_band_power', 'pupil_velocity_activity', 'pupil_activity_index', 'pupil_frequency_features', 'audit_pupil_frequency_stability', 'pupil_response_kernel', 'pupil_event_regressor', 'fit_pupil_event_deconvolution', 'pupil_event_effects', 'compare_pupil_kernels', 'fit_pupil_confound_model', 'adjust_pupil_confounds', 'pupil_confound_effects', 'audit_pupil_fatigue_drift', 'compare_raw_adjusted_pupil', 'filter_eye_signal', 'filter_pupil_signal', 'audit_signal_filter', 'compare_signal_filters', 'plots_governance_08', 'plot_eye_biometric_preflight', 'plot_eye_process_anomaly_audit', 'plot_eye_presentation_accessibility', 'plot_eye_process_drift_audit', 'plot_eye_process_window_sensitivity', 'plot_eye_pupil_frequency_features', 'plot_eye_pupil_frequency_stability', 'plot_eye_pupil_deconvolution', 'plot_eye_pupil_confound_model', 'plot_eye_aoi_trajectory', 'plot_eye_aoi_growth_curve', 'plot_eye_signal_filter_audit', 'plot_eye_process_windows', 'plot_eye_pupil_fatigue_drift', 'plot_eye_presentation_fairness_comparison', 'plot_pupil_spectrum', 'plot_pupil_band_power', 'plot_pupil_activity_windows', 'plot_pupil_activity_sensitivity', 'plot_process_window_sensitivity', 'operational_validation_08', 'score_partial_response_pattern', 'score_response_stream', 'update_person_score', 'streaming_score_history', 'collect_validation_evidence', 'validation_bundle_manifest', 'validation_report', 'write_validation_report', 'export_validation_bundle', 'preaction_process_features', 'addm_glam_proxy_features', 'process_feature_family_registry', 'assign_process_feature_family', 'process_feature_stability', 'plots_operational_08', 'plot_eye_streaming_score', 'plot_eye_validation_bundle', 'plot_eye_preaction_process_features', 'plot_eye_decision_process_proxy', 'plot_process_feature_stability', 'governance_09', 'UTC', 'process_validation_design', 'validate_process_validation_design', 'expand_process_validation_design', 'validation_condition_id', 'simulate_process_validation_data', 'run_process_validation', 'summarise_process_validation', 'validation_recovery_table', 'validation_coverage_table', 'validation_failure_profile', 'validation_summary_mcse', 'validation_condition_ranking', 'validation_robustness_score', 'freeze_validation_reference', 'validate_against_reference', 'validation_evidence_matrix', 'eye_analysis_spec', 'eye_pipeline_step', 'eye_analysis_pipeline', 'validate_eye_pipeline', 'eye_pipeline_graph', 'eye_pipeline_manifest', 'run_eye_pipeline', 'resume_eye_pipeline', 'audit_eye_pipeline', 'pipeline_step_status', 'pipeline_result', 'pipeline_failures', 'write_eye_pipeline_report', 'export_eye_pipeline', 'eye_pipeline_dot', 'eye_pipeline_mermaid', 'eye_targets_manifest', 'write_eye_targets_template', 'eye_api_lifecycle', 'eye_api_inventory', 'register_eye_api_status', 'eye_api_status', 'eye_api_superseded', 'canonical_eye_api', 'api_surface_summary', 'api_family_map', 'audit_eye_api', 'eye_api_recommendation', 'write_api_lifecycle_registry', 'read_api_lifecycle_registry', 'api_lifecycle_diff', 'process_sensitivity_grid', 'run_process_sensitivity', 'sensitivity_sign_stability', 'sensitivity_significance_stability', 'sensitivity_threshold_stability', 'summarise_process_sensitivity', 'decision_stability', 'specification_curve_data', 'specification_coverage', 'sensitivity_decision_leverage', 'sensitivity_fragility_index', 'sensitivity_rank_stability', 'sensitivity_branch_fingerprint', 'sensitivity_multiverse_manifest', 'compare_aoi_methods', 'compare_fixation_methods', 'compare_pupil_preprocessing', 'compare_process_models', 'eye_decision_manifest', 'validate_decision_manifest', 'decision_manifest_table', 'decision_manifest_hash', 'lock_decision_manifest', 'verify_decision_manifest_lock', 'compare_decision_manifests', 'decision_manifest_diff', 'write_decision_manifest', 'read_decision_manifest', 'audit_decision_provenance', 'outcome_blind_snapshot', 'verify_outcome_blind_snapshot', 'analysis_decision_entropy', 'decision_space_coverage', 'plots_governance_09', 'plot_eye_process_validation_design', 'plot_eye_process_validation_result', 'plot_eye_validation_reference_comparison', 'plot_eye_analysis_pipeline', 'plot_eye_pipeline_audit', 'plot_eye_api_audit', 'plot_eye_process_sensitivity', 'plot_eye_decision_stability', 'plot_eye_decision_manifest', 'EyeAOI', 'as_eye_dataset', 'convert_xy', 'synchronize_eye_biometrics', 'audit_clock_sync', 'build_trials', 'build_stimulus_intervals', 'assign_trials', 'add_responses', 'build_item_responses', 'new_aoi', 'register_aois', 'assign_aois', 'build_aoi_visits', 'store_quality', 'audit_sampling_rate', 'audit_signal_quality', 'audit_pupil_quality', 'audit_episodes', 'audit_event_order', 'audit_trial_coverage', 'audit_aois', 'audit_missingness', 'check_process_leakage', 'check_feature_level', 'interpretive_warnings', 'analysis_readiness', 'compare_preprocessing', 'compare_aoi_definitions', 'sensitivity_process', 'baseline_pupil', 'derive_all_features', 'derive_biometric_features', 'derive_gaze_features', 'derive_pupil_features', 'derive_rt_features', 'detect_blinks', 'detect_fixations_idt', 'detect_fixations_ivt', 'detect_saccades', 'feature_dictionary', 'feature_spec', 'features_wide', 'filter_gaze', 'filter_pupil', 'flag_gaze_outliers', 'gaze_entropy', 'gaze_velocity', 'interpolate_pupil', 'preprocess_eye', 'preprocess_spec', 'pupil_deconvolve', 'rolling_apply', 'scanpath_sequence', 'summarize_fixations', 'transition_entropy', 'transition_matrix', 'trial_table', 'io_validation_10', 'anonymize_eye_dataset', 'as_eye_biometrics', 'compare_eye_datasets', 'create_validation_bundle', 'discover_validation_cases', 'export_canonical', 'eye_format_profiles', 'fingerprint_eye_dataset', 'format_compatibility_matrix', 'format_validation_spec', 'import_canonical', 'init_validation_corpus', 'inspect_eye_source', 'read_eye_dataset', 'read_validation_manifest', 'report_eye_dataset', 'report_processirt', 'roundtrip_eye_dataset', 'schema_coverage', 'schema_coverage_summary', 'source_preservation_audit', 'validate_eye_corpus', 'validate_eye_source', 'validate_eyelink_export', 'validate_generic_export', 'validate_pupillabs_export', 'validate_smi_export', 'validate_tobii_export', 'validation_manifest', 'write_eye_dataset', 'write_format_validation_report', 'write_provenance', 'write_validation_manifest', 'gazepoint_real_10', 'gp_align_media_ids', 'gp_check_biometrics_sync', 'gp_check_fixation_ids', 'gp_check_media_timing', 'gp_check_pupil_channels', 'gp_check_sampling_rate', 'gp_check_validity_fields', 'gp_parse_markers', 'gp_reconstruct_stimuli', 'gp_reconstruct_trials', 'read_gazepoint_aoi_statistics', 'read_gazepoint_summary', 'gazepoint_workflow_10', 'build_gazepoint_media_trials', 'derive_gazepoint_workflow_features', 'gazepoint_analysis_tables', 'gazepoint_irt_tables', 'gazepoint_workflow_spec', 'plot_gazepoint_workflow', 'run_gazepoint_workflow', 'validate_gazepoint_workflow', 'write_gazepoint_workflow_report', 'interoperability_storage_10', 'EyeStorage', 'EyeStorageSpec', 'as_eyeprocess_eyeris', 'as_eyeprocess_eyetools', 'as_eyeprocess_eyetrackingr', 'as_eyeprocess_gazer', 'as_eyeprocess_pupillometryr', 'collect_eye_storage', 'export_eye_bids', 'eye_storage_spec', 'import_eye_bids', 'open_eye_storage', 'write_eye_storage', 'validation_program_10', 'audit_vendor_validation', 'model_validation_spec', 'model_validation_summary', 'run_model_validation', 'vendor_validation_spec', 'write_vendor_validation_report', 'validation_evidence_10', 'advanced_model_evidence_spec', 'audit_advanced_model_evidence', 'raven_reproduction_spec', 'run_raven_reproduction', 'sbc_summary', 'simulation_based_calibration', 'write_advanced_model_evidence_report', 'grouped_validation_10', 'crossed_grouped_cv', 'crossed_grouped_folds', 'grouped_cv', 'grouped_folds', 'quantify_process_leakage', 'validation_completion_10', 'benchmark_eyeprocess', 'create_public_benchmark', 'preprocessing_multiverse', 'reporting_guideline_audit', 'run_eyeprocess_validation_program', 'write_reporting_guideline_report', 'write_software_paper_scaffold', 'validation_orchestration_10', 'collect_validation_jobs', 'prune_validation_checkpoints', 'read_validation_job_manifest', 'resume_validation_jobs', 'run_validation_jobs', 'split_validation_plan', 'validation_job_plan', 'validation_seed', 'write_validation_job_manifest', 'validation_orchestration_completion_10', 'audit_model_promotion', 'audit_validation_completion', 'model_promotion_spec', 'plot_interval_coverage', 'plot_parameter_recovery', 'plot_sbc_rank', 'plot_validation_failures', 'plot_validation_runtime', 'validation_calibration_summary', 'validation_failure_summary', 'validation_recovery_summary', 'validation_runtime_summary', 'validation_sbc_summary', 'validation_thresholds', 'write_model_promotion_report', 'write_validation_release_report', 'partitioned_storage_10', 'EyePartitionSpec', 'EyePartitionedStorage', 'EyeStorageValidation', 'benchmark_eye_storage', 'detect_corrupt_partitions', 'migrate_eye_storage_schema', 'open_partitioned_eye_storage', 'partition_eye_storage', 'query_eye_storage', 'storage_transaction_manifest', 'upgrade_eye_dataset', 'validate_eye_storage_metadata', 'write_partitioned_eye_storage', 'benchmark_reproducibility_10', 'eyeprocess_benchmark_study', 'read_benchmark_table', 'benchmark_expected_outputs', 'import_benchmark_study', 'validate_benchmark_study', 'run_benchmark_reproduction', 'write_benchmark_data_dictionary', 'package_reproducibility_manifest', 'verify_reproducibility_manifest', 'write_software_paper_reproduction', 'audit_benchmark_release', 'vendor_importers_10', 'is_eyelink_export', 'is_pupil_labs_export', 'is_smi_export', 'is_tobii_export', 'pupil_labs_format', 'read_eyelink_asc', 'read_eyelink_edf', 'read_eyelink_report', 'read_pupil_core', 'read_pupil_neon', 'read_pupillabs', 'read_smi', 'read_smi_aoi_export', 'read_smi_event_export', 'read_smi_raw_export', 'read_tobii', 'vendor_corpus_10', 'audit_roundtrip_loss', 'audit_vendor_field_coverage', 'build_compatibility_matrix', 'compare_vendor_semantics', 'fingerprint_validation_case', 'init_vendor_corpus', 'promote_vendor_support', 'read_vendor_registry', 'redact_validation_case', 'register_validation_case', 'register_vendor_semantics', 'write_vendor_case_report', 'write_vendor_registry', 'core_plots_10', 'plot_aoi_dwell', 'plot_biometrics', 'plot_clock_alignment', 'plot_coordinate_spaces', 'plot_eye_overview', 'plot_eye_trace', 'plot_feature_correlation', 'plot_feature_distribution', 'plot_fixations', 'plot_gaze_heatmap', 'plot_item_difficulty', 'plot_missingness', 'plot_model_diagnostics', 'plot_pupil_timeseries', 'plot_sampling_rate', 'plot_scanpath', 'plot_signal_quality', 'plot_transition_matrix', 'plot_trial_timeline', 'measurement_intelligence_utils_10', 'EyePlotSpec', 'eye_plot_spec', 'plot_diagnostics', 'plot_evidence', 'plot_sensitivity', 'autoplot_eyeprocess', 'probabilistic_aoi_10', 'assign_aois_probabilistic', 'audit_aoi_separation', 'summarise_aoi_membership', 'propagate_aoi_uncertainty', 'plot_aoi_probability_map', 'plot_aoi_boundary_risk', 'plot_probabilistic_scanpath', 'plot_fuzzy_transition_matrix', 'plot_aoi_metric_uncertainty', 'compositional_aoi_10', 'aoi_balance_coordinates', 'compare_aoi_compositions', 'derive_aoi_composition', 'fit_aoi_compositional_model', 'plot_aoi_balance_biplot', 'plot_aoi_composition_trajectory', 'plot_aoi_ternary', 'plot_aoi_variation_matrix', 'plot_compositional_group_difference', 'transform_aoi_composition', 'plots_aoi_perturbation', 'aoi_perturbation', 'AMBIGUOUS', 'OUTSIDE', 'aoi_perturbation_spec', 'apply_aoi_perturbation_grid', 'assess_aoi_inference_stability', 'compare_aoi_assignments', 'convert_aoi_margin_to_degrees', 'convert_aoi_margin_to_pixels', 'create_aoi_perturbation_grid', 'dilate_aoi', 'erode_aoi', 'estimate_aoi_assignment_stability', 'estimate_fixation_assignment_probability', 'jitter_aoi', 'perturb_aoi_geometry', 'plot_aoi_assignment_stability', 'plot_aoi_coefficient_stability', 'plot_aoi_perturbations', 'plot_aoi_robustness_surface', 'recompute_aoi_features', 'report_aoi_sensitivity', 'run_aoi_sensitivity_analysis', 'summarise_aoi_sensitivity', 'translate_aoi', 'validate_aoi_geometry', 'plots_completion_08', 'plot_aoi_transition_matrix', 'plot_aoi_transition_rank', 'plot_process_channel_ablation_delta', 'plot_pupil_components', 'plot_pupil_preprocessing_audit', 'validation_extras_09', 'analysis_resolution_guard', 'audit_pupil_preprocessing_order', 'coverage_calibration_curve', 'measurement_error_budget', 'pupil_baseline_sensitivity', 'sbc_ecdf_deviation', 'sbc_rank_diagnostics', 'simulation_rank_statistic', 'negative_controls_09', 'audit_temporal_leakage', 'negative_control_concordance', 'outcome_blind_feature_audit', 'placebo_window_audit', 'process_feature_time_provenance', 'process_negative_control_permute', 'process_negative_control_shift', 'process_null_benchmark', 'run_process_negative_controls', 'summarise_process_negative_controls', 'validate_feature_availability', 'benchmark_stress_09', 'apply_synthetic_corruption', 'benchmark_memory_estimate', 'benchmark_scaling_curve', 'eye_benchmark_design', 'inject_aoi_label_noise', 'inject_calibration_offset', 'inject_device_shift', 'inject_eye_missingness', 'inject_pupil_dropout', 'inject_sampling_jitter', 'inject_trial_imbalance', 'run_eye_benchmark', 'stress_test_process_pipeline', 'stress_test_summary', 'stress_tolerance_frontier', 'summarise_eye_benchmark', 'synthetic_corruption_plan', 'reproducibility_provenance_09', 'analysis_environment_snapshot', 'compare_reproducibility_fingerprints', 'export_prov_json', 'export_ro_crate_metadata', 'eye_prov_graph', 'eye_reproducibility_fingerprint', 'eye_session_manifest', 'file_hash_manifest', 'object_hash', 'provenance_edge_table', 'provenance_lineage_table', 'read_reproducibility_fingerprint', 'validate_eye_prov_graph', 'verify_reproducibility_fingerprint', 'write_prov_dot', 'write_reproducibility_fingerprint', 'software_paper_evidence_09', 'freeze_software_paper_evidence', 'paper_reproducibility_manifest', 'software_paper_claim_matrix', 'software_paper_coverage', 'software_paper_evidence_bundle', 'software_paper_gap_analysis', 'software_paper_readiness', 'software_paper_validation_table', 'write_software_paper_evidence', 'validation_evidence_programs_09', 'evaluate_validation_acceptance', 'expand_eyeprocess_validation_plan', 'eyeprocess_validation_evidence_grade', 'eyeprocess_validation_plan', 'eyeprocess_validation_seed', 'read_validation_scenario_manifest', 'summarise_validation_acceptance', 'validate_eyeprocess_validation_plan', 'validation_acceptance_matrix', 'validation_acceptance_rule', 'validation_mcse_profile', 'validation_replication_budget', 'validation_scenario_manifest', 'write_validation_scenario_manifest', 'validation_stress_freeze_09', 'expand_eyeprocess_stress_evidence_plan', 'eyeprocess_negative_control_evidence_plan', 'eyeprocess_reliability_evidence_plan', 'eyeprocess_stress_evidence_plan', 'eyeprocess_validation_claim_matrix', 'eyeprocess_validation_evidence_manifest', 'eyeprocess_validation_readiness', 'eyeprocess_validation_release_gate', 'freeze_eyeprocess_validation_evidence', 'read_eyeprocess_validation_evidence', 'run_eyeprocess_stress_evidence', 'summarise_eyeprocess_stress_evidence', 'verify_eyeprocess_validation_evidence', 'write_eyeprocess_validation_evidence', 'measurement_accountability_11', 'event_marker_qc', 'pupil_latency_sensitivity', 'validation_ladder', 'validation_atlas_09', 'eyeprocess_irt_engine_evidence_table', 'eyeprocess_irt_precision_evidence_table', 'eyeprocess_negative_control_evidence_table', 'eyeprocess_recovery_evidence_table', 'eyeprocess_reliability_evidence_table', 'eyeprocess_sbc_evidence_table', 'eyeprocess_stress_evidence_table', 'eyeprocess_validation_atlas_gaps', 'eyeprocess_validation_evidence_atlas', 'eyeprocess_validation_evidence_index', 'freeze_eyeprocess_validation_atlas', 'verify_eyeprocess_validation_atlas', 'write_eyeprocess_validation_report', 'multilevel_mediation', 'MultilevelMediationData', 'prepare_multilevel_mediation_data', 'validate_multilevel_mediation_data', 'identify_mediation_levels', 'decompose_within_between', 'center_within_participant', 'summarise_within_between_variance', 'audit_mediation_missingness', 'check_mediation_trial_counts', 'mediation_provenance_json', 'add_multilevel_mediation_component', 'survival', 'CANONICAL_GAZE_SURVIVAL_COLUMNS', 'GazeSurvivalFit', 'check_gaze_proportional_hazards', 'compare_gaze_survival_models', 'estimate_gaze_latency_quantiles', 'estimate_gaze_survival', 'fit_gaze_aft_model', 'fit_gaze_cox_model', 'fit_gaze_mixed_cox_model', 'plot_gaze_cox_diagnostics', 'plot_gaze_cumulative_incidence', 'plot_gaze_hazard', 'plot_gaze_survival_curve', 'predict_gaze_survival', 'prepare_gaze_survival_data', 'report_gaze_survival_model', 'simulate_gaze_survival_example', 'simulate_gaze_survival_inputs', 'summarise_gaze_censoring', 'tidy_gaze_survival_model', 'validate_gaze_survival_data', 'spatial_quality', 'validate_gaze_quality_inputs', 'compute_gaze_accuracy', 'compute_gaze_precision', 'compute_rms_s2s', 'compute_gaze_sd_precision', 'compute_bcea', 'estimate_sampling_interval', 'estimate_sampling_jitter', 'estimate_effective_sampling_rate', 'compute_valid_sample_fraction', 'compute_gaze_data_loss', 'summarise_spatial_quality', 'summarise_sampling_quality', 'create_gaze_quality_report', 'compare_gaze_quality_sessions', 'compare_gaze_quality_conditions', 'plot_gaze_accuracy', 'plot_gaze_precision', 'plot_bcea', 'plot_sampling_intervals', 'plot_gaze_quality_dashboard', 'report_gaze_quality', 'simulate_gaze_quality_calibration', 'advanced_events', 'dynamic_aoi', 'event_benchmark', 'gaze_stress', 'measurement_validity', 'naturalistic_coordinates', 'scanpath_sensitivity', 'align_head_pose_to_gaze', 'assign_dynamic_aoi', 'audit_dynamic_aoi_coverage', 'audit_pupil_preprocessing', 'benchmark_event_detector', 'compare_event_detectors', 'compare_scanpath_metrics', 'compute_pursuit_gain', 'compute_pursuit_velocity_error', 'compute_spatial_error_field', 'correct_gaze_with_spatial_error', 'correct_pupil_size_artifact', 'detect_events_directional', 'detect_events_ivvt', 'detect_microsaccades', 'detect_smooth_pursuits', 'detector_parameter_sensitivity', 'dynamic_aoi_sensitivity', 'dynamic_time_warping_distance', 'event_boundary_error', 'event_confusion_matrix', 'fit_pupil_size_artifact', 'inject_blink_gaps', 'inject_event_misclassification', 'inject_spatial_drift', 'inject_spatial_noise', 'levenshtein_scanpath', 'microsaccade_main_sequence', 'ngram_jaccard_similarity', 'pixels_to_visual_angle', 'plot_detector_benchmark', 'plot_dynamic_aoi_alignment', 'plot_gaze_stress', 'plot_microsaccade_main_sequence', 'plot_pupil_size_artifact', 'plot_pursuit_velocity', 'plot_scanpath_sensitivity', 'plot_spatial_error_field', 'plot_world_gaze_vectors', 'propagate_coordinate_uncertainty', 'run_gaze_stress_suite', 'scanpath_metric_sensitivity', 'screen_gaze_to_head_vectors', 'simulate_known_gaze_process', 'summarise_microsaccades', 'summarise_pursuits', 'transform_head_gaze_to_world', 'transform_screen_gaze_to_world', 'transition_js_distance', 'validate_dynamic_aoi_spec', 'validate_pursuit_detection', 'visual_angle_to_pixels']
EyeDataset ¶
Bases: dict
Dict-like Python counterpart of the R eye_dataset list class.
DetectorInferenceResult
dataclass
¶
DetectorMultiverse
dataclass
¶
DetectorMultiverseResult
dataclass
¶
EventDetectorSpec
dataclass
¶
Canonical, immutable event-detector specification.
EyeProcessBackendError ¶
Bases: EyeProcessError
Raised when an optional backend is required or fails.
EyeProcessCoordinateError ¶
Bases: EyeProcessError
Raised for coordinate-space errors.
EyeProcessError ¶
Bases: Exception
Base error for eyeprocesspy.
EyeProcessGovernanceError ¶
Bases: EyeProcessError
Raised when an evidence/governance gate is violated.
EyeProcessModelError ¶
Bases: EyeProcessError
Raised for modelling failures.
EyeProcessSchemaError ¶
Bases: EyeProcessError
Raised for canonical schema errors.
EyeProcessTimebaseError ¶
Bases: EyeProcessError
Raised for timebase normalization or alignment errors.
EyeProcessValidationError ¶
Bases: EyeProcessError
Raised when a canonical dataset violates validation contracts.
EyeAOI
dataclass
¶
Python representation of the R eye_aoi list class.
EyeStorage ¶
Bases: dict
Lightweight disk-backed storage handle.
EyeStorageSpec
dataclass
¶
Python counterpart of the R eye_storage_spec object.
EyePlotSpec ¶
Bases: dict
R-list-like plot specification with stable class metadata.
MultilevelMediationData
dataclass
¶
Prepared trial-level mediation data plus audits and provenance.
EyePartitionedStorage ¶
Bases: _EyeDict
Disk-backed handle for atomic partitioned eyeprocess storage.
EyePartitionSpec
dataclass
¶
Python counterpart of frozen R eye_partition_spec.
EyeStorageValidation ¶
Bases: _EyeDict
GazeSurvivalFit
dataclass
¶
Container for a fitted gaze-survival model.
EyeClockTransform
dataclass
¶
read_eye_folder ¶
register_eye_adapter ¶
Register a vendor/custom reader using the frozen R adapter contract.
compute_pursuit_gain ¶
compute_pursuit_gain(data: Any, *, time: str = 'timestamp_ms', gaze_x: str = 'gaze_x_deg', gaze_y: str = 'gaze_y_deg', target_x: str = 'target_x_deg', target_y: str = 'target_y_deg', time_unit: str = 'ms') -> pd.DataFrame
Compute sample-wise gaze/target speed ratio on synchronized trajectories.
compute_pursuit_velocity_error ¶
Compute gaze minus target velocity error on synchronized trajectories.
detect_events_directional ¶
detect_events_directional(data: Any, *, time: str = 'timestamp_ms', x: str = 'gaze_x_deg', y: str = 'gaze_y_deg', time_unit: str = 'ms', minimum_velocity: float = 2.0, maximum_velocity: float = 30.0, maximum_direction_change_deg: float = 35.0, minimum_duration_ms: float = 40.0, minimum_sampling_hz: float = 30.0) -> EyeResult
Detect directionally coherent moderate-speed smooth pursuit.
detect_events_ivvt ¶
detect_events_ivvt(data: Any, *, time: str = 'timestamp_ms', x: str = 'gaze_x_deg', y: str = 'gaze_y_deg', time_unit: str = 'ms', fixation_velocity_threshold: float = 5.0, saccade_velocity_threshold: float = 30.0, minimum_duration_ms: float = 20.0, minimum_sampling_hz: float = 30.0) -> EyeResult
Classify fixation, pursuit, and saccade samples with explicit velocity thresholds.
detect_microsaccades ¶
detect_microsaccades(data: Any, *, time: str = 'timestamp_ms', x: str = 'gaze_x_deg', y: str = 'gaze_y_deg', time_unit: str = 'ms', lambda_threshold: float = 6.0, minimum_duration_ms: float = 6.0, maximum_amplitude_deg: float = 2.0, minimum_sampling_hz: float = 200.0, right_x: str | None = None, right_y: str | None = None, binocular_tolerance_ms: float = 10.0) -> EyeResult
Detect microsaccades using robust velocity ellipses and optional binocular overlap.
detect_smooth_pursuits ¶
Dispatch to a transparent pursuit detector.
microsaccade_main_sequence ¶
Return amplitude and peak velocity for main-sequence inspection.
plot_microsaccade_main_sequence ¶
Plot microsaccade amplitude against peak velocity.
plot_pursuit_velocity ¶
Plot sample velocity and pursuit-labelled samples.
summarise_microsaccades ¶
Summarize microsaccade count, duration, amplitude, and peak velocity.
summarise_pursuits ¶
Summarize pursuit episodes from IVVT or directional output.
validate_pursuit_detection ¶
Return review diagnostics rather than declaring detector validity.
audit_irf_shape ¶
audit_irf_shape(comparison: Any, mean_absolute_threshold: float = 0.05, max_absolute_threshold: float = 0.15) -> 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
compare_parametric_nonparametric_irf ¶
compare_parametric_nonparametric_irf(response_matrix: Any, gpirt_object: Any = None, theta_grid: Sequence[float] | None = None) -> pd.DataFrame
equate_irt_scales ¶
equate_irt_scales(reference: Any, new: Any, method: str = 'stocking-lord', theta_grid: Sequence[float] | None = None) -> EyeResult
expected_process_information ¶
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_continuous_time_irt ¶
fit_continuous_time_irt(data: Any, external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> 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_dynamic_gpirt ¶
fit_dynamic_gpirt(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_gpirt ¶
fit_gpirt(response_matrix: Any, engine: str = 'spline_reference', external_engine: Callable[..., Any] | None = None, spline_df: int = 5, **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_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
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_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_variational_irt ¶
fit_variational_irt(response_matrix: Any, external_engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
latent_trait_trajectory ¶
process_dif_nuisance_surrogate ¶
process_dif_nuisance_surrogate(data: Any, process_features: Sequence[str], person: str = 'participant_id', aggregate: bool = True) -> pd.DataFrame
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
process_ngram_features ¶
process_ngram_features(sequence: Any, n: Sequence[int] = (1, 2, 3), separator: str = '>') -> np.ndarray
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_sequence_embedding ¶
process_sequence_embedding(sequence: Any, n: Sequence[int] = (1, 2, 3), dimensions: int = 5) -> np.ndarray
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
validate_latent_space_process_similarity ¶
validate_latent_space_process_similarity(object: Any, process_matrix: Any, entity: str = 'person') -> EyeResult
aoi_perturbation_spec ¶
aoi_perturbation_spec(perturbation_id: str, operation: str = 'baseline', *, margin_x: float = 0.0, margin_y: float | None = None, translation_x: float = 0.0, translation_y: float = 0.0, unit: str = 'px', screen_width_px: int | None = None, screen_height_px: int | None = None, viewing_distance: float | None = None, physical_screen_size: Sequence[float] | None = None, degrees_per_pixel: Sequence[float] | None = None, seed: int | None = None, boundary_policy: str = 'warn') -> EyeResult
Create a validated, reproducible AOI perturbation specification.
assess_aoi_inference_stability ¶
compare_aoi_assignments ¶
compare_aoi_assignments(baseline: Sequence[Any], perturbed: Sequence[Any], *, ids: Sequence[Any] | None = None) -> EyeResult
convert_aoi_margin_to_degrees ¶
convert_aoi_margin_to_degrees(margin_pixels: Any, *, screen_width_px: int, screen_height_px: int, viewing_distance: float, physical_screen_size: Sequence[float]) -> tuple[float, float]
Convert pixel margins to degrees of visual angle on x and y axes.
convert_aoi_margin_to_pixels ¶
convert_aoi_margin_to_pixels(margin_degrees: Any, *, screen_width_px: int, screen_height_px: int, viewing_distance: float, physical_screen_size: Sequence[float]) -> tuple[float, float]
Convert visual-angle margins to pixels on x and y axes.
create_aoi_perturbation_grid ¶
create_aoi_perturbation_grid(*, dilations: Iterable[float] | None = None, erosions: Iterable[float] | None = None, translations_x: Iterable[float] | None = None, translations_y: Iterable[float] | None = None, translations_xy: Iterable[Sequence[float]] | None = None, jitters: Iterable[float] | None = None, anisotropic: Iterable[Sequence[float]] | None = None, unit: str = 'px', include_baseline: bool = True, seed: int = 20260918, **geometry_kwargs: Any) -> EyeResult
Create a deterministic perturbation grid without silently crossing choices.
estimate_aoi_assignment_stability ¶
estimate_aoi_assignment_stability(comparisons: Mapping[str, Any] | DataFrame, *, metadata: DataFrame | None = None, group_cols: Sequence[str] | None = None) -> EyeResult
estimate_fixation_assignment_probability ¶
estimate_fixation_assignment_probability(assignments: Mapping[str, Sequence[Any]] | DataFrame, *, ids: Sequence[Any] | None = None, include_baseline: bool = True) -> pd.DataFrame
Estimate empirical assignment frequencies across a declared perturbation set.
jitter_aoi ¶
jitter_aoi(aois: DataFrame, x: float, y: float | None = None, *, seed: int = 20260918, **kwargs: Any) -> pd.DataFrame
perturb_aoi_geometry ¶
Apply one perturbation and preserve nominal and transformed provenance.
plot_aoi_coefficient_stability ¶
plot_aoi_perturbations ¶
plot_aoi_perturbations(x: Any, *, perturbation_id: str | None = None, data: DataFrame | None = None, x_col: str | None = None, y_col: str | None = None, ax: Any = None)
plot_aoi_robustness_surface ¶
plot_aoi_robustness_surface(x: Any, *, value_col: str = 'proportion_unchanged', x_col: str = 'margin_x', y_col: str = 'margin_y', ax: Any = None)
recompute_aoi_features ¶
recompute_aoi_features(data: DataFrame, assignments: Sequence[Any], *, participant_col: str | None = None, trial_col: str | None = None, duration_col: str | None = None, time_col: str | None = None, perturbation_id: str | None = None, aoi_levels: Sequence[str] | None = None, observation_level: str = 'fixation') -> pd.DataFrame
Recompute AOI features without dropping observed zero-assignment cells.
A participant/trial × AOI cell receives a structural zero count only when the group contains at least one non-missing AOI assignment opportunity. Groups whose assignments are all missing retain NA counts/inspection. Dwell is NA when an assigned observation has missing duration, and first-fixation timing is never inferred from row order.
report_aoi_sensitivity ¶
Return a compact manuscript-oriented Markdown report.
run_aoi_sensitivity_analysis ¶
run_aoi_sensitivity_analysis(data: DataFrame, aois: DataFrame, grid: Any, *, x_col: str, y_col: str, observation_id_col: str | None = None, participant_col: str | None = None, trial_col: str | None = None, duration_col: str | None = None, time_col: str | None = None, observation_level: str = 'fixation', overlap_policy: str = 'ambiguous', model_callback: Callable[[DataFrame, DataFrame, Any], DataFrame] | None = None, preprocessing_specification: Any = None, event_detector: Any = None, quality_rules: Any = None, model_specification: Any = None) -> EyeResult
Run geometry perturbation, remapping, feature recomputation, and optional models.
translate_aoi ¶
validate_aoi_geometry ¶
Validate rectangular and polygonal AOI geometry without resolving overlap.
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
bayesian_process_diagnostic_flags ¶
bayesian_process_diagnostic_flags(x: Any, rhat_threshold: float = 1.01, ess_threshold: float = 400) -> pd.DataFrame
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
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_benchmark_release ¶
Audit whether benchmark assets are ready for public release.
benchmark_expected_outputs ¶
Read frozen benchmark reproduction targets and tolerances.
eyeprocess_benchmark_study ¶
Locate the frozen synthetic multimodal benchmark and read its manifest.
import_benchmark_study ¶
Import benchmark tables, preferring the canonical EyeDataset constructor when compatible.
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.
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.
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.
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.
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_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.
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.
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.
benchmark_memory_estimate ¶
Estimate recursive Python memory for an object or generated size.
benchmark_scaling_curve ¶
Estimate the log-log scaling exponent from benchmark results.
eye_benchmark_design ¶
Define a computational benchmark design.
inject_aoi_label_noise ¶
Randomly reassign a proportion of observed AOI labels.
inject_calibration_offset ¶
Inject additive gaze calibration offset.
inject_device_shift ¶
Inject an additive device/site shift in a numeric feature.
inject_eye_missingness ¶
Inject generic missingness into selected columns.
inject_pupil_dropout ¶
Inject pupil dropout.
inject_sampling_jitter ¶
Inject Gaussian timestamp jitter.
inject_trial_imbalance ¶
Inject row/trial imbalance by dropping observations.
run_eye_benchmark ¶
Run the frozen computational scaling-benchmark workflow.
stress_test_process_pipeline ¶
Stress-test an analysis under explicit synthetic corruptions.
stress_tolerance_frontier ¶
Identify the empirical stress frontier for a metric.
summarise_eye_benchmark ¶
Summarise benchmark timing and memory by problem 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.
aoi_balance_coordinates ¶
Calculate user-defined AOI balance coordinates.
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.
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.
fit_aoi_compositional_model ¶
Fit the frozen fixed-effects compositional AOI regression contract.
plot_aoi_balance_biplot ¶
Plot a CLR-PCA compositional balance biplot.
plot_aoi_composition_trajectory ¶
Plot ordered AOI composition trajectories.
plot_aoi_ternary ¶
Plot a three-part AOI dwell composition on a ternary simplex.
plot_aoi_variation_matrix ¶
Plot pairwise variance of AOI log-ratios.
plot_compositional_group_difference ¶
Plot group centroid differences from a composition comparison.
transform_aoi_composition ¶
Transform a composition using ILR, CLR, or ALR coordinates.
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
audit_process_external_validity ¶
audit_process_external_validity(data: Any, criterion: str, predictors: Sequence[str], baseline_predictors: Sequence[str] | None = None) -> 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
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
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
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.
predict_item_parameter_priors ¶
process_feature_blocks ¶
process_feature_blocks(data: Any, blocks: Mapping[str, Sequence[str] | str], id: str | None = None, drop_constant: bool = True) -> 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
convert_coordinates ¶
convert_coordinates(x, from_, to, components=('gaze_samples', 'episodes', 'aoi_geometry'), clip=False, overwrite=False)
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_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_clock_alignment ¶
Plot gaze and biometric clock overlap by recording.
plot_coordinate_spaces ¶
Plot canonical coordinate-space usage counts.
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_feature_correlation ¶
Plot pairwise feature correlations from features_wide.
plot_feature_distribution ¶
Plot one feature as a histogram or grouped boxplot.
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_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_item_difficulty ¶
Plot item difficulty from an eyeprocess model.
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_model_diagnostics ¶
Plot generic fitted-versus-residual diagnostics when available.
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_sampling_rate ¶
Plot estimated gaze sampling rates.
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_signal_quality ¶
Plot signal-quality fractions returned by audit_signal_quality.
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_trial_timeline ¶
Plot trial start/end intervals.
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)
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.
assess_detector_inference_stability ¶
assess_detector_inference_stability(x: DetectorInferenceResult, *, term: str, substantive_threshold: float | None = None, direction: str = 'above') -> pd.DataFrame
Summarize coefficient stability across all planned detector specifications.
The denominator is the declared detector multiverse, not only branches that emitted the requested term. Model failures and missing-term branches therefore reduce the reported convergence rate rather than disappearing from it.
compare_event_catalogues ¶
compare_event_catalogues(reference: DataFrame, candidate: DataFrame, *, event_type: str = 'fixation', onset_tolerance_ms: float = 75.0, minimum_overlap: float = 0.1) -> pd.DataFrame
Compare two event catalogues using one-to-one temporal matching.
create_detector_multiverse ¶
create_detector_multiverse(specs: Sequence[EventDetectorSpec] | None = None, *, base_spec: EventDetectorSpec | None = None, parameter_grid: Mapping[str, Sequence[Any]] | None = None, id_template: str = '{base}_{index:03d}', label: str = 'event_detector_multiverse') -> DetectorMultiverse
Create a deterministic detector multiverse from explicit specs or a grid.
define_event_detector_spec ¶
define_event_detector_spec(detector_id: str, algorithm: str, *, velocity_threshold: float | None = None, dispersion_threshold: float | None = None, minimum_duration_ms: float | None = None, maximum_gap_ms: float | None = None, merge_rule: str = 'none', sampling_rate: float | None = None, smoothing: str | None = None, filter: str | None = None, coordinate_unit: str = 'degrees', implementation: str | None = None, implementation_version: str | None = None, parameters: Mapping[str, Any] | None = None, callback: Callable[..., Any] | None = None) -> EventDetectorSpec
Create and validate a canonical detector specification.
Thresholds are intentionally not given universal defaults. A threshold must be supplied when the selected algorithm requires one.
detect_events_with_spec ¶
Run one explicit detector specification and return an isolated EyeDataset branch.
estimate_detector_agreement ¶
estimate_detector_agreement(x: DetectorMultiverseResult | DataFrame, *, event_type: str = 'fixation', onset_tolerance_ms: float = 75.0, minimum_overlap: float = 0.1) -> pd.DataFrame
Pairwise detector agreement across all successful detector branches.
import_external_detector_events ¶
import_external_detector_events(events: DataFrame, spec: EventDetectorSpec, *, dataset: EyeDataset | None = None) -> pd.DataFrame
Validate and normalize an external detector event catalogue.
match_detected_events ¶
match_detected_events(reference: DataFrame, candidate: DataFrame, *, event_type: str = 'fixation', onset_tolerance_ms: float = 75.0, minimum_overlap: float = 0.1) -> pd.DataFrame
One-to-one temporal matching robust to different event catalogue lengths.
plot_detector_agreement ¶
plot_detector_agreement(x: DetectorMultiverseResult, *, metric: str = 'mean_event_overlap', ax: Any = None)
Plot pairwise detector agreement as a matrix.
plot_detector_coefficient_stability ¶
Plot coefficient estimates and confidence intervals by detector.
plot_detector_event_timeline ¶
plot_detector_event_timeline(x: DetectorMultiverseResult | DataFrame, *, trial_id: str | None = None, event_type: str = 'fixation', ax: Any = None)
Plot detected event intervals by detector.
plot_detector_feature_distributions ¶
plot_detector_feature_distributions(x: DetectorMultiverseResult, *, feature: str = 'dwell_time_ms', aoi_id: str | None = None, ax: Any = None)
Plot feature distributions by detector.
plot_detector_multiverse ¶
plot_detector_multiverse(x: DetectorMultiverseResult, *, inference: DetectorInferenceResult | None = None, term: str | None = None, feature: str = 'dwell_time_ms', aoi_id: str | None = None)
Return a dictionary of separate detector-multiverse diagnostic figures.
propagate_detector_to_aoi ¶
propagate_detector_to_aoi(x: DetectorMultiverseResult, *, overlap: str = 'error', continue_on_error: bool = True) -> DetectorMultiverseResult
Assign AOIs independently within every detector branch.
propagate_detector_to_features ¶
propagate_detector_to_features(x: DetectorMultiverseResult, *, continue_on_error: bool = True) -> DetectorMultiverseResult
Recompute AOI features for every successful detector branch, including zero-event trials.
report_detector_multiverse ¶
report_detector_multiverse(x: DetectorMultiverseResult, *, inference: DetectorInferenceResult | None = None, term: str | None = None, substantive_threshold: float | None = None, path: str | None = None) -> str
Create a compact reproducible Markdown detector-sensitivity report.
run_detector_inference_multiverse ¶
run_detector_inference_multiverse(x: DetectorMultiverseResult, model_spec: Mapping[str, Any], *, model_callback: Callable[[DataFrame, Mapping[str, Any]], DataFrame] | None = None, minimum_valid_fraction: float | None = None) -> DetectorInferenceResult
Fit the identical explicit model specification across detector branches.
Row attrition is never silent: AOI selection, quality filtering, non-finite outcomes, model rows used, and branch status are retained in input_audit and propagated to coefficient rows when a model is fitted.
run_detector_multiverse ¶
run_detector_multiverse(x: EyeDataset, multiverse: DetectorMultiverse | Sequence[EventDetectorSpec], *, continue_on_error: bool = True) -> DetectorMultiverseResult
Run all detector branches independently in deterministic detector-id order.
simulate_detector_multiverse_data ¶
simulate_detector_multiverse_data(*, n_participants: int = 12, sampling_rate: float = 60.0, trial_duration_s: float = 2.0, seed: int = 20260918) -> EyeDataset
Create a small synthetic 60-Hz dataset with a known disclosure-dwell effect.
summarise_detector_disagreement ¶
summarise_detector_disagreement(x: DetectorMultiverseResult, *, event_type: str = 'fixation') -> pd.DataFrame
Pairwise detector disagreement expressed without assuming a gold standard.
summarise_detector_events ¶
Detector-level event counts and fixation-duration summaries.
summarise_detector_robustness ¶
summarise_detector_robustness(x: DetectorMultiverseResult, *, inference: DetectorInferenceResult | None = None, term: str | None = None, substantive_threshold: float | None = None, direction: str = 'above') -> dict[str, pd.DataFrame]
Return event-, feature-, and inference-level robustness summaries.
validate_event_detector_spec ¶
Validate a detector specification; returns True invisibly on success.
assign_dynamic_aoi ¶
assign_dynamic_aoi(samples: Any, aois: Any, *, time: str = 'timestamp', x: str = 'gaze_x', y: str = 'gaze_y', interpolation: str = 'linear', lag_tolerance: float = 0.0, overlap: str = 'ambiguous') -> EyeResult
Assign samples to time-indexed AOIs with explicit overlap and coverage states.
audit_dynamic_aoi_coverage ¶
Summarize assignment, uncovered time, outside geometry, and ambiguity.
dynamic_aoi_sensitivity ¶
dynamic_aoi_sensitivity(samples: Any, aois: Any, *, lag_tolerances: Sequence[float] = (0.0,), interpolations: Sequence[str] = ('linear', 'step'), **kwargs: Any) -> pd.DataFrame
Compare dynamic-AOI assignments across declared timing/interpolation choices.
plot_dynamic_aoi_alignment ¶
Plot assignment status counts for a dynamic-AOI result.
validate_dynamic_aoi_spec ¶
validate_dynamic_aoi_spec(aois: Any, *, aoi: str = 'aoi', time: str = 'timestamp', shape: str = 'shape') -> EyeResult
Validate rectangle, polygon, or mask keyframes without filling missing geometry.
compare_dynamic_transition_models ¶
compare_dynamic_transition_models(*models: Any, criterion: str = 'AIC', **named: Any) -> pd.DataFrame
decode_dynamic_states ¶
diffusion_identification_study ¶
diffusion_identification_study(conditions: Any = None, replications: int = 20, base_seed: int = 20260805, spec: EyeResult | None = None) -> EyeResult
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
dynamic_irtree_recovery ¶
dynamic_irtree_recovery(grid: Any = None, replications: int = 20, spec: EyeResult | None = None, base_seed: int = 1) -> EyeResult
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
dynamic_posterior_predictive_check ¶
dynamic_transition_design ¶
dynamic_transition_design(data: Any, spec: EyeResult | None = None, formula: Any = None) -> 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
fit_dynamic_irtree ¶
fit_dynamic_irtree(x: Any, spec: EyeResult | None = None, min_transitions: int = 10, seed: int = 1, **kwargs: Any) -> 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
fit_gaze_diffusion_irt ¶
fit_gaze_diffusion_irt(data: Any, spec: EyeResult | None = None, seed: int = 1, **kwargs: Any) -> EyeResult
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_multinomial_transition ¶
fit_multinomial_transition(design: EyeResult, ridge: float = 0.0001, reference_state: str | None = None, control: Mapping[str, Any] | None = None) -> EyeResult
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
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_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
prepare_gaze_diffusion_data ¶
prepare_strategy_mixture_data ¶
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
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
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
strategy_aoi_sensitivity ¶
strategy_aoi_sensitivity(datasets: Mapping[str, Any] | Sequence[Any], spec: EyeResult, seed: int = 1, **kwargs: Any) -> EyeResult
strategy_classification_uncertainty ¶
strategy_label_switching_diagnostics ¶
strategy_posterior_probabilities ¶
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
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
transition_residual_diagnostics ¶
validate_strategy_manipulation ¶
validate_strategy_manipulation(object: EyeResult, condition: str, expected_strategy: str, minimum_contrast: float = 0) -> EyeResult
as_procdata_sequence ¶
as_procdata_sequence(x: Any, source: str = 'visits', collapse_consecutive: bool = True) -> pd.DataFrame
as_seqhmm_data ¶
as_traminer_sequence ¶
as_traminer_sequence(x: Any, source: str = 'visits', collapse_consecutive: bool = True, create_object: bool = False) -> pd.DataFrame
compare_engine_adapters ¶
Compare multiple external-engine adapter results.
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.
engine_adapter_status ¶
Report one adapter's availability and stable contract.
external_model_engines ¶
List frozen external-engine adapters and exact-engine availability.
eyeprocess_api_version ¶
Return the frozen public API contract version (R: eyeprocess_api_version).
eyeprocess_deprecation ¶
eyeprocess_deprecation(old: Any, replacement: Any, since: Any, remove_after: Any, reason: str = '') -> pd.DataFrame
Return a structured deprecation record.
fit_brms_adapter ¶
fit_diffirt_adapter ¶
Strict legacy diffusion-IRT adapter from R/020.
fit_diffirt_engine_adapter ¶
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.
fit_eyetrackingr_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).
fit_lnirt_adapter ¶
fit_mirt_adapter ¶
fit_openmx_adapter ¶
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.
fit_pupillometryr_adapter ¶
fit_seqhmm_adapter ¶
fit_tam_adapter ¶
fit_traminer_adapter ¶
object_schema ¶
Describe a stable eyeprocess object schema.
plot_eye_engine_comparison ¶
Python counterpart of plot.eye_engine_comparison with plot-data attached.
upgrade_eyeprocess_model ¶
Upgrade a list-like legacy model to the stable eyeprocess model contract.
validate_engine_adapter ¶
Validate the stable external-engine adapter result contract.
validate_model_object ¶
Validate a fitted model against the stable 1.0.0 model contract.
benchmark_event_detector ¶
benchmark_event_detector(truth: Any, detected: Any, *, start: str = 'start_time', end: str = 'end_time', event_type: str = 'event_type', group: str | None = None, minimum_iou: float = 0.5) -> EyeResult
Benchmark detected events against an explicit annotated event catalogue.
compare_event_detectors ¶
Compare named detector catalogues against the same truth annotations.
detector_parameter_sensitivity ¶
detector_parameter_sensitivity(data: Any, truth: Any, detector: Callable[..., Any], parameter_grid: Mapping[str, Sequence[Any]], *, benchmark_kwargs: Mapping[str, Any] | None = None) -> EyeResult
Run a declared detector parameter grid and keep failed branches visible.
event_boundary_error ¶
Return signed and absolute onset/offset errors for matched events.
event_confusion_matrix ¶
event_confusion_matrix(truth: Any, detected: Any, *, start: str = 'start_time', end: str = 'end_time', event_type: str = 'event_type', sample_step: float = 1.0, none_label: str = 'none') -> pd.DataFrame
Compute a time-sampled event-label confusion matrix at an explicit resolution.
plot_detector_benchmark ¶
Plot one benchmark metric across detectors.
build_evidence_graph ¶
build_evidence_graph(raw_data, transformations=None, metrics=None, models=None, diagnostics=None, decisions=None, edges=None)
crossmodal_recurrence_model ¶
crossmodal_recurrence_model(x, y, outcome=None, channels='gaze_pupil', radius=None, covariates=None)
fit_process_missingness_model ¶
plot_eye_crossmodal_recurrence_model ¶
add_responses ¶
Add canonical response rows, optionally replacing matching response keys.
analysis_readiness ¶
Summarize readiness across schema, time, coordinates, trials, and quality.
as_eye_dataset ¶
Coerce an object to :class:EyeDataset like R as_eye_dataset().
assign_aois ¶
Assign registered AOIs to gaze samples or episodes.
assign_trials ¶
Assign trial IDs to time-stamped tables from canonical intervals.
audit_clock_sync ¶
Audit temporal overlap between gaze and biometric streams.
audit_episodes ¶
Summarize episode counts and basic structural issues by episode type.
audit_event_order ¶
Audit event timestamp order within each recording.
audit_missingness ¶
Report missing/non-finite fractions by field and grouping key.
audit_pupil_quality ¶
Audit interpolation burden and optional plausible pupil range.
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_trial_coverage ¶
Audit canonical trial intervals and attached observations.
build_aoi_visits ¶
Aggregate contiguous AOI observations into canonical visit episodes.
build_item_responses ¶
Create response rows from trial intervals when no responses exist.
build_stimulus_intervals ¶
Build contiguous stimulus/media intervals.
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.
check_feature_level ¶
Check required identifying keys for each feature aggregation level.
check_process_leakage ¶
Flag feature windows extending beyond their response timestamp.
compare_aoi_definitions ¶
Compare AOI assignment counts across alternative definition sets.
compare_preprocessing ¶
compare_preprocessing(*xs, metrics=('valid_gaze_fraction', 'valid_pupil_fraction', 'fixation_count'))
Compare basic quality/feature summaries across preprocessing pipelines.
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.
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.
sensitivity_process ¶
Return the frozen preprocessing-sensitivity summary contract.
store_quality ¶
Store quality rows in the canonical quality table.
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_frontier_model_contract ¶
fit_crossclassified_process_irt_mhrm ¶
fit_crossclassified_process_irt_mhrm(data: Any, engine: Callable[..., Any] | None = None, **kwargs: Any) -> EyeResult
fit_kde_latent_distribution_irt ¶
fit_kde_latent_distribution_irt(response_matrix: 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
fit_persistence_gaze_diffusion_irt ¶
fit_persistence_gaze_diffusion_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
advanced_validation_grid ¶
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
extract_functional_pupil_parameters ¶
extract_functional_pupil_parameters(x: Any, pattern: str | None = None, confidence: float = 0.95) -> 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 ¶
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
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 ¶
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
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
inject_blink_gaps ¶
inject_blink_gaps(data: Any, *, columns: Sequence[str] = ('gaze_x_deg', 'gaze_y_deg'), fraction: float = 0.05, mean_gap_samples: int = 10, seed: int = 1) -> pd.DataFrame
Inject contiguous missing gaps rather than independent random missingness.
inject_event_misclassification ¶
inject_event_misclassification(data: Any, *, event_type: str = 'event_type', probability: float = 0.05, seed: int = 1) -> pd.DataFrame
Perturb event labels while preserving the clean label for recovery analyses.
inject_spatial_drift ¶
inject_spatial_drift(data: Any, *, x: str = 'gaze_x_deg', y: str = 'gaze_y_deg', max_offset_x: float = 1.0, max_offset_y: float = 0.0) -> pd.DataFrame
Inject a linear session drift while retaining original columns.
inject_spatial_noise ¶
inject_spatial_noise(data: Any, *, x: str = 'gaze_x_deg', y: str = 'gaze_y_deg', sd: float = 0.1, seed: int = 1) -> pd.DataFrame
Inject zero-mean Gaussian spatial noise.
plot_gaze_stress ¶
Plot a downstream metric against corruption severity.
run_gaze_stress_suite ¶
run_gaze_stress_suite(data: Any, evaluator: Callable[[DataFrame], Mapping[str, float]], *, corruption: str, severities: Sequence[float] = (0.0, 0.25, 0.5, 1.0), seed: int = 1) -> EyeResult
Quantify downstream metric degradation across an explicit corruption curve.
simulate_known_gaze_process ¶
simulate_known_gaze_process(*, n_cycles: int = 4, sampling_hz: float = 300.0, fixation_ms: float = 300.0, saccade_ms: float = 30.0, pursuit_ms: float = 500.0, noise_sd_deg: float = 0.03, seed: int = 1) -> pd.DataFrame
Generate labelled fixation-saccade-pursuit cycles for method validation.
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_biometrics ¶
read_gazepoint_biometrics(path, participant_id=None, recording_id=None, session_id='S001', keep_raw=True, quiet=False, **kwargs)
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_gaze ¶
Gaze-only public alias retained from R read_gazepoint_gaze.
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.
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.
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.
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.
plot_gazepoint_workflow ¶
Create the workflow plot suite and return a plot manifest.
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.
validate_gazepoint_workflow ¶
Validate structural and reproducibility invariants of workflow output.
write_gazepoint_workflow_report ¶
Write the reproducible workflow Markdown report and optional HTML copy.
analysis_decision_entropy ¶
audit_decision_provenance ¶
audit_decision_provenance(x: Any, required_domains: Any = ('sampling', 'validity', 'fixation', 'pupil', 'aoi', 'model', 'sensitivity', 'exclusions'), required_provenance: Any = ('data_source', 'software_version', 'analysis_commit')) -> EyeResult
compare_aoi_methods ¶
compare_aoi_methods(data: Any, methods: Any, analysis_fun: Callable, extract_fun: Callable = _default_sensitivity_extract) -> EyeResult
compare_fixation_methods ¶
compare_fixation_methods(data: Any, methods: Any, analysis_fun: Callable, extract_fun: Callable = _default_sensitivity_extract) -> EyeResult
compare_process_models ¶
compare_process_models(data: Any, methods: Any, analysis_fun: Callable, extract_fun: Callable = _default_sensitivity_extract) -> EyeResult
compare_pupil_preprocessing ¶
compare_pupil_preprocessing(data: Any, methods: Any, analysis_fun: Callable, extract_fun: Callable = _default_sensitivity_extract) -> EyeResult
decision_stability ¶
decision_stability(x: Any, effect: str = 'effect', p_value: str | None = None, alpha: float = 0.05, threshold: float = 0) -> EyeResult
expand_process_validation_design ¶
eye_analysis_pipeline ¶
eye_analysis_pipeline(*args: Any, spec: Any = None, name: str = 'eye_analysis', strict: bool = True) -> EyeResult
eye_analysis_spec ¶
eye_analysis_spec(blink_correction: Any = None, pupil_baseline: Any = None, fixation_algorithm: Any = None, aoi_rule: Any = None, exclusions: Any = None, model: Any = None, sensitivity: Any = None, **kwargs: Any) -> EyeResult
eye_api_inventory ¶
eye_decision_manifest ¶
eye_decision_manifest(sampling: Any = None, validity: Any = None, fixation: Any = None, pupil: Any = None, aoi: Any = None, model: Any = None, sensitivity: Any = None, exclusions: Any = None, provenance: Any = None, notes: Any = None, **kwargs: Any) -> EyeResult
eye_pipeline_step ¶
eye_pipeline_step(name: str, fun: Callable[..., Any], requires: Any = (), optional: bool = False, description: str | None = None, decision: str | None = None) -> EyeResult
freeze_validation_reference ¶
lock_decision_manifest ¶
outcome_blind_snapshot ¶
process_sensitivity_grid ¶
process_sensitivity_grid(*args: Any, label: str = 'process_sensitivity', max_specifications: float = 100000, **kwargs: Any) -> pd.DataFrame
process_validation_design ¶
process_validation_design(n_persons: Any = (50, 150, 500), n_trials: Any = (10, 30, 80), missingness: Any = (0, 0.05, 0.15, 0.3), sampling_rate_hz: Any = (60, 120, 300, 1000), aoi_error: Any = ('low', 'moderate', 'severe'), calibration_error: Any = (0, 0.5, 1), pupil_dropout: Any = (0, 0.1, 0.3), heterogeneity: Any = ('low', 'moderate'), model_misspecification: Any = (False, True), replications: int = 100, seed: int = 1, label: str = 'process_validation') -> EyeResult
read_decision_manifest ¶
register_eye_api_status ¶
register_eye_api_status(registry: Any = None, name: Any = None, status: Any = None, canonical: Any = np.nan, replacement: Any = np.nan, since: str = '0.9.0.9000', notes: Any = np.nan) -> pd.DataFrame
resume_eye_pipeline ¶
resume_eye_pipeline(x: Any, previous: Any, context: Any = None, stop_on_error: bool = True) -> EyeResult
run_eye_pipeline ¶
run_eye_pipeline(x: Any, context: Any = None, stop_on_error: bool = True, previous: Any = None) -> EyeResult
run_process_sensitivity ¶
run_process_sensitivity(data: Any, grid: Any, analysis_fun: Callable, extract_fun: Callable = _default_sensitivity_extract, progress: bool = False) -> EyeResult
run_process_validation ¶
run_process_validation(design: Any, simulate_fun: Callable = simulate_process_validation_data, fit_fun: Callable = _default_validation_fit, extract_fun: Callable = _default_validation_extract, max_conditions: float = math.inf, progress: bool = False) -> EyeResult
sensitivity_decision_leverage ¶
sensitivity_fragility_index ¶
sensitivity_rank_stability ¶
sensitivity_rank_stability(x: Any, id: str | None = None, rank: str | None = None, specification: str | None = None) -> float
sensitivity_significance_stability ¶
sensitivity_threshold_stability ¶
sensitivity_threshold_stability(x: Any, effect: str = 'effect', threshold: float = 0, direction: str = 'above') -> float
simulate_process_validation_data ¶
simulate_process_validation_data(condition: Any, replication: int = 1, seed: int | None = None, beta: float = 0.35) -> EyeResult
specification_curve_data ¶
specification_curve_data(x: Any, effect: str = 'effect', lower: str | None = None, upper: str | None = None) -> pd.DataFrame
summarise_process_sensitivity ¶
summarise_process_sensitivity(x: Any, effect: str = 'effect', p_value: str | None = None, threshold: float = 0, alpha: float = 0.05) -> pd.DataFrame
validate_against_reference ¶
validate_decision_manifest ¶
validate_decision_manifest(x: Any, required_domains: Any = ('sampling', 'validity', 'fixation', 'pupil', 'aoi', 'model', 'sensitivity', 'exclusions'), require_nonempty: bool = False) -> bool
validation_condition_ranking ¶
validation_coverage_table ¶
write_decision_manifest ¶
write_eye_targets_template ¶
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.
crossed_grouped_folds ¶
Create cross-classified folds with a deliberate mixed-level buffer.
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.
grouped_folds ¶
Create grouped folds so declared independent groups never cross folds.
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.
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.
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).
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.
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.
import_eye_bids ¶
Import Eye-Tracking-BIDS physiological recordings.
open_eye_storage ¶
Open a storage handle without collecting all canonical tables.
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.
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.
as_eye_biometrics ¶
Coerce an EyeDataset/DataFrame to the canonical biometrics table.
compare_eye_datasets ¶
Compare two canonical datasets table-by-table with numeric tolerance.
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.
discover_validation_cases ¶
Discover file/directory validation cases under a corpus directory.
eye_format_profiles ¶
Return the frozen 12-row source-format support/validation profile.
fingerprint_eye_dataset ¶
Compute deterministic per-table content fingerprints.
format_compatibility_matrix ¶
Return declared format capabilities plus empirical corpus tallies.
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.
init_validation_corpus ¶
Initialize the private real-export validation-corpus template.
inspect_eye_source ¶
Inspect file/folder structure, delimiters, columns, hashes, and format detection.
read_eye_dataset ¶
Read the canonical folder format written by R/Python-compatible table serialization.
read_validation_manifest ¶
Read and validate a corpus manifest, resolving relative source paths.
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.
roundtrip_eye_dataset ¶
Write/read the canonical folder representation and compare all tables.
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.
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.
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.
validate_eyelink_export ¶
Validate EyeLink ASC/Data Viewer shape and explicitly flag EDF conversion.
validate_generic_export ¶
Validate readability and inferability of a generic mapped delimited export.
validate_pupillabs_export ¶
Validate Pupil Labs Neon/Core source shape without claiming an unavailable adapter.
validate_smi_export ¶
Validate SMI/BeGaze textual exports; proprietary IDF remains unsupported.
validate_tobii_export ¶
Validate basic Tobii Pro Lab delimited-export structure.
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.
write_eye_dataset ¶
Write the canonical folder format; native RDS remains an explicit backend boundary.
write_format_validation_report ¶
Write a Markdown report for one validation result or a validation corpus.
write_provenance ¶
Write provenance as CSV or JSON; native RDS is explicitly gated.
eyeprocess_cdm_attribute_profiles ¶
eyeprocess_cdm_attribute_profiles(n_attributes: int, attribute_names: Sequence[str] | None = None) -> pd.DataFrame
eyeprocess_cdm_classification_uncertainty ¶
eyeprocess_cdm_dina_ideal_response ¶
eyeprocess_cdm_dina_probability ¶
eyeprocess_cdm_dina_probability(ideal_response: Any, slip: Any = 0.1, guess: Any = 0.2) -> np.ndarray
eyeprocess_cdm_qmatrix_audit ¶
eyeprocess_cdm_qmatrix_audit(Q: Any, item_ids: Sequence[str] | None = None, attribute_names: Sequence[str] | None = None) -> EyeResult
eyeprocess_irt_2pl_probability ¶
eyeprocess_irt_3pl_probability ¶
eyeprocess_irt_3pl_probability(theta: Any, a: float = 1, b: float = 0, c: float = 0.2, D: float = 1) -> np.ndarray
eyeprocess_irt_4pl_probability ¶
eyeprocess_irt_4pl_probability(theta: Any, a: float = 1, b: float = 0, c: float = 0, d: float = 1, D: float = 1) -> np.ndarray
eyeprocess_irt_adaptive_trace ¶
eyeprocess_irt_adaptive_trace(item_id: Sequence[str], theta_before: Any, theta_after: Any, se_after: Any, information: Any, response: Any = np.nan) -> pd.DataFrame
eyeprocess_irt_anchor_audit ¶
eyeprocess_irt_anchor_audit(items: Any, dif: Any = None, max_abs_effect: float = 0.1, min_information: float | None = None) -> pd.DataFrame
eyeprocess_irt_anchor_purification ¶
eyeprocess_irt_anchor_purification(items: Any, effect_fun: Callable[[list[str]], Any], initial: Sequence[str] | None = None, threshold: float = 0.1, max_iter: int = 10) -> EyeResult
eyeprocess_irt_bank_coverage ¶
eyeprocess_irt_bank_coverage(items: Any, theta: Any = np.linspace(-4, 4, 161), target_information: float = 5, target: Sequence[float] = (-2, 2)) -> EyeResult
eyeprocess_irt_category_function_audit ¶
eyeprocess_irt_classification_precision ¶
eyeprocess_irt_classification_precision(theta_estimate: Any, standard_error: Any, cut_score: Any = 0, confidence: float = 0.95) -> pd.DataFrame
eyeprocess_irt_content_balance_audit ¶
eyeprocess_irt_content_balance_audit(administered: Sequence[str], item_bank: Any, target: Mapping[str, float] | None = None) -> pd.DataFrame
eyeprocess_irt_device_drift ¶
eyeprocess_irt_device_drift(parameters: Any, item_id: str = 'item_id', device: str = 'device', parameter: str = 'b') -> pd.DataFrame
eyeprocess_irt_dif_effect_curve ¶
eyeprocess_irt_dif_effect_curve(reference_item: Any, focal_item: Any, theta: Any = np.linspace(-4, 4, 81)) -> pd.DataFrame
eyeprocess_irt_dtf_curve ¶
eyeprocess_irt_dtf_curve(reference: Any, focal: Any, theta: Any = np.linspace(-4, 4, 81)) -> pd.DataFrame
eyeprocess_irt_eap_score ¶
eyeprocess_irt_eap_score(response: Any, items: Any, theta_grid: Any = np.linspace(-4, 4, 81), prior_mean: float = 0, prior_sd: float = 1, D: float = 1) -> EyeResult
eyeprocess_irt_expected_score ¶
eyeprocess_irt_exposure_summary ¶
eyeprocess_irt_exposure_summary(administered: Sequence[str], item_bank_ids: Sequence[str] | None = None) -> pd.DataFrame
eyeprocess_irt_extreme_score_audit ¶
eyeprocess_irt_extreme_score_audit(responses: Any, lower_fraction: float = 0.02, upper_fraction: float = 0.98) -> pd.DataFrame
eyeprocess_irt_fit_dashboard ¶
eyeprocess_irt_fit_dashboard(item_fit: Any = None, person_fit: Any = None, q3: Any = None, parameter_audit: Any = None, identification: Any = None) -> EyeResult
eyeprocess_irt_functioning_effect_summary ¶
eyeprocess_irt_gpcm_probability ¶
eyeprocess_irt_gpcm_probability(theta: Any, a: float = 1, steps: Sequence[float] = (), D: float = 1) -> np.ndarray
eyeprocess_irt_grm_probability ¶
eyeprocess_irt_grm_probability(theta: Any, a: float = 1, thresholds: Sequence[float] = (), D: float = 1) -> np.ndarray
eyeprocess_irt_haebara_link ¶
eyeprocess_irt_haebara_link(reference: Any, focal: Any, anchors: Sequence[str] | None = None, theta: Any = np.linspace(-4, 4, 81), weights: Any = None, start: Sequence[float] = (1, 0)) -> EyeResult
eyeprocess_irt_identification_audit ¶
eyeprocess_irt_identification_audit(spec: Any, constraints: Mapping[str, Any] | None = None, n_items: int | None = None, n_persons: int | None = None) -> EyeResult
eyeprocess_irt_infit_outfit ¶
eyeprocess_irt_infit_outfit(observed: Any, expected: Any, by: str = 'item', min_variance: float = 1e-08) -> pd.DataFrame
eyeprocess_irt_information_area ¶
eyeprocess_irt_information_gain ¶
eyeprocess_irt_information_targeting ¶
eyeprocess_irt_information_targeting(items: Any, theta: Any, weights: Any = None, D: float = 1) -> EyeResult
eyeprocess_irt_invariance_evidence ¶
eyeprocess_irt_invariance_evidence(anchor_audit: Any = None, dif: Any = None, dtf: Any = None, linking: Any = None, process_concordance: Any = None) -> EyeResult
eyeprocess_irt_item_bank ¶
eyeprocess_irt_item_bank(items: Any, content: Sequence[str] | None = None, exposure_limit: float = 1) -> EyeResult
eyeprocess_irt_item_fit_residuals ¶
eyeprocess_irt_item_fit_residuals(responses: Any, probabilities: Any, item_ids: Sequence[str] | None = None) -> pd.DataFrame
eyeprocess_irt_item_information ¶
eyeprocess_irt_item_information(theta: Any, family: str = '2pl', D: float = 1, **kwargs: Any) -> np.ndarray
eyeprocess_irt_item_selection ¶
eyeprocess_irt_item_selection(bank: Any, theta: float, administered: Sequence[str] = (), exposure: Any = None, content_required: Sequence[str] | None = None, D: float = 1) -> EyeResult
eyeprocess_irt_latent_regression_design ¶
eyeprocess_irt_latent_regression_design(data: Any, formula: str, center_numeric: bool = True) -> EyeResult
eyeprocess_irt_link_stability ¶
eyeprocess_irt_link_stability(reference: Any, focal: Any, anchor_sets: Sequence[Sequence[str]] | Mapping[str, Sequence[str]], method: str = 'mean-sigma') -> EyeResult
eyeprocess_irt_local_dependence_pairs ¶
eyeprocess_irt_local_dependence_pairs(q3: Any, threshold: float = 0.2, absolute: bool = True) -> pd.DataFrame
eyeprocess_irt_map_score ¶
eyeprocess_irt_map_score(response: Any, items: Any, bounds: Sequence[float] = (-6, 6), prior_mean: float = 0, prior_sd: float = 1, D: float = 1) -> EyeResult
eyeprocess_irt_marginal_reliability ¶
eyeprocess_irt_mean_mean_link ¶
eyeprocess_irt_mean_mean_link(reference: Any, focal: Any, anchors: Sequence[str] | None = None) -> EyeResult
eyeprocess_irt_mean_sigma_link ¶
eyeprocess_irt_mean_sigma_link(reference: Any, focal: Any, anchors: Sequence[str] | None = None) -> EyeResult
eyeprocess_irt_measurement_precision_profile ¶
eyeprocess_irt_measurement_precision_profile(theta: Any, items: Any, target: Sequence[float] = (-2, 2), D: float = 1) -> EyeResult
eyeprocess_irt_missing_by_design_audit ¶
eyeprocess_irt_missing_by_design_audit(responses: Any, design: Any = None, min_administered: int = 1) -> EyeResult
eyeprocess_irt_misspecification_metrics ¶
eyeprocess_irt_misspecification_metrics(reference_summary: Any, misspecified_summary: Any) -> pd.DataFrame
eyeprocess_irt_mle_score ¶
eyeprocess_irt_mle_score(response: Any, items: Any, bounds: Sequence[float] = (-6, 6), D: float = 1) -> EyeResult
eyeprocess_irt_model_card ¶
eyeprocess_irt_model_card(spec: Any, engine_status: Any = None, identification: Any = None, fit_evidence: Any = None, invariance: Any = None, validation: Any = None, intended_use: Any = None, excluded_interpretations: Sequence[str] = ('diagnosis', 'cheating inference', 'mental-state inference')) -> EyeResult
eyeprocess_irt_model_spec ¶
eyeprocess_irt_model_spec(family: str = 'rasch', dimensions: int = 1, identification: str = 'theta_standard', engine: str = 'native_math', process_channels: Sequence[str] = (), status: str = 'reference', notes: str | None = None) -> EyeResult
eyeprocess_irt_monotonicity_audit ¶
eyeprocess_irt_monotonicity_audit(theta: Any, probability: Any, tolerance: float = 1e-08) -> EyeResult
eyeprocess_irt_nominal_probability ¶
eyeprocess_irt_nominal_probability(theta: Any, slopes: Sequence[float], intercepts: Sequence[float]) -> np.ndarray
eyeprocess_irt_parameter_plausibility_audit ¶
eyeprocess_irt_parameter_plausibility_audit(items: Any, discrimination: Sequence[float] = (0.2, 4), difficulty: Sequence[float] = (-6, 6), lower_asymptote: Sequence[float] = (0, 0.5), upper_asymptote: Sequence[float] = (0.5, 1)) -> pd.DataFrame
eyeprocess_irt_person_fit_lz ¶
eyeprocess_irt_person_fit_lz(observed: Any, expected: Any, min_probability: float = 1e-08) -> pd.DataFrame
eyeprocess_irt_person_fit_residuals ¶
eyeprocess_irt_person_fit_residuals(responses: Any, probabilities: Any, person_ids: Sequence[str] | None = None) -> pd.DataFrame
eyeprocess_irt_plausible_values ¶
eyeprocess_irt_ppc_discrepancy ¶
eyeprocess_irt_ppc_discrepancy(observed: Any, replicated: Any, statistic: str = 'mean_score') -> EyeResult
eyeprocess_irt_prior_sensitivity_grid ¶
eyeprocess_irt_prior_sensitivity_grid(discrimination_scale: Sequence[float] = (0.5, 1, 1.5), difficulty_scale: Sequence[float] = (1, 2), guessing_mean: Sequence[float] = (0.1, 0.2)) -> pd.DataFrame
eyeprocess_irt_prior_sensitivity_summary ¶
eyeprocess_irt_prior_sensitivity_summary(results: Any, prior_id: str = 'prior_id', estimate: str = 'estimate') -> EyeResult
eyeprocess_irt_prior_spec ¶
eyeprocess_irt_prior_spec(discrimination: str = 'lognormal', difficulty: str = 'normal', guessing: str = 'beta', location: float = 0, scale: float = 1, guessing_shape: Sequence[float] = (5, 17), label: str = 'default') -> EyeResult
eyeprocess_irt_process_alignment ¶
eyeprocess_irt_process_alignment(item_parameters: Any, process_profile: Any, process_columns: Sequence[str] | None = None) -> EyeResult
eyeprocess_irt_process_aware_selection_penalty ¶
eyeprocess_irt_process_aware_selection_penalty(information: Any, burden: Any, burden_weight: float = 0, quality_risk: Any = 0, quality_weight: float = 0) -> np.ndarray
eyeprocess_irt_process_dif_concordance ¶
eyeprocess_irt_process_dif_concordance(dif: Any, process: Any, item_id: str = 'item_id', dif_effect: str = 'effect', process_effect: str = 'effect') -> EyeResult
eyeprocess_irt_q3 ¶
eyeprocess_irt_q3(responses: Any, probabilities: Any, use: str = 'pairwise.complete.obs') -> pd.DataFrame
eyeprocess_irt_recovery_design ¶
eyeprocess_irt_recovery_design(sample_size: Sequence[int] = (250, 750), n_items: Sequence[int] = (12, 24), missing_rate: Sequence[float] = (0, 0.15), testlet_sd: Sequence[float] = (0, 0.35), replications: int = 10, seed: int = 20260811) -> pd.DataFrame
eyeprocess_irt_sbc_ranks ¶
eyeprocess_irt_sbc_ranks(truth: Any, draws: Any, randomize_ties: bool = True, seed: int = 1) -> np.ndarray
eyeprocess_irt_sbc_summary ¶
eyeprocess_irt_score_table ¶
eyeprocess_irt_score_table(responses: Any, items: Any, method: str = 'EAP', person_ids: Sequence[str] | None = None, **kwargs: Any) -> pd.DataFrame
eyeprocess_irt_session_drift ¶
eyeprocess_irt_session_drift(parameters: Any, item_id: str = 'item_id', session: str = 'session', parameter: str = 'b') -> pd.DataFrame
eyeprocess_irt_sparse_design_audit ¶
eyeprocess_irt_sparse_design_audit(data: Any, person: str, item: str, response: str | None = None, min_person_items: int = 3, min_item_persons: int = 10) -> EyeResult
eyeprocess_irt_stocking_lord_link ¶
eyeprocess_irt_stocking_lord_link(reference: Any, focal: Any, anchors: Sequence[str] | None = None, theta: Any = np.linspace(-4, 4, 81), weights: Any = None, start: Sequence[float] = (1, 0)) -> EyeResult
eyeprocess_irt_stopping_rule ¶
eyeprocess_irt_stopping_rule(n_administered: int, se: float = np.nan, min_items: int = 5, max_items: int = 30, target_se: float = 0.3) -> dict[str, Any]
eyeprocess_irt_targeting_gap ¶
eyeprocess_irt_targeting_gap(theta: Any, items: Any, breaks: Any = np.arange(-4, 4.01, 0.5)) -> EyeResult
eyeprocess_irt_test_characteristic_curve ¶
eyeprocess_irt_test_information ¶
eyeprocess_irt_testlet_audit ¶
eyeprocess_irt_testlet_spec ¶
eyeprocess_irt_testlet_spec(item_id: Sequence[str], testlet: Sequence[str], general_dimension: str = 'general') -> pd.DataFrame
eyeprocess_irt_threshold_order_audit ¶
eyeprocess_joint_process_irt_spec ¶
eyeprocess_joint_process_irt_spec(response_family: str = '2pl', time_model: str = 'none', process_channels: Sequence[str] = ('dwell', 'pupil', 'transitions'), person_covariates: Sequence[str] = (), item_covariates: Sequence[str] = (), missingness: str = 'ignorable', status: str = 'experimental') -> EyeResult
eyeprocess_mirt_directional_information ¶
eyeprocess_mirt_directional_information(theta: Any, discrimination: Any, difficulty: float = 0, direction: Any = None, D: float = 1) -> float
eyeprocess_mirt_information_matrix ¶
eyeprocess_mirt_information_matrix(theta: Any, discrimination: Any, difficulty: float = 0, D: float = 1) -> np.ndarray
eyeprocess_mirt_loading_audit ¶
eyeprocess_mirt_loading_spec ¶
eyeprocess_mirt_loading_spec(items: Sequence[str], loadings: Any, dimension_names: Sequence[str] | None = None, simple_structure: bool = False) -> EyeResult
eyeprocess_multichannel_measurement_map ¶
eyeprocess_multichannel_measurement_map(response: str = 'accuracy', channels: Sequence[str] = ('response_time', 'dwell', 'pupil', 'transitions'), role: Sequence[str] | None = None) -> pd.DataFrame
eyeprocess_process_irt_data_bundle ¶
eyeprocess_process_irt_data_bundle(data: Any, person: str, item: str, response: str, response_time: str | None = None, process: Sequence[str] = (), covariates: Sequence[str] = ()) -> EyeResult
eyeprocess_process_item_profile ¶
eyeprocess_process_missingness_pattern ¶
eyeprocess_process_missingness_pattern(data: Any, response: str, channels: Sequence[str]) -> pd.DataFrame
eyeprocess_process_person_profile ¶
eyeprocess_response_time_profile ¶
eyeprocess_response_time_profile(data: Any, person: str, item: str, response_time: str) -> EyeResult
eyeprocess_speed_accuracy_profile ¶
eyeprocess_speed_accuracy_profile(data: Any, person: str, response: str, response_time: str) -> EyeResult
fit_eyeprocess_erm ¶
fit_eyeprocess_gdina ¶
fit_eyeprocess_gdina(dat: Any, Q: Any, model: str = 'GDINA', engine: str = 'GDINA', **kwargs: Any) -> EyeResult
fit_eyeprocess_lnirt ¶
fit_eyeprocess_lnirt(Y: Any, RT: Any, quadratic: bool = False, engine: str = 'LNIRT', **kwargs: Any) -> EyeResult
fit_eyeprocess_mirt ¶
fit_eyeprocess_mirt(data: Any, model: Any = 1, itemtype: str = '2PL', engine: str = 'mirt', **kwargs: Any) -> EyeResult
fit_eyeprocess_tam ¶
fit_eyeprocess_tam(resp: Any, model: str = 'rasch', engine: str = 'TAM', **kwargs: Any) -> EyeResult
freeze_eyeprocess_irt_reference ¶
freeze_eyeprocess_irt_reference(recovery_summary: Any = None, sbc: Any = None, failures: Any = None, metadata: Mapping[str, Any] | None = None) -> EyeResult
run_eyeprocess_equateirt ¶
run_eyeprocess_irt_ability_sbc ¶
run_eyeprocess_irt_ability_sbc(items: Any, replications: int = 200, posterior_draws: int = 99, theta_grid: Any = np.linspace(-5, 5, 401), prior_mean: float = 0, prior_sd: float = 1, interval: float = 0.95, seed: int = 20260811, D: float = 1) -> EyeResult
run_eyeprocess_irt_recovery ¶
run_eyeprocess_mirtcat ¶
simulate_eyeprocess_catr ¶
simulate_eyeprocess_catr(itemBank: Any, trueTheta: float = 0, engine: str = 'catR', **kwargs: Any) -> EyeResult
simulate_eyeprocess_irt_binary ¶
simulate_eyeprocess_irt_binary(n_persons: int = 500, items: Any = None, theta: Any = None, missing_rate: float = 0, testlet_sd: float = 0, seed: int = 1, D: float = 1) -> EyeResult
validate_eyeprocess_external_irt_fit ¶
validate_eyeprocess_joint_process_irt_spec ¶
audit_bias ¶
audit_bias(results: Any, threshold: float = 0.1, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> 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
audit_convergence ¶
audit_convergence(results: Any, minimum: float = 0.95, by: Sequence[str] = ('scenario', 'engine')) -> pd.DataFrame
audit_coverage ¶
audit_coverage(results: Any, minimum: float = 0.9, maximum: float = 1, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> 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
audit_interval_width ¶
audit_interval_width(results: Any, maximum: float = math.inf, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> 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_rmse ¶
audit_rmse(results: Any, threshold: float = 0.3, by: Sequence[str] = ('scenario', 'engine', 'parameter')) -> pd.DataFrame
calibration_transfer_audit ¶
external_validate_irt ¶
external_validate_irt(train_data: Any, external_data: Any, fitter: Callable, predictor: Callable, scorer: Callable, label: str = 'external') -> pd.DataFrame
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
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
leave_device_out_validation ¶
leave_device_out_validation(data: Any, device: 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
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
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
posterior_predictive_discrepancies ¶
posterior_predictive_discrepancies(observed: Any, replicated: Any, discrepancies: Mapping[str, Callable[[Any], float]] | None = None) -> pd.DataFrame
posterior_sbc_contract ¶
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_posterior_sbc ¶
run_posterior_sbc(observed_data: Any, contract: Any, replications: int = 100, seed: int = 20260808) -> EyeResult
run_sbc ¶
run_sbc(simulator: Callable[[int], Any], fitter: Callable[[Any], Any], posterior_draws: Callable[[Any], Any], replications: int = 100, seed: int = 20260808) -> EyeResult
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_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_misspecification ¶
stress_test_misspecification(scenarios: Any, runner: Callable[[Any, int], Any], 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
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
summarize_parameter_recovery ¶
summarize_parameter_recovery(results: Any, by: Sequence[str] = ('scenario', 'engine', 'parameter'), interval_level: float = 0.95) -> pd.DataFrame
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_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_dynamic_aoi_model ¶
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_gaze_informed_irt ¶
fit_gaze_informed_irt(x: Any, response: str = 'score', gaze_features: Sequence[str] = (), engine: str = 'lme4', **kwargs: Any) -> EyeResult
fit_gaze_weighted_choice ¶
fit_gaze_weighted_choice(x: Any, response: str = 'score', dwell_features: Sequence[str] = (), engine: str = 'glm', **kwargs: Any) -> EyeResult
fit_irt ¶
fit_irt(x: Any, engine: str = 'mirt', model: Any = 1, itemtype: str = '2PL', value: str = 'score', **kwargs: Any) -> 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_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
fit_process_irt ¶
fit_pupil_informed_irt ¶
fit_pupil_informed_irt(x: Any, response: str = 'score', pupil_features: Sequence[str] = (), engine: str = 'lme4', **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_strategy_mixture ¶
fit_strategy_mixture(x: Any, features: Sequence[str], centers: int = 2, response_formula: Any = None, seed: int = 1, append: bool = True) -> EyeResult
functional_pupil_features ¶
functional_pupil_features(x: Any, df: int = 5, grid_points: int = 100, append: bool = True, prefix: str = 'pupil_basis') -> Any
model_data ¶
model_data(x: Any, include_features: bool = True, aggregate_features: Callable = np.mean) -> pd.DataFrame
model_missing_process ¶
model_missing_process(x: Any, feature_name: str, predictors: Sequence[str] = ('score', 'response_time'), engine: str = 'glm', **kwargs: Any) -> 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
response_matrix ¶
response_time_matrix ¶
sensitivity_missing_process ¶
sensitivity_missing_process(x: Any, feature_name: str, formula: Any, methods: Sequence[str] = ('complete_case', 'median_indicator')) -> EyeResult
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
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.
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.
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_bank_decision_stability ¶
audit_bank_decision_stability(x: Any, draws: int = 1000, noise_sd: float = 0.1, seed: int = 20260807) -> EyeResult
audit_device_equivalence ¶
audit_device_equivalence(x: Any, equivalence_margin: float, by: Sequence[str] = ('metric', 'task', 'aoi')) -> EyeResult
audit_fairness_transportability ¶
audit_fairness_transportability(x: Any, context: str = 'device', effect: str = 'process_dif', item: str = 'item_id') -> EyeResult
decompose_dif_evidence ¶
decompose_dif_evidence(psychometric: Any, process: Any = None, design_features: Any = None) -> EyeResult
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
fit_process_dif ¶
fit_process_dif(x: Any, response: str, process: str, group: str, item: str, ability: str | None = None) -> EyeResult
fit_process_norms ¶
fit_process_norms(x: Any, metric: str, covariates: Sequence[str] | str, family: str = 'auto') -> 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
monitor_dif_drift ¶
monitor_dif_drift(x: Any, time: str, group: str, metrics: Sequence[str], item: 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
plot_device_bias_by_magnitude ¶
plot_item_pareto ¶
plot_item_pareto(x: Any, x_objective: str = 'information', y_objective: str = 'process_burden', ax=None)
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 ¶
autoplot_eyeprocess ¶
Autoplot-compatible wrapper around eyeprocesspy plot dispatch.
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.
apply_offline_recalibration ¶
audit_process_reliability ¶
audit_process_reliability(x, metrics, method='icc', person_col='person_id', item_col='item_id', draws=250)
design_process_dstudy ¶
design_process_dstudy(gstudy, persons=None, items=tuple(range(5, 51, 5)), sessions=tuple(range(1, 6)), devices=(1,))
detect_calibration_drift ¶
detect_calibration_drift(x, references=None, window='30 sec', method='targets', x_col=None, y_col=None, time_col=None)
estimate_process_uncertainty ¶
fit_offline_recalibration ¶
fit_offline_recalibration(x, method='translation', robust=True, x_col=None, y_col=None, reference_x_col=None, reference_y_col=None)
fit_process_gstudy ¶
plot_eye_process_reliability_audit ¶
plot_eye_process_uncertainty ¶
plot_eye_process_uncertainty_propagation ¶
plot_eye_uncertainty_budget_comparison ¶
process_uncertainty_spec ¶
process_uncertainty_spec(calibration=True, aoi_assignment=True, preprocessing=True, sampling=True, model=True, source_sd=None, draws=1000, seed=20260807)
propagate_process_uncertainty ¶
propagate_process_uncertainty(x, estimand=lambda data: np.nanmean(data), method='bootstrap', draws=None, seed=None)
audit_pupil_preprocessing ¶
audit_pupil_preprocessing(data: Any, *, pupil: str = 'pupil', time: str = 'timestamp_seconds', valid: str | None = None, blink: str | None = None, interpolated: str | None = None, by: str | None = None) -> EyeResult
Produce a transparent pupil preprocessing/QC ledger.
compute_spatial_error_field ¶
compute_spatial_error_field(validation: Any, *, gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', target_x: str = 'target_x', target_y: str = 'target_y', target_id: str | None = None, minimum_samples_per_target: int = 3) -> EyeResult
Estimate target-local systematic gaze error without inventing missing targets.
correct_gaze_with_spatial_error ¶
correct_gaze_with_spatial_error(data: Any, field: Any, *, x: str = 'gaze_x', y: str = 'gaze_y', method: str = 'idw', power: float = 2.0, strength: float = 1.0, suffix: str = '_corrected') -> pd.DataFrame
Apply an explicit spatial-bias correction while preserving raw coordinates.
correct_pupil_size_artifact ¶
correct_pupil_size_artifact(data: Any, model: Any, *, pupil: str | None = None, gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', by: str | None = None, suffix: str = '_pupil_corrected') -> pd.DataFrame
Apply an explicit pupil-size artefact model without overwriting raw gaze.
fit_pupil_size_artifact ¶
fit_pupil_size_artifact(validation: Any, *, pupil: str = 'pupil', gaze_x: str = 'gaze_x', gaze_y: str = 'gaze_y', target_x: str = 'target_x', target_y: str = 'target_y', by: str | None = None, minimum_samples: int = 8) -> EyeResult
Estimate pupil-size-related apparent gaze displacement from fixed-target data.
plot_pupil_size_artifact ¶
Plot pupil-artifact slope vectors by fitted group.
plot_spatial_error_field ¶
Plot target-local bias vectors.
add_multilevel_mediation_component ¶
add_multilevel_mediation_component(prepared: MultilevelMediationData, *, value_col: str, semantic: str, within_col: str, between_col: str, grand_mean_center_between: bool | None = None) -> MultilevelMediationData
Add another decomposed trial-level variable to a prepared mediation object.
This helper supports serial mediators and moderators while keeping all within/between decomposition inside eyeprocesspy rather than statistical backend packages.
audit_mediation_missingness ¶
audit_mediation_missingness(data: DataFrame, *, x_col: str, mediator_col: str, outcome_col: str, participant_col: str = 'participant_id', trial_col: str = 'trial_id', quality_col: str | None = None, minimum_quality: float | None = None, mediator_observed_col: str | None = None, response_observed_col: str | None = None) -> pd.DataFrame
Audit missingness while distinguishing missing gaze from true zero gaze.
center_within_participant ¶
center_within_participant(data: DataFrame, value_col: str, participant_col: str = 'participant_id', *, output_col: str | None = None) -> pd.DataFrame
Participant-mean center a numeric trial-level variable.
Missing observations remain missing and are excluded only from the group mean used for centering; rows themselves are preserved.
check_mediation_trial_counts ¶
check_mediation_trial_counts(data: DataFrame, participant_col: str = 'participant_id', trial_col: str = 'trial_id', *, minimum_trials: int = 2) -> pd.DataFrame
Summarise repeated-measures support without excluding participants.
decompose_within_between ¶
decompose_within_between(data: DataFrame, columns: str | Iterable[str], participant_col: str = 'participant_id', *, grand_mean_center_between: bool = False) -> pd.DataFrame
Add within-person and between-person components for numeric variables.
identify_mediation_levels ¶
identify_mediation_levels(data: DataFrame, columns: str | Iterable[str], participant_col: str = 'participant_id', *, tolerance: float = 1e-12) -> pd.DataFrame
Classify variables as within, between, both, or unidentified.
mediation_provenance_json ¶
Serialize preparation provenance for reports or cross-language fixtures.
prepare_multilevel_mediation_data ¶
prepare_multilevel_mediation_data(data: DataFrame, *, x_col: str, mediator_col: str, outcome_col: str, participant_col: str = 'participant_id', trial_col: str = 'trial_id', quality_col: str | None = None, minimum_quality: float | None = None, mediator_observed_col: str | None = None, response_observed_col: str | None = None, quality_action: str = 'flag', grand_mean_center_between: bool = False, require_within_x: bool = True, source_id: str | None = None, preprocessing_spec: Mapping[str, Any] | None = None, event_detector: Mapping[str, Any] | str | None = None, aoi_specification: Mapping[str, Any] | str | None = None, warn: bool = True) -> MultilevelMediationData
Prepare trial-level multilevel mediation data.
No rows are dropped. quality_action='flag' is the default and preserves
mediator values on poor-quality trials while marking those trials as not
analysis eligible. quality_action='mask_mediator' is an explicit request
to set poor-quality mediator values to missing before decomposition.
summarise_within_between_variance ¶
summarise_within_between_variance(data: DataFrame, columns: str | Iterable[str], participant_col: str = 'participant_id') -> pd.DataFrame
Summarise observed within- and between-participant variance.
validate_multilevel_mediation_data ¶
validate_multilevel_mediation_data(data: DataFrame, *, x_col: str, mediator_col: str, outcome_col: str, participant_col: str = 'participant_id', trial_col: str = 'trial_id', require_within_x: bool = True) -> dict[str, Any]
Validate identifiers, decomposition inputs, and repeated-measures support.
ablate_multimodal_channels ¶
ablate_multimodal_channels(x: Any, include: Sequence[str] = ('response', 'rt', 'gaze', 'pupil'), include_response: bool = True) -> EyeResult
audit_multimodal_identifiability ¶
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
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
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
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
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
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
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
multimodal_m2_negative_controls ¶
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_m2_spec ¶
multimodal_m2_spec(backend: str = 'cmdstanr', prior_profile: str = 'regularized', missingness: str = 'ignorable') -> EyeResult
multimodal_m3_ablation ¶
multimodal_m3_ablation(x: Any, models: Any = None, nuisance: Any = None, **kwargs: Any) -> EyeResult
multimodal_m3_functional_bridge ¶
multimodal_m3_functional_bridge(data: Any, score: Any, pupil: str = 'pupil', provenance: Any = None) -> EyeResult
multimodal_m3_negative_controls ¶
multimodal_m3_process_information ¶
multimodal_m3_process_information(x: Any, pupil_cost: float = 1, decisive_z: float = 2) -> 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_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
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_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_process_information ¶
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
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_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
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
process_information ¶
process_information(baseline: Any, augmented: Any, metric: str = 'variance_reduction') -> pd.DataFrame
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
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
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
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
validate_multimodal_m2 ¶
validate_multimodal_m2(x: Any, include_ppc: bool = True, rhat_max: float = 1.01, ess_min: int = 200) -> 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
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
align_head_pose_to_gaze ¶
align_head_pose_to_gaze(gaze: Any, pose: Any, *, gaze_time: str = 'timestamp', pose_time: str = 'timestamp', quaternion: tuple[str, str, str, str] = ('qx', 'qy', 'qz', 'qw'), position: tuple[str, str, str] = ('px', 'py', 'pz')) -> pd.DataFrame
Interpolate pose to gaze timestamps using Slerp for rotation and linear position.
pixels_to_visual_angle ¶
pixels_to_visual_angle(pixels: Any, *, pixels_per_mm: float, viewing_distance_mm: float) -> np.ndarray
Convert signed pixel displacement to visual angle in degrees.
plot_world_gaze_vectors ¶
Plot world-space gaze directions projected on x/z and y/z.
propagate_coordinate_uncertainty ¶
propagate_coordinate_uncertainty(data: Any, *, x: str = 'gaze_x_px', y: str = 'gaze_y_px', viewing_distance_mm: float, viewing_distance_sd_mm: float, draws: int = 500, seed: int = 1, **screen_geometry: Any) -> EyeResult
Propagate declared viewing-distance uncertainty into head-centred gaze vectors.
screen_gaze_to_head_vectors ¶
screen_gaze_to_head_vectors(data: Any, *, x: str = 'gaze_x_px', y: str = 'gaze_y_px', screen_width_px: float, screen_height_px: float, screen_width_mm: float, screen_height_mm: float, viewing_distance_mm: float, origin: str = 'top_left') -> pd.DataFrame
Map 2D screen gaze into unit direction vectors in a head-centred frame.
transform_head_gaze_to_world ¶
transform_head_gaze_to_world(data: Any, *, vector: tuple[str, str, str] = ('head_gaze_x', 'head_gaze_y', 'head_gaze_z'), quaternion: tuple[str, str, str, str] = ('qx', 'qy', 'qz', 'qw'), position: tuple[str, str, str] = ('px', 'py', 'pz')) -> pd.DataFrame
Rotate head-centred gaze into world space and retain ray origins.
transform_screen_gaze_to_world ¶
Convenience pipeline: screen pixels -> head vector -> pose alignment -> world ray.
visual_angle_to_pixels ¶
visual_angle_to_pixels(degrees: Any, *, pixels_per_mm: float, viewing_distance_mm: float) -> np.ndarray
Convert signed visual angle to pixel displacement.
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 ¶
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 ¶
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
process_feature_stability ¶
process_feature_stability(data: Any, feature: str = 'feature', split: str = 'split', importance: str = 'importance', top_n: int = 20) -> pd.DataFrame
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]
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.
detect_corrupt_partitions ¶
Return partitions that are missing, truncated, or fingerprint-modified.
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.
open_partitioned_eye_storage ¶
Open a partitioned storage handle without collecting its tables.
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.
query_eye_storage ¶
Query one partitioned table, returning a lazy Dataset when requested.
storage_transaction_manifest ¶
Return a copy of the storage transaction manifest.
upgrade_eye_dataset ¶
Upgrade a legacy EyeDataset to the stable 2.0.0 object contract.
validate_eye_storage_metadata ¶
Validate partition existence, byte sizes, and MD5 fingerprints.
write_partitioned_eye_storage ¶
Write named tables as fingerprinted, atomically committed partitions.
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.
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_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_eye_functional_pupil_irt ¶
plot_eye_functional_pupil_sensitivity ¶
plot_eye_presentation_fairness_comparison ¶
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_process_windows ¶
plot_eye_pupil_confound_model ¶
plot_eye_pupil_deconvolution ¶
plot_eye_pupil_frequency_features ¶
plot_eye_pupil_frequency_stability ¶
plot_pupil_activity_sensitivity ¶
plot_pupil_activity_windows ¶
plot_pupil_spectrum ¶
plot_pupil_spectrum(signal: Any, sampling_rate_hz: float, max_hz: float | None = None, **kwargs: Any)
plot_eye_analysis_pipeline ¶
plot_eye_decision_manifest ¶
plot_eye_decision_stability ¶
plot_eye_pipeline_audit ¶
plot_eye_process_sensitivity ¶
plot_eye_process_sensitivity(x: Any, y: Any = None, type: str = 'specification_curve', effect: str = 'effect', lower: str | None = None, upper: str | None = None, ax: Any = None, **kwargs: Any)
plot_eye_process_validation_design ¶
plot_eye_process_validation_result ¶
plot_eye_process_validation_result(x: Any, y: Any = None, type: str = 'recovery', parameter: Any = None, ax: Any = None, **kwargs: Any)
plot_eye_validation_reference_comparison ¶
plot_eye_validation_reference_comparison(x: Any, y: Any = None, metric: str = 'rmse_delta', ax: Any = None, **kwargs: Any)
plot_eye_irt_information_profile ¶
plot_eye_irt_process_alignment ¶
plot_eye_irt_process_alignment(x: Any, *, channel: str | None = None, parameter: str = 'b', ax=None)
plot_eye_irt_recovery_result ¶
plot_eye_bayesian_process_dashboard ¶
plot_eye_biometric_imputation_sensitivity ¶
plot_eye_gaze_anchored_3pl_audit ¶
plot_eye_gaze_anchored_3pl_audit(x: Any, type: str = 'lower_asymptote', feature: str | None = None, ax=None)
plot_eye_item_parameter_seed ¶
plot_eye_multiblock_process_map ¶
plot_eye_nonparametric_rasch_audit ¶
plot_eye_process_external_validity ¶
plot_eye_process_profile_mixture ¶
plot_eye_visual_context_irt ¶
plot_eye_multimodal_m2_simulation ¶
plot_eye_multimodal_m3_identifiability ¶
plot_eye_multimodal_m3_information ¶
plot_eye_multimodal_m3_negative_controls ¶
plot_eye_multimodal_m3_simulation ¶
plot_eye_multimodal_m4_fit ¶
plot_eye_multimodal_m4_identifiability ¶
plot_eye_multimodal_m4_information ¶
plot_eye_multimodal_m4_negative_controls ¶
plot_eye_multimodal_m4_recovery ¶
plot_eye_multimodal_m4_sensitivity ¶
plot_eye_multimodal_m4_simulation ¶
plot_eye_multimodal_simulation ¶
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)
plot_eye_calibration_drift_profile ¶
plot_eye_calibration_error_model ¶
plot_eye_data_quality_profile ¶
plot_eye_probabilistic_aoi_assignment ¶
plot_eye_process_reliability_profile ¶
plot_eye_process_reliability_profile(x: Any, y: Any = None, type: str = 'bland_altman', ax: Any = None)
plot_eye_sampling_irregularity_audit ¶
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.
derive_all_features ¶
Derive gaze, pupil, RT, and biometric features using a feature spec.
derive_biometric_features ¶
Derive trial-channel biometric summary features.
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.
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_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_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_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.
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.
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.
filter_pupil ¶
Filter pupil diameter within recording and eye.
flag_gaze_outliers ¶
Flag gaze outliers using MAD, velocity, or coordinate-space bounds.
gaze_entropy ¶
Compute Shannon entropy of AOI occupancy.
interpolate_pupil ¶
Interpolate bounded pupil gaps within recording and eye.
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.
pupil_deconvolve ¶
Apply the frozen exploratory discrete pupil deconvolution.
rolling_apply ¶
Centered rolling apply matching R rolling_apply().
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.
summarize_fixations ¶
summarize_fixations(x, by=('recording_id', 'trial_id', 'aoi_id'), source=('all', 'vendor', 'eyeprocess'))
Summarize fixation episodes by requested grouping fields.
transition_entropy ¶
Compute row-wise entropy of the normalized AOI transition matrix.
transition_matrix ¶
transition_matrix(x, normalize=('none', 'row', 'all'), source=('visits', 'fixations', 'samples'), include_self=False)
Return AOI transition matrix from scanpath sequences.
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.
plot_aoi_boundary_risk ¶
Plot mean assignment ambiguity or AOI-pair overlap area.
plot_aoi_metric_uncertainty ¶
Plot Monte Carlo distributions for propagated AOI process metrics.
plot_aoi_probability_map ¶
Plot gaze samples with AOI rectangles and membership certainty.
plot_fuzzy_transition_matrix ¶
Plot expected adjacent-state transitions under AOI uncertainty.
plot_probabilistic_scanpath ¶
Plot the gaze trajectory underlying a probabilistic AOI fit.
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.
summarise_aoi_membership ¶
Summarise mean AOI membership probabilities.
compare_scanpath_distributions ¶
detect_process_changepoints ¶
detect_process_changepoints(x, channels=('gaze_velocity', 'aoi', 'pupil', 'eda'), time_col=None, window=10, threshold_quantile=0.9, min_segment=5)
fit_fixation_point_process ¶
fit_fixation_point_process(x, spatial_covariates=None, temporal_covariates=None, interaction='none', x_col='x', y_col='y', time_col='time', grid_size=20)
fit_marked_gaze_process ¶
fit_marked_gaze_process(x, marks=('duration', 'pupil', 'saccade_amplitude'), x_col='x', y_col='y', time_col='time')
gaze_recurrence ¶
plot_eye_gaze_point_process_diagnostics ¶
plot_eye_scanpath_representative ¶
plot_eye_windowed_recurrence ¶
representative_scanpath ¶
representative_scanpath(x, method='medoid', id_col='person_id', aoi_col='aoi', x_col='x', y_col='y', distance='multimatch')
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
apply_preflight_decision ¶
apply_preflight_decision(data: Any, audit: Any, keep_decisions: Sequence[str] = ('pass_preflight', 'use_with_caution')) -> pd.DataFrame
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
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
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_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
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
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
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
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
compare_presentation_fairness ¶
compare_presentation_fairness(data: Any, variant: str, outcome: str, person: str | None = None) -> EyeResult
compare_pupil_kernels ¶
compare_pupil_kernels(data: Any, tmax_values: Sequence[float] = (512, 930), **kwargs: Any) -> pd.DataFrame
compare_signal_filters ¶
compare_signal_filters(signal: Any, widths: Sequence[int] = (5, 9, 15), methods: Sequence[str] = ('runmed', 'robfilter')) -> pd.DataFrame
drift_by_device ¶
drift_by_stimulus_version ¶
drift_by_stimulus_version(data: Any, stimulus_version: str = 'stimulus_version', **kwargs: Any) -> pd.DataFrame
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
filter_eye_signal ¶
filter_eye_signal(signal: Any, width: int = 9, method: str = 'auto', online: bool = True) -> EyeResult
fit_aoi_growth_curve ¶
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
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
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
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
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
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_band_power ¶
pupil_band_power(y: Any, sampling_rate_hz: float, lower_hz: float, upper_hz: float, detrend: bool = True) -> float
pupil_event_regressor ¶
pupil_event_regressor(time_ms: Any, event_time_ms: float, tmax_ms: float = 930, shape: float = 10.1) -> np.ndarray
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
pupil_response_kernel ¶
pupil_response_kernel(time_since_event_ms: Any, tmax_ms: float = 930, shape: float = 10.1, normalize: bool = True) -> np.ndarray
simulate_presentation_variants ¶
simulate_presentation_variants(audit: Any, line_spacing_multiplier: float = 1.25, key_term_highlighting: bool = True) -> pd.DataFrame
summarize_process_windows ¶
audit_distractor_attention ¶
audit_distractor_attention(data: Any, response_option: str = 'response_option', option_gaze: Sequence[str] = (), chosen_suffix: str | None = None) -> pd.DataFrame
audit_process_local_dependence ¶
audit_process_local_dependence(response_residuals: Any, process_residuals: Any = None, threshold: float = 0.2) -> EyeResult
audit_process_measurement_invariance ¶
audit_process_measurement_invariance(object: Any, channel: str = 'process', relative_sd_threshold: float = 0.25) -> EyeResult
classify_item_missingness ¶
classify_item_missingness(data: Any, response: str = 'response', reached: str = 'reached', inspected: str | None = None, started: str | None = None) -> pd.Categorical
compare_irt_models ¶
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
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
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
estimate_visual_exposure_probability ¶
estimate_visual_exposure_probability(data: Any, exposed: str = 'reached', predictors: Sequence[str] = (), family: Any = None) -> 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
fit_changepoint_multimodal_irt ¶
fit_changepoint_multimodal_irt(data: Any, *args: Any, gaze: str = 'fixation_count', refit: bool = True, **kwargs: Any) -> EyeResult
fit_changepoint_rt_irt ¶
fit_irt_model ¶
fit_irt_model(spec: Any, data: Any, *args: Any, allow_experimental: bool = False, **kwargs: Any) -> Any
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_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_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
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
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_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
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_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
fit_speed_accuracy_engagement_irt ¶
fit_speed_accuracy_engagement_irt(data: Any, *args: Any, engine: str = 'reference', **kwargs: Any) -> EyeResult
generalizability_process_study ¶
generalizability_process_study(data: Any, outcome: str, facets: Sequence[str], REML: bool = True) -> 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_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_count_channel ¶
irt_count_channel(family: str = 'negative_binomial', value: str = 'fixation_count', latent: str = 'engagement', 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_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
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_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_sequence_channel ¶
irt_sequence_channel(sequence: str = 'sequence', family: str = 'ngram', latent: str = 'strategy', 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
plot_eye_process_dependent_discrimination ¶
plot_eye_process_local_dependence_audit ¶
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_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
process_dependent_discrimination_audit ¶
process_dependent_discrimination_audit(data: Any, response: str, theta: str, process: str, person: str, item: str, nonlinear: bool = True) -> EyeResult
promote_irt_model ¶
promote_irt_model(spec: Any, evidence: Any, target: str = 'experimental', update_registry: bool = False) -> 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
simulate_irt_model ¶
audit_sampling_irregularity ¶
audit_sampling_irregularity(data: Any, time: str = 'timestamp_ms', unit: str = 'ms', by: Any = None, cv_threshold: float = 0.05) -> EyeResult
bootstrap_process_reliability ¶
bootstrap_process_reliability(data: Any, person: str, session: str, measure: str, replications: int = 500, seed: int = 1) -> 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
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
calibration_sensitivity_grid ¶
calibration_sensitivity_grid(offset_x: Any = (-0.02, 0, 0.02), offset_y: Any = (-0.02, 0, 0.02)) -> pd.DataFrame
compare_hard_probabilistic_aoi ¶
compare_hard_probabilistic_aoi(data: Any, aois: Any, probabilistic: Any, x: str = 'gaze_x', y: str = 'gaze_y') -> pd.DataFrame
effective_sampling_frequency ¶
effective_sampling_frequency(data: Any, time: str = 'timestamp_ms', unit: str = 'ms', by: Any = None) -> 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
find_process_measures ¶
find_process_measures(registry: Any = None, channel: Any = None, level: Any = None, status: Any = None, query: str | None = None) -> pd.DataFrame
fixation_boundary_uncertainty ¶
fixation_boundary_uncertainty(data: Any, aois: Any, x: str = 'gaze_x', y: str = 'gaze_y') -> pd.DataFrame
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
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
gaze_uncertainty_ellipse ¶
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
process_bland_altman ¶
process_bland_altman(data: Any, person: str, session: str, measure: str, sessions: Any = None) -> EyeResult
process_measure_coverage ¶
process_measure_lineage ¶
process_measure_lineage(measure: Any, inputs: Any, transformations: Any = (), output_level: Any = None) -> EyeResult
process_measure_registry ¶
process_reliability_profile ¶
process_temporal_stability ¶
process_temporal_stability(data: Any, person: str, session: str, measure: str, method: str = 'pearson') -> pd.DataFrame
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
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
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
fit_joint_signal_missingness ¶
fit_phase_amplitude_irt ¶
fit_phase_amplitude_irt(responses, phase_scores, amplitude_scores=None, person_id=None, family='gaussian', **kwargs)
fit_process_observation_model ¶
plot_eye_process_observation_model ¶
process_pattern_mixture ¶
register_pupil_curves ¶
register_pupil_curves(x, time, pupil, anchor='stimulus', method='elastic', id_col='person_id', grid_size=101)
analysis_environment_snapshot ¶
Snapshot the active Python analysis environment.
compare_reproducibility_fingerprints ¶
Compare two reproducibility fingerprints.
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.
eye_prov_graph ¶
Construct a lightweight provenance graph.
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.
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.
file_hash_manifest ¶
Build a file hash manifest.
provenance_edge_table ¶
Build a provenance edge table.
provenance_lineage_table ¶
Build a provenance lineage node table.
read_reproducibility_fingerprint ¶
Read a JSON fingerprint; RDS/dput inputs remain R-specific.
verify_reproducibility_fingerprint ¶
Verify an internally stored fingerprint hash.
write_reproducibility_fingerprint ¶
Write a fingerprint; JSON is native, RDS/dput remain R-specific.
algorithm_facet_effects ¶
audit_latent_distribution ¶
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
event_roundtrip_audit ¶
event_roundtrip_audit(source_events: Any, roundtrip_events: Any, hed_column: str | None = None, **kwargs: Any) -> EyeResult
explain_latent_interaction ¶
explain_latent_interaction(object: Any, person: Any = None, item: Any = None, top: int = 10) -> pd.DataFrame
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_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
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
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)
plot_person_item_space ¶
plot_person_item_space(object: Any, dimensions: Sequence[int] = (1, 2), labels: bool = False, ax: Any = None)
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
validate_vendor_semantics ¶
validate_vendor_semantics(data: Any, contract: Any, metadata: Mapping[str, Any] | None = None) -> EyeResult
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
compare_scanpath_metrics ¶
compare_scanpath_metrics(reference: Any, candidate: Any, *, reference_trajectory: Any | None = None, candidate_trajectory: Any | None = None, trajectory_columns: tuple[str, ...] = ('x', 'y')) -> pd.DataFrame
Return complementary sequence, transition, n-gram, and optional trajectory metrics.
dynamic_time_warping_distance ¶
dynamic_time_warping_distance(reference: Any, candidate: Any, *, columns: tuple[str, ...] = ('x', 'y'), normalize: bool = True) -> float
Dynamic-time-warping distance for geometric/temporal scanpath representations.
levenshtein_scanpath ¶
Compute edit distance between AOI sequences.
ngram_jaccard_similarity ¶
Jaccard similarity for ordered AOI n-grams.
plot_scanpath_sensitivity ¶
Plot candidate metric ranks to expose metric-dependent conclusions.
scanpath_metric_sensitivity ¶
Show how candidate ordering changes across defensible scanpath metrics.
transition_js_distance ¶
Jensen-Shannon distance between AOI transition distributions.
canonical_table_names ¶
Return canonical table names in frozen R order.
empty_eye_table ¶
Create an empty canonical table with the R column order.
eye_schema ¶
Return the canonical eyeprocess schema (R eye_schema).
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.
schema_table ¶
Return canonical fields for one schema table.
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.
compatibility_evidence_matrix ¶
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
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
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
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
plot_eye_compatibility_evidence_matrix ¶
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
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
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
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
validate_bids_eye_semantics ¶
validate_bids_eye_semantics(data: Any, metadata: Mapping[str, Any], events_metadata: Mapping[str, Any] | None = None) -> EyeResult
validate_hed_event_semantics ¶
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
audit_item_reduction_sensitivity ¶
audit_item_reduction_sensitivity(erm_model: Any, criterion: Any = None, alpha: float = 0.05, maxstep: int = 5) -> 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
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
compare_bayesian_process_models ¶
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
fit_process_rasch_tree ¶
fit_process_rasch_tree(response_matrix: Any, covariates: Any, formula: Any = None, maxit: int = 60) -> 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
freeze_software_paper_evidence ¶
Freeze evidence as Python-native JSON and return its MD5 manifest.
paper_reproducibility_manifest ¶
Create the compact frozen paper reproducibility manifest.
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_coverage ¶
Compute descriptive evidence coverage.
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_gap_analysis ¶
Identify gaps in a software-paper evidence bundle.
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_validation_table ¶
Summarise validation evidence for a software paper.
write_software_paper_evidence ¶
Write the frozen human-readable evidence audit report.
compare_gaze_quality_conditions ¶
compare_gaze_quality_conditions(data: Any, condition: str = 'condition', **kwargs: Any) -> pd.DataFrame
compare_gaze_quality_sessions ¶
compare_gaze_quality_sessions(data: Any, session: str = 'session_id', **kwargs: Any) -> pd.DataFrame
compute_bcea ¶
compute_bcea(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', by: str | Sequence[str] | None = None, probability: float = 0.68, unit: str = 'degrees', output_unit: str | None = None, geometry: Mapping[str, Any] | None = None) -> pd.DataFrame
Compute bivariate contour ellipse area (BCEA) at an explicit probability.
compute_gaze_accuracy ¶
compute_gaze_accuracy(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', target_x: str = 'target_x', target_y: str = 'target_y', by: str | Sequence[str] | None = None, unit: str = 'degrees', output_unit: str | None = None, geometry: Mapping[str, Any] | None = None) -> pd.DataFrame
Compute target-referenced gaze accuracy for each requested analysis unit.
compute_gaze_data_loss ¶
compute_gaze_data_loss(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', time: str | None = 'timestamp_ms', valid: str | None = None, missing_reason: str | None = None, by: str | Sequence[str] | None = None, time_unit: str = 'ms') -> pd.DataFrame
compute_gaze_precision ¶
Return the distinct RMS-S2S, SD, and BCEA precision representations.
compute_gaze_sd_precision ¶
compute_gaze_sd_precision(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', by: str | Sequence[str] | None = None, unit: str = 'degrees', output_unit: str | None = None, geometry: Mapping[str, Any] | None = None) -> pd.DataFrame
Compute spatial standard-deviation precision around a stable target.
compute_rms_s2s ¶
compute_rms_s2s(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', time: str | None = None, by: str | Sequence[str] | None = None, unit: str = 'degrees', output_unit: str | None = None, geometry: Mapping[str, Any] | None = None, dimension: str = '2d', time_unit: str = 'ms', max_gap_ms: float | None = None) -> pd.DataFrame
Compute RMS sample-to-sample displacement without bridging missing samples.
compute_valid_sample_fraction ¶
compute_valid_sample_fraction(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', valid: str | None = None, by: str | Sequence[str] | None = None) -> pd.DataFrame
create_gaze_quality_report ¶
create_gaze_quality_report(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', time: str = 'timestamp_ms', target_x: str | None = 'target_x', target_y: str | None = 'target_y', valid: str | None = None, missing_reason: str | None = None, by: str | Sequence[str] | None = None, unit: str = 'degrees', output_unit: str | None = None, geometry: Mapping[str, Any] | None = None, time_unit: str = 'ms', nominal_sampling_hz: float | None = None, bcea_probability: float = 0.68, max_gap_ms: float | None = None, thresholds: Mapping[str, Any] | None = None, preprocessing_spec: Any = None, event_detector: Any = None, aoi_specification: Any = None, quality_rules: Any = None, model_specification: Any = None, software_version: str | None = None, unit_column: str | None = None) -> pd.DataFrame
Create a manuscript-ready report; thresholds only flag rows for review.
estimate_effective_sampling_rate ¶
estimate_effective_sampling_rate(data: Any, time: str = 'timestamp_ms', by: str | Sequence[str] | None = None, time_unit: str = 'ms', nominal_sampling_hz: float | None = None, dropped_interval_factor: float = 1.5, x: str | None = None, y: str | None = None, valid: str | None = None) -> pd.DataFrame
estimate_sampling_interval ¶
estimate_sampling_interval(data: Any, time: str = 'timestamp_ms', by: str | Sequence[str] | None = None, time_unit: str = 'ms') -> pd.DataFrame
estimate_sampling_jitter ¶
estimate_sampling_jitter(data: Any, time: str = 'timestamp_ms', by: str | Sequence[str] | None = None, time_unit: str = 'ms') -> pd.DataFrame
plot_gaze_precision ¶
plot_sampling_intervals ¶
plot_sampling_intervals(data: Any, time: str = 'timestamp_ms', time_unit: str = 'ms', ax: Any = None)
simulate_gaze_quality_calibration ¶
simulate_gaze_quality_calibration(seed: int = 20260918, samples_per_target: int = 18, nominal_sampling_hz: float = 60.0) -> pd.DataFrame
Generate a reproducible 9-point validation set with six quality profiles.
validate_gaze_quality_inputs ¶
validate_gaze_quality_inputs(data: Any, x: str = 'gaze_x', y: str = 'gaze_y', time: str | None = None, target_x: str | None = None, target_y: str | None = None, by: str | Sequence[str] | None = None, unit: str = 'degrees', time_unit: str = 'ms', unit_column: str | None = None) -> dict[str, Any]
Validate structural inputs without dropping or repairing observations.
check_gaze_proportional_hazards ¶
Evaluate Cox PH using Schoenfeld-residual time trends.
This is a scientific-contract analogue to survival::cox.zph; exact
numerical parity with R is not claimed.
compare_gaze_survival_models ¶
Summarize fitted models without implying a cross-family winner.
Cox information criteria use partial likelihood; AFT information criteria use full likelihood. The returned comparability flag is therefore false when these bases are mixed or analysis-row counts differ.
estimate_gaze_latency_quantiles ¶
estimate_gaze_latency_quantiles(obj: DataFrame | GazeSurvivalFit, *, probs: Sequence[float] = (0.25, 0.5, 0.75), group: str | None = None, newdata: DataFrame | None = None) -> pd.DataFrame
Estimate event-time quantiles from KM or fitted models.
estimate_gaze_survival ¶
estimate_gaze_survival(data: DataFrame, *, group: str | None = None, conf_level: float = 0.95) -> pd.DataFrame
Estimate Kaplan-Meier survival curves for gaze latency.
fit_gaze_aft_model ¶
fit_gaze_aft_model(data: DataFrame, formula: str, *, distribution: str | None = None, maxiter: int = 2000) -> GazeSurvivalFit
Fit an explicitly selected Weibull or log-normal AFT model.
Estimation is delegated to the specialist lifelines survival backend; eyeprocesspy owns validation, provenance, and semantic output rather than reimplementing the AFT likelihood.
fit_gaze_cox_model ¶
fit_gaze_cox_model(data: DataFrame, formula: str, *, ties: str = 'breslow', cluster: str | None = None) -> GazeSurvivalFit
Fit a Cox PH model, optionally with cluster-robust uncertainty.
fit_gaze_mixed_cox_model ¶
fit_gaze_mixed_cox_model(data: DataFrame, formula: str, *, participant_col: str = 'participant_id', structure: str | None = None, ties: str = 'breslow') -> GazeSurvivalFit
Fit a repeated-participant Cox model.
Python currently provides participant-clustered sandwich uncertainty. It
does not mislabel this estimator as latent frailty. structure='frailty'
fails explicitly; R eyeprocess provides the frailty implementation.
plot_gaze_cox_diagnostics ¶
Plot Schoenfeld residuals against log event time for the first Cox term.
plot_gaze_cumulative_incidence ¶
Plot 1-KM for one target-event definition.
This is not a competing-risks cumulative-incidence estimator.
plot_gaze_hazard ¶
Plot discrete Nelson-Aalen hazard increments for descriptive use.
plot_gaze_survival_curve ¶
Plot Kaplan-Meier gaze-survival curves.
predict_gaze_survival ¶
predict_gaze_survival(fit: GazeSurvivalFit, newdata: DataFrame, times: Sequence[float]) -> pd.DataFrame
Predict survival probabilities at requested times.
prepare_gaze_survival_data ¶
prepare_gaze_survival_data(trials: DataFrame, events: DataFrame | None = None, *, target_aoi: str | None = None, event_type: str = 'first_fixation', participant_col: str = 'participant_id', trial_col: str = 'trial_id', recording_col: str = 'recording_id', stimulus_col: str = 'stimulus_id', condition_col: str = 'condition', trial_start_col: str | None = None, trial_end_col: str | None = None, time_origin_col: str | None = None, observation_end_reason_col: str | None = None, event_time_col: str = 'start_time', event_aoi_col: str = 'aoi_id', event_trial_col: str = 'trial_id', event_participant_col: str = 'participant_id', event_recording_col: str = 'recording_id', episode_type_col: str = 'episode_type', event_observed_col: str = 'event_observed', supplied_event_time_col: str = 'event_time', supplied_censor_time_col: str = 'censor_time', n_valid_samples_col: str = 'n_valid_samples', valid_fraction_col: str = 'valid_data_fraction', valid_observation_col: str | None = None, min_valid_fraction: float | None = None, time_origin: str = 'trial_start', time_unit: str = 'seconds', source_data: str | None = None, preprocessing_specification: str | None = None, event_detector: str | None = None, aoi_specification: str | None = None, quality_rules: Mapping[str, Any] | None = None) -> pd.DataFrame
Construct the canonical one-row-per-trial gaze-survival table.
Absence of a target event becomes right censoring only when events is
supplied and a complete usable trial observation window is known. Without
event evidence, callers must provide event_observed explicitly.
report_gaze_survival_model ¶
Create a concise manuscript-ready reporting bundle.
simulate_gaze_survival_example ¶
simulate_gaze_survival_example(kind: str = 'disclosure', *, seed: int = 20260918, n_participants: int = 36, trials_per_participant: int = 3) -> pd.DataFrame
Generate a deterministic canonical censored gaze-latency example.
simulate_gaze_survival_inputs ¶
simulate_gaze_survival_inputs(kind: str = 'disclosure', *, seed: int = 20260918, n_participants: int = 36, trials_per_participant: int = 3) -> dict[str, pd.DataFrame]
Generate deterministic synthetic trial windows and canonical event rows.
summarise_gaze_censoring ¶
Summarize observed, censored, and review-required trials.
tidy_gaze_survival_model ¶
Return exponentiated Cox hazard ratios or AFT time ratios.
validate_gaze_survival_data ¶
Validate canonical gaze-survival rows without modifying them.
apply_clock_transform ¶
normalize_timebase ¶
normalize_timebase(x, component=('gaze_samples', 'eye_samples', 'events', 'biometrics'), native_unit=None, origin='recording_start', overwrite=True)
eyeprocess_irt_engine_evidence_table ¶
Build the frozen external-engine capability table.
eyeprocess_irt_precision_evidence_table ¶
Build the frozen IRT information/precision evidence table.
eyeprocess_negative_control_evidence_table ¶
Build the frozen paper-ready negative-control table.
eyeprocess_recovery_evidence_table ¶
Build the frozen paper-ready parameter-recovery table.
eyeprocess_reliability_evidence_table ¶
Build the frozen paper-ready reliability 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_validation_atlas_gaps ¶
Summarize missing components and unresolved claims.
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_evidence_index ¶
Create the frozen index over validation evidence artifacts.
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.
benchmark_eyeprocess ¶
Benchmark a zero-argument operation using elapsed time and result size.
create_public_benchmark ¶
Create the frozen de-identified canonical public benchmark bundle.
preprocessing_multiverse ¶
Run the frozen-R preprocessing/AOI multiverse contract.
reporting_guideline_audit ¶
Audit the twelve frozen eye-tracking reporting-guideline sections.
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.
write_reporting_guideline_report ¶
Write the frozen reporting-guideline Markdown audit.
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.
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.
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.
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.
write_advanced_model_evidence_report ¶
Write the frozen advanced-model scientific-evidence Markdown report.
evaluate_validation_acceptance ¶
Evaluate one value against a frozen acceptance rule.
expand_eyeprocess_validation_plan ¶
Expand a validation plan using R expand.grid row ordering.
eyeprocess_validation_evidence_grade ¶
eyeprocess_validation_evidence_grade(components, required=('design', 'execution', 'summary', 'provenance', 'hash'))
Grade completeness of declared validation-evidence components.
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.
eyeprocess_validation_seed ¶
Derive the frozen deterministic bounded validation seed.
read_validation_scenario_manifest ¶
Read a Python-native validation scenario manifest.
summarise_validation_acceptance ¶
Summarise a frozen acceptance matrix.
validate_eyeprocess_validation_plan ¶
Validate the structural contract of a validation-evidence plan.
validation_acceptance_matrix ¶
Evaluate a validation summary table against named rules.
validation_acceptance_rule ¶
Define one frozen validation acceptance rule.
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.
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.
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.
pupil_baseline_sensitivity ¶
pupil_baseline_sensitivity(data, time='time_ms', pupil='pupil', windows=None, by=None, correction='subtractive')
Evaluate frozen pupil baseline-window sensitivity.
sbc_ecdf_deviation ¶
Return the frozen maximum ECDF deviation for SBC ranks.
sbc_rank_diagnostics ¶
Build frozen SBC rank diagnostics.
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.
collect_validation_jobs ¶
Collect JSON validation checkpoints from one or more directories.
prune_validation_checkpoints ¶
Report or delete checkpoints with selected execution statuses.
read_validation_job_manifest ¶
Read a Python validation manifest created by this source port.
resume_validation_jobs ¶
resume_validation_jobs(plan, output_dir, retry=('missing', 'failed', 'nonconverged', 'locked', 'corrupt'), **kwargs)
Resume only missing or explicitly retryable validation jobs.
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.
split_validation_plan ¶
Split a validation plan into independent chunk-specific plans.
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.
validation_seed ¶
Allocate a deterministic validation seed from design contents.
write_validation_job_manifest ¶
Write the validation manifest using transparent Python JSON.
audit_model_promotion ¶
Audit promotion readiness for each declared advanced-model family.
audit_validation_completion ¶
Audit whether the validation programme passes frozen completion gates.
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.
plot_interval_coverage ¶
Plot observed interval coverage against a nominal target.
plot_parameter_recovery ¶
Plot estimated versus true parameter values.
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.
validation_calibration_summary ¶
Summarize binary prediction calibration, Brier/log loss, and ECE.
validation_failure_summary ¶
Summarize execution failures, nonconvergence, locks, and warnings.
validation_recovery_summary ¶
Summarize parameter bias, RMSE, coverage, and standard-error recovery.
validation_runtime_summary ¶
Summarize validation runtime by model family/scenario.
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.
write_model_promotion_report ¶
Write a Markdown report for an advanced-model promotion audit.
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.
audit_vendor_validation ¶
Audit a multi-vendor validation corpus using the frozen R rules.
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.
model_validation_summary ¶
Summarize scenario-by-parameter model-validation metrics.
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.
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.
write_vendor_validation_report ¶
Write the frozen multi-vendor validation Markdown report.
expand_eyeprocess_stress_evidence_plan ¶
Expand a stress plan in frozen R family/value order.
eyeprocess_negative_control_evidence_plan ¶
eyeprocess_negative_control_evidence_plan(controls=_NEGATIVE_CONTROLS, replications=100, seed=20260811)
Declare frozen negative-control evidence targets.
eyeprocess_reliability_evidence_plan ¶
Declare frozen reliability-evidence targets.
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.
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.
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.
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.
read_eyeprocess_validation_evidence ¶
Read a Python-native frozen validation-evidence JSON file.
run_eyeprocess_stress_evidence ¶
Execute the frozen measurement-stress evidence programme.
summarise_eyeprocess_stress_evidence ¶
Summarise executed measurement-stress evidence.
verify_eyeprocess_validation_evidence ¶
Verify the integrity hash of a frozen evidence bundle.
write_eyeprocess_validation_evidence ¶
Write frozen validation evidence as deterministic JSON.
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.
build_compatibility_matrix ¶
build_compatibility_matrix(x, required_vendors=('gazepoint', 'tobii', 'pupillabs', 'eyelink', 'smi'), min_empirical_cases=2)
Build evidence-tiered vendor compatibility claims.
compare_vendor_semantics ¶
Compare semantic mappings and report maximum canonical loss risk.
fingerprint_validation_case ¶
Fingerprint every file in a real-export validation case.
init_vendor_corpus ¶
Create or validate a multi-vendor validation-corpus directory.
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.
read_vendor_registry ¶
Read the version-specific multi-vendor case registry.
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_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.
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.
write_vendor_case_report ¶
Write a Markdown evidence report for one registered vendor case.
write_vendor_registry ¶
Write a vendor registry using the frozen canonical column order.
is_eyelink_export ¶
Return a confidence score for EyeLink EDF/ASC/report exports.
is_pupil_labs_export ¶
Return a confidence score for Pupil Labs Neon/Core exports.
is_smi_export ¶
Return a confidence score for SMI BeGaze text exports.
is_tobii_export ¶
Return a confidence score for Tobii Pro Lab-style delimited 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_edf ¶
Convert an EDF with SR Research EDF2ASC, then import its ASC output.
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_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.
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_pupillabs ¶
Dispatch to Pupil Labs Neon or Core importers.
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_aoi_export ¶
Alias of :func:read_smi for SMI AOI exports.
read_smi_event_export ¶
Alias of :func:read_smi for SMI event exports.
read_smi_raw_export ¶
Alias of :func:read_smi for SMI raw-text 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.