diff --git a/.github/workflows/open_journals_pdf_generation.yml b/.github/workflows/open_journals_pdf_generation.yml new file mode 100644 index 0000000..f74d560 --- /dev/null +++ b/.github/workflows/open_journals_pdf_generation.yml @@ -0,0 +1,36 @@ +name: Draft PDF +on: + # creates a button + workflow_dispatch: + inputs: + logLevel: + description: "Log level" + required: true + default: "warning" + type: choice + options: + - info + - warning + - debug + +jobs: + paper: + runs-on: ubuntu-latest + name: Paper Draft + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Build draft PDF + uses: openjournals/openjournals-draft-action@master + with: + journal: joss + # This should be the path to the paper within your repo. + paper-path: publication/paper.md + - name: Upload + uses: actions/upload-artifact@v4 + with: + name: paper + # This is the output path where Pandoc will write the compiled + # PDF. Note, this should be the same directory as the input + # paper.md + path: paper.pdf \ No newline at end of file diff --git a/publication/code_example.png b/publication/code_example.png new file mode 100644 index 0000000..fb3727d Binary files /dev/null and b/publication/code_example.png differ diff --git a/publication/ezinput_flow.png b/publication/ezinput_flow.png new file mode 100644 index 0000000..fbb794e Binary files /dev/null and b/publication/ezinput_flow.png differ diff --git a/publication/nanopyx_example.png b/publication/nanopyx_example.png new file mode 100644 index 0000000..c9f59a6 Binary files /dev/null and b/publication/nanopyx_example.png differ diff --git a/publication/paper.bib b/publication/paper.bib new file mode 100644 index 0000000..b258148 --- /dev/null +++ b/publication/paper.bib @@ -0,0 +1,144 @@ +@misc{prompt_toolkit, +author = {Jonathan Slenders}, +title = {prompt-toolkit}, +year = {2023}, +publisher = {GitHub}, +journal = {GitHub repository}, +howpublished = {\url{https://github.com/prompt-toolkit/python-prompt-toolkit}} +} + +@article{von2021democratising, + title={Democratising deep learning for microscopy with ZeroCostDL4Mic}, + author={von Chamier, Lucas and Laine, Romain F and Jukkala, Johanna and Spahn, Christoph and Krentzel, Daniel and Nehme, Elias and Lerche, Martina and Hern{\'a}ndez-P{\'e}rez, Sara and Mattila, Pieta K and Karinou, Eleni and others}, + journal={Nature communications}, + volume={12}, + number={1}, + pages={2276}, + year={2021}, + doi={10.1038/s41467-021-22518-0}, + publisher={Nature Publishing Group UK London} +} + +@article{schindelin2012fiji, + title={Fiji: an open-source platform for biological-image analysis}, + author={Schindelin, Johannes and Arganda-Carreras, Ignacio and Frise, Erwin and Kaynig, Verena and Longair, Mark and Pietzsch, Tobias and Preibisch, Stephan and Rueden, Curtis and Saalfeld, Stephan and Schmid, Benjamin and others}, + journal={Nature methods}, + volume={9}, + number={7}, + pages={676--682}, + year={2012}, + doi={10.1038/nmeth.2019}, + publisher={Nature Publishing Group US New York} +} + +@misc{saraiva_2025_rxivmaker, + title={Rxiv-Maker: an automated template engine for streamlined scientific publications}, + author={Bruno M. Saraiva and António D. Brito and Guillaume Jaquemet and Ricardo Henriques}, + year={2025}, + eprint={2508.00836}, + archivePrefix={arXiv}, + primaryClass={cs.DL}, + doi={10.48550/arXiv.2508.00836}, + url={https://arxiv.org/abs/2508.00836}, +} + +@article{sofroniew2025napari, + author = {Sofroniew, Nicholas and Lambert, Talley and Bokota, Grzegorz and Nunez-Iglesias, Juan and Sobolewski, Piotr and Sweet, Andy and Gaifas, Lorenzo and Evans, Kevin and Burt, Alister and Pop, Draga Doncila and Yamauchi, Kira and Weber Mendonça, Melissa and Liu, Lucy and Buckley, Genevieve and Vierdag, Wouter-Michiel and Monko, Thomas and Royer, Loic and Can Solak, Ahmet and Harrington, Kyle I. S. and Zhao, Ruolan}, + title = {napari: a multi-dimensional image viewer for Python (v0.6.2)}, + journal = {Zenodo}, + publisher = {Zenodo}, + year = 2025, + doi = {10.5281/zenodo.15779115}, + url = {https://doi.org/10.5281/zenodo.15779115} +} + +@inproceedings{kluyver2016jupyter, + author = {Kluyver, Thomas and Ragan-Kelley, Benjamin and Pérez, Fernando and Granger, Brian and Bussonnier, Matthias and Frederic, Jonathan and Kelley, Kyle and Hamrick, Jessica and Grout, Jason and Corlay, Sylvain and Ivanov, Paul and Avila, Damián and Abdalla, Safia and Willing, Carol}, + title = {Jupyter Notebooks – a publishing format for reproducible computational workflows}, + booktitle = {Positioning and Power in Academic Publishing: Players}, + pages = {87--90}, + year = 2016, + publisher = {IOS Press}, + doi = {10.3233/978-1-61499-649-1-87}, + url = {https://doi.org/10.3233/978-1-61499-649-1-87} +} + +@article{saraiva2025nanopyx, + title={Efficiently accelerated bioimage analysis with NanoPyx, a Liquid Engine-powered Python framework}, + author={Saraiva, Bruno M. and Cunha, In{\^e}s and Brito, Ant{\'o}nio D. and Jacquemet, Guillaume and Henriques, Ricardo}, + journal={Nature Methods}, + volume={22}, + pages={283--286}, + year={2025}, + publisher={Nature Publishing Group}, + doi={10.1038/s41592-024-02562-6}, + url={https://doi.org/10.1038/s41592-024-02562-6} +} + +@article{mcquin2018cellprofiler, + author = {McQuin, Claire and Goodman, Allen and Chernyshev, Vasiliy and Kamentsky, Lee and Cimini, Beth A. and Karhohs, Kyle W. and Doan, Minh and Ding, Liya and Rafelski, Susanne M. and Thirstrup, Derek and et al.}, + journal = {PLOS Biology}, + title = {Cellprofiler 3.0: Next-generation image processing for biology}, + year = {2018}, + doi={10.1371/journal.pbio.2005970} +} + +@article{demsar2013orange, + author = {Janez Dem\v{s}ar and Toma\v{z} Curk and Ale\v{s} Erjavec and \v{C}rt Gorup and + Toma\v{z} Ho\v{c}evar and Mitar Milutinovi\v{c} and Martin Mo\v{z}ina and Matija Polajnar and + Marko Toplak and An\v{z}e Stari\v{c} and Miha \v{S}tajdohar and Lan Umek and + Lan \v{Z}agar and Jure \v{Z}bontar and Marinka \v{Z}itnik and Bla\v{z} Zupan}, + title = {Orange: Data Mining Toolbox in Python}, + journal = {Journal of Machine Learning Research}, + year = {2013}, + volume = {14}, + pages = {2349-2353}, + url = {http://jmlr.org/papers/v14/demsar13a.html} +} + +@article{sandve2013ten, + author = {Sandve, Geir Kjetil and Nekrutenko, Anton and Taylor, James and Hovig, Eivind}, + journal = {PLoS Computational Biology}, + number = {10}, + title = {Ten simple rules for reproducible computational research}, + volume = {9}, + year = {2013}, + doi={10.1371/journal.pcbi.1003285} +} + +@article{DL4MicEverywhere, + author = {Hidalgo-Cenalmor, I. and Pylvänäinen, JW and G. Ferreira, M. and Russell, CT and Saguy, A. and Arganda-Carreras, I. and Shechtman, Y. and AI4Life Horizon Europe Program Consortium and Jacquemet, G. and Henriques, R. and Gómez-de-Mariscal, E.}, + journal = {nature Methods}, + number = {}, + title = {DL4MicEverywhere: deep learning for microscopy made flexible, shareable and reproducible.}, + volume = {21}, + year = {2024}, + doi={10.1038/s41592-024-02295-6} +} + +@article{imagej, + author = {Schneider, C. and Rasband, W. and Eliceiri, K.}, + journal = {Nature Methods}, + number = {}, + title = {NIH Image to ImageJ: 25 years of image analysis.}, + volume = {9}, + year = {2012}, + doi={10.1038/nmeth.2089} +} + +@misc{colab, + author = {Google}, + title = {Google Colaboratory}, + year = 2024, + url = {https://colab.research.google.com/} +} + +@article{colabfold, + author = {}, + journal = {Nature Methods}, + number = {19}, + title = {ColabFold: making protein folding accessible to all}, + volume = {}, + year = {2022}, + doi = {10.1038/s41592-022-01488-1} +} \ No newline at end of file diff --git a/publication/paper.md b/publication/paper.md new file mode 100644 index 0000000..2ae133f --- /dev/null +++ b/publication/paper.md @@ -0,0 +1,130 @@ +--- +title: "EZInput: A Cross-Environment Python Library for Easy UI Generation in Scientific Computing" +tags: + - User Interface + - Python + - Jupyter Notebook + - Terminal User Interface + - Scientific Computing +authors: + - name: "Bruno M. Saraiva" + affiliations: 1 + - name: "Iván Hidalgo-Cenalmor" + affiliations: 3 + - name: "António D. Brito" + affiliations: 1 + - name: "Damián Martínez" + affiliations: 1 + - name: "Tayla Shakespeare" + affiliations: 1 + - name: "Guillaume Jaquemet" + affiliations: "3, 4, 5, 6" + - name: "Ricardo Henriques" + affiliations: "1, 2" +affiliations: + - index: 1 + name: "Instituto de Tecnologia Química e Biológica António Xavier, Universidade Nova de Lisboa, Portugal" + - index: 2 + name: "UCL Laboratory for Molecular Cell Biology, University College London, United Kingdom" + - index: 3 + name: "Faculty of Science and Engineering, Cell Biology, Åbo Akademi University, Finland" + - index: 4 + name: "InFLAMES Research Flagship Center, University of Turku, Finland" + - index: 5 + name: "Turku Bioscience Centre, University of Turku and Åbo Akademi University, Finland" + - index: 6 + name: "Foundation for the Finnish Cancer Institute, Finland" +date: 2026-01-29 +bibliography: paper.bib +--- + +## Summary + +Researchers face a persistent barrier when applying computational algorithms with parameter configuration typically demanding programming skills, interfaces differing across environments, and settings rarely persisting between sessions. This fragmentation forces repetitive input, slows iterative exploration, and undermines reproducibility because parameter choices are difficult to record, share, and reuse. +We present EZInput, a cross-runtime environment Python library enabling algorithm developers to automatically generate graphical user interfaces that make their computational tools accessible to end-users without programming expertise. EZInput employs a declarative specification system where developers define input requirements and validation constraints once; the library then handles environment detection, interface rendering, parameter validation, and session persistence across Jupyter notebooks, Google Colab, and terminal environments. This "write once, run anywhere" architecture enables researchers to prototype in notebooks and deploy identical parameter configurations for batch execution on remote systems without code changes or manual transcription. Parameter persistence, inspired by ImageJ/FIJI and adapted to Python workflows, saves and restores user configurations via lightweight YAML files, eliminating redundant input and producing shareable records that enhance reproducibility. EZInput supports diverse input types essential for scientific computing and it also includes built-in validation that ensures data integrity and clear feedback that reduces user friction. + +--- + +## Statement of need + +Computational methods are central to modern scientific research, yet their practical adoption is often limited by usability and reproducibility challenges. Algorithm developers typically prioritise scientific correctness and performance, while the creation of robust user interfaces is time-consuming, environment-dependent, and difficult to maintain. As a result, many tools require users to configure parameters directly in code, excluding non-programmers and making parameter choices difficult to document, share, and reuse. + +Existing solutions address this problem only partially. Standalone graphical applications such as CellProfiler [@mcquin2018cellprofiler] and Orange [@demsar2013orange] provide accessible interfaces but require substantial development effort, constrain workflows, and usually target a single execution environment. Notebook-based approaches using Jupyter [@kluyver2016jupyter] enable interactive exploration but still rely on code edits for parameter configuration and lack persistent parameter memory, forcing repetitive input across sessions. + +EZInput is designed to solve these problems for **scientifically focused algorithm developers** who want to make their tools accessible to **end-users without programming expertise**, while also supporting **reproducible, systematic parameter exploration**. By providing environment-agnostic interface generation and automatic parameter persistence, EZInput enables the same parameter configurations to be used consistently across interactive notebooks, cloud platforms, and terminal-based execution. + +--- + +## State of the field + +While powerful algorithms are being created, their adoption by non-programming users has been hampered by interfaces demanding programmatic expertise, creating a dichotomy between algorithm development and practical application. Recent community efforts have begun addressing this challenge, with notable successes in specific domains such as ZeroCostDL4Mic and DL4MicEverywhere for deep learning in microscopy [@von2021democratising; @DL4MicEverywhere] and napari for interactive image visualisation [@sofroniew2025napari]. However, these solutions typically target specific computational environments or application domains. What remains missing is a framework enabling developers to write interface specifications once and deploy them anywhere at the same time as it automatically maintains parameter configurations that enhance reproducibility and facilitate systematic testing across different parameter combinations. + +Traditional approaches to bridging this accessibility gap have typically followed two distinct paths, each with inherent limitations. The first involves developing bespoke graphical user interfaces (GUIs) for individual algorithms, exemplified by tools such as CellProfiler for bioimage analysis [@mcquin2018cellprofiler] and Orange for data mining [@demsar2013orange]. Although these provide accessible entry points for non-programmers, they require substantial additional development effort, create fragmented user experiences across tools, and often constrain users to predefined workflows that limit algorithmic flexibility. Critically, such bespoke solutions typically target a single computational environment, preventing developers from easily distributing their tools to users working in different contexts. The second approach utilises notebook environments such as Jupyter [@kluyver2016jupyter], which offer more accessible entry points and have become the de facto standard for exploratory data analysis. However, notebook-based approaches still necessitate direct code manipulation for parameter configuration and critically lack persistent parameter settings essential for iterative workflows. This absence of parameter memory forces users to repeatedly input configurations across sessions, diminishing productivity in exploratory research contexts where rapid iteration over parameter spaces is fundamental, and making systematic testing across parameter combinations unnecessarily cumbersome. + +ImageJ and its distribution FIJI have demonstrated the value of parameter persistence through their parameter memory systems, which automatically retain user settings across sessions, enabling rapid experimental iterations that significantly enhance productivity in image analysis pipelines [@imagej; @schindelin2012fiji]. This functionality has proven particularly valuable in microscopy workflows, where researchers frequently fine-tune processing parameters across diverse datasets. However, translating this functionality to the Python ecosystem has proven challenging due to architectural differences in development frameworks and the absence of a unified parameter management system that operates consistently across computational environments. Existing Python GUI frameworks such as ipywidgets provide building blocks for notebook interfaces but cannot be easily deployed elsewhere as they were developed with only jupyter notebooks in mind. + +Here, we present EZInput, a cross-runtime environment Python library that bridges this accessibility gap by enabling algorithm developers to create user-friendly interfaces with minimal effort, making their tools accessible to end-users without programming expertise across diverse computational environments. The framework employs a declarative specification system where developers define input requirements and constraints once, after which EZInput automatically manages interface rendering, validation, and parameter persistence across Jupyter notebooks, Google Colab, and terminal environments \autoref{fig:diagram}. This "write once, run anywhere" architecture eliminates the need for parallel development of multiple interfaces while maintaining full feature parity across environments. EZInput adapts ImageJ/FIJI's parameter memory concept to modern Python workflows through lightweight configuration files that automatically save and restore user settings across sessions, enabling the rapid iteration essential for exploratory data analysis. Unlike previous solutions that sacrifice either accessibility or algorithmic sophistication, EZInput preserves both through an architecture that separates interface concerns from computational logic, allowing algorithm developers to focus on their scientific domain as the library handles all aspects of user interaction, validation, and parameter management. + +![**EZInput enables seamless cross-application user interfaces through unified declarative specifications.** The framework demonstrates consistent interface generation across computational environments without requiring environment-specific code modifications. Underlying Python code demonstrating the declarative specification system that generates both interfaces. A single parameter definition block specifies labels and inputs, with EZInput automatically handling environment detection and appropriate interface rendering. This "write once, run anywhere" approach eliminates the need for parallel development of multiple interfaces whilst maintaining full feature parity across environments. Parameter persistence functionality ensures that user configurations remain consistent between Jupyter and terminal environments, enabling seamless transitions between interactive exploration and production workflows. \label{fig:diagram}](ezinput_flow.png){ width=80% } + +--- + +## Software Design + +EZInput implements a declarative parameter specification system that fundamentally separates interface content definition from presentation logic \autoref{fig:cross-application}. Developers specify input requirements through a simple, intuitive API where each parameter is defined by its type (integer range, float range, text input, file path, dropdown selection, checkbox), label, constraints (minimum/maximum values, valid options, file extensions), and optional default values. The library's core architecture automatically detects the execution environment and renders appropriate interface elements without requiring environment-specific code from developers. This automatic environment detection mechanism examines the Python runtime context, checking for the presence of IPython kernel connections and interactive shell characteristics to determine the optimal rendering backend. + +![**EZInput enables seamless cross-application user interfaces through unified declarative specifications.** The framework demonstrates consistent interface generation across computational environments without requiring environment-specific code modifications. Underlying Python code demonstrating the declarative specification system that generates both interfaces. A single parameter definition block specifies labels and inputs, with EZInput automatically handling environment detection and appropriate interface rendering. This "write once, run anywhere" approach eliminates the need for parallel development of multiple interfaces whilst maintaining full feature parity across environments. Parameter persistence functionality ensures that user configurations remain consistent between Jupyter and terminal environments, enabling seamless transitions between interactive exploration and production workflows. \label{fig:cross-application}](code_example.png){ width=80% } + +In Jupyter notebook environments, including Google Colab [@colab], EZInput leverages the ipywidgets library to generate interactive graphical controls that integrate seamlessly with the notebook interface. Numerical parameters are rendered as sliders with real-time value display, dropdown selections appear as native select widgets, text inputs provide inline editing with validation feedback, and file path inputs offer interactive file browser integration. The generated interfaces maintain full compatibility with Jupyter's output cell system, displaying parameter configurations inline with code cells and preserving interactive state across notebook sessions. + +For terminal environments, EZInput employs promp\_toolkit to construct sophisticated text-based user interfaces (TUIs) that provide keyboard-navigable parameter configuration without graphical display requirements [@prompt_toolkit]. The terminal interface implements identical functionality to the Jupyter version, including parameter validation, constraint enforcement, help text display, and configuration persistence, ensuring consistent user experience regardless of computational context. Parameters are presented in a vertically scrollable list with clear visual hierarchy, keyboard shortcuts enable rapid navigation between fields, and validation feedback appears inline as users modify values. This terminal compatibility proves particularly valuable in high-performance computing environments and remote server contexts where graphical displays are limited but user-friendly parameter configuration remains essential. + +A defining innovation of EZInput is its automatic parameter persistence system, which saves user configurations to lightweight YAML files stored alongside Python scripts or in user-specified locations. This functionality adapts ImageJ/FIJI's parameter memory concept to modern Python workflows, addressing a critical gap in existing notebook-based scientific computing tools. When users configure parameters through either Jupyter or terminal interfaces, EZInput automatically serializes their selections to a human-readable YAML file using a naming convention derived from the interface title. Upon subsequent executions, the library automatically detects and loads these configuration files, pre-populating interface elements with previously saved values. This eliminates the redundant parameter input that typically characterizes exploratory research workflows, where scientists iteratively refine analysis parameters across multiple sessions. + +The parameter persistence mechanism implements selective memory through a flag on individual parameters, allowing developers to specify which parameters should persist across sessions and which should reset to defaults. This granular control proves essential for workflows where certain parameters (such as file paths or experimental conditions) vary between runs while others (such as algorithmic hyperparameters or processing settings) typically remain constant. Configuration files employ a structured YAML format that maintains parameter names, values, and metadata, ensuring robustness to parameter additions or removals across code versions. The human-readable format also enables manual editing of configuration files when programmatic parameter adjustment is desired, and supports version control integration for collaborative research contexts where parameter configurations constitute part of the experimental methods. + +Beyond individual workflow efficiency, parameter persistence substantially enhances reproducibility in computational research. Configuration files generated by EZInput can be shared alongside datasets and analysis scripts, enabling collaborators to reproduce analyses with identical parameter settings without requiring detailed written documentation of each parameter value. This addresses reproducibility challenges documented in computational science [@sandve2013ten], where parameter configurations often remain inadequately documented in traditional methods sections. In collaborative projects, shared configuration files ensure consistency across multiple users executing the same analysis pipeline, reducing variability introduced by manual parameter transcription errors. The lightweight nature of YAML configuration files also facilitates inclusion in supplementary materials for scientific publications, providing complete transparency of computational methods. + +--- + +## Research Impact Statement + +EZInput addresses the persistent accessibility barrier in computational science by empowering algorithm developers to create user-friendly interfaces with minimal development effort. Through automatic GUI generation, parameter persistence, and cross-environment consistency, the library enables developers to make sophisticated computational methods accessible to end-users, such as experimental biologists, who may lack programming expertise, while simultaneously facilitating systematic testing across diverse computational environments. By requiring only declarative specification of input requirements, EZInput eliminates the substantial interface development overhead whilst maintaining full algorithmic flexibility, allowing developers to focus on their computational methods rather than GUI implementation. The "write once, run anywhere" architecture not only democratizes access for end-users but also streamlines developer workflows, enabling the same parameter configurations to be tested seamlessly from local Jupyter notebooks to cloud platforms to HPC clusters without code modification. + +The framework's success is exemplified by its integration into NanoPyx, a high-performance bioimage analysis library, where microscopy researchers leverage EZInput to easily process their images using the methods implemented in NanoPyx \autoref{fig:nanopyx-example} [@saraiva2025nanopyx]. We have also adapted the ColabFold notebook [@colabfold] to use EZInput for parameter configuration, demonstrating its versatility across diverse scientific domains. + +![**Integration of EZInput within NanoPyx enables accessible, reproducible microscopy image analysis.** In NanoPyx, EZInput’s declarative parameter specification automatically produces Jupyter notebook interfaces for complex image processing routines (image registration, denoising, super-resolution reconstruction and image quality assessment). Parameters (numeric ranges, paths, algorithm modes) persist across sessions via lightweight YAML memory, accelerating iterative tuning and ensuring identical settings can be reapplied or shared. This integration lowers the barrier for non-programming users while preserving full algorithmic flexibility, supporting seamless transition from interactive exploration to scripted or HPC execution using the same saved configurations. \label{fig:nanopyx-example}](nanopyx_example.png) + +Unlike comprehensive platforms such as CellProfiler [@mcquin2018cellprofiler] or ImageJ/FIJI [@schindelin2012fiji], EZInput functions as a lightweight library integrating into existing Python codebases. Compared to GUI frameworks including ipywidgets, EZInput distinguishes itself through automatic interface generation from declarative specifications, built-in parameter persistence addressing reproducibility, and native terminal support enabling HPC deployment. While web-based frameworks excel at creating dashboards, they require server infrastructure incompatible with many HPC environments where scientific computing occurs. EZInput's minimal dependencies (ipywidgets, prompt_toolkit, PyYAML) facilitate integration without conflicts while enabling developers to validate their tools across multiple execution contexts with identical parameter sets. + +Automatic configuration files document exact algorithmic settings, enabling inclusion in supplementary materials, sharing among collaborators for analytical consistency, and version control alongside analysis scripts. Critically, these same configuration files enable systematic testing by allowing developers to define parameter sets once and validate algorithmic behavior across different computational environments. This addresses reproducibility concerns raised by Sandve et al. [@sandve2013ten] regarding inadequate documentation of computational methods as it provides a practical infrastructure for systematic validation workflows. + +EZInput's declarative system optimally serves applications with well-defined parameters suitable for standard input types. Applications requiring sophisticated custom visualizations or real-time graphical feedback may benefit from specialized frameworks offering lower-level control, positioning EZInput as complementary to visualization tools like napari [@sofroniew2025napari]. + +The open-source nature under MIT license facilitates community development, with ongoing priorities including enhanced documentation, cross-environment testing, and integration patterns for common scientific Python frameworks (scikit-learn, scikit-image, PyTorch). +By lowering barriers to creating accessible scientific tools, EZInput enables accessibility considerations to become standard practice rather than optional enhancements. This democratization of interface development parallels the democratization of algorithm access itself, expanding participation in computational science from both developer and user perspectives. As computational methods become increasingly central to scientific inquiry, tools that simultaneously address accessibility and reproducibility through unified architectural design provide valuable contributions to evolving computational research infrastructure. +--- + +## AI usage disclosure + +GitHub copilot with model GPT-4.1 was used for creating automatic documentation and docstrings which were then reviewed and edited by the authors. + +LLM model GPT-5 was used as an editorial aid during the preparation of this manuscript to assist with restructuring and clarity. All technical descriptions, claims, and comparisons were written, reviewed, and verified by the authors to ensure correctness and fidelity to the software implementation and existing literature. + +--- + +## Code availability + +EZInput is open source and available at + + +Demonstrated integrations: +- NanoPyx: +- ColabFold notebook using EZInput: + + +--- + +## Acknowledgements + +A.D.B. acknowledges the FCT 2021.06849.BD fellowship. B.S. and R.H. acknowledge support from the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation programme (grant agreement No. 101001332) (to R.H.) and funding from the European Union through the Horizon Europe program (RT-SuperES project with grant agreement 101099654-RTSuperES to R.H.). Funded by the European Union. However, the views and opinions expressed are those of the authors only and do not necessarily reflect those of the European Union. Neither the European Union nor the granting authority can be held responsible for them. This work was also supported by a European Molecular Biology Organization (EMBO) installation grant (EMBO-2020-IG-4734 to R.H.), a Chan Zuckerberg Initiative Essential Open Source Software for Science (EOSS6-0000000260), additionally supported by the Wellcome Trust (grant number 313383/Z/24/Z). Also by a "la Caixa" Foundation (grant HR25-00453 to R.H.). This work was supported by FCT – Fundação para a Ciência e a Tecnologia, I.P., through MOSTMICRO-ITQB R&D Unit (doi.org/10.54499/UID/04612/2025, UID/PRR/4612/2025) and LS4FUTURE Associated Laboratory (DOI 10.54499/LA/P/0087/2020). This study was funded by the Research Council of Finland (338537, 371287 and 374180 to G.J.), the Sigrid Juselius Foundation (to G.J.), the Cancer Society of Finland (Syöpäjärjestöt; to G.J.), and the Solutions for Health strategic funding for Åbo Akademi University (to G.J.). Additionally, this research received support from the InFLAMES Flagships Programme of the Research Council of Finland (decision numbers: 337530, 337531, 357910, and 35791). I.H. was supported by the Ministry of Education and Culture's Doctoral Education Pilot under Decision No. VN/3137/2024-OKM-6 (The Finnish Doctoral Program Network in Artificial Intelligence, AI-DOC).