python programming

This work addresses the inefficiencies researchers face in interactive computing environments due to cumbersome parameter configuration, inconsistent user interfaces, and the inability to persist settings across sessions—factors that hinder exploratory workflows and reproducibility. To overcome these challenges, the authors propose a declarative UI generation framework that, from a single specification of input parameters and validation rules, automatically renders consistent interfaces across diverse platforms such as Jupyter, Colab, and terminal-based environments. Inspired by ImageJ/FIJI, the system incorporates a persistence mechanism that serializes configurations in YAML format, enabling seamless sharing and reuse of settings across sessions and platforms. This approach significantly lowers the barrier for non-programmers to employ complex algorithms, minimizes redundant input, and enhances both experimental iteration speed and scientific reproducibility.

This study systematically evaluates large language models’ (LLMs) ability to invoke unfamiliar, domain-specific Python libraries (e.g., ParShift, pyclugen) for complex scientific computing tasks under zero-shot conditions, focusing on the reliability of generating executable and functionally correct code. We propose a structured zero-shot prompting framework, integrated with multi-round quantitative execution validation, functional correctness assessment, and error-pattern analysis; additionally, conversational data analysis and synthetic-data clustering serve as complementary evaluation dimensions. To our knowledge, this is the first benchmarking effort targeting LLMs’ capability to interface with third-party scientific computing libraries. Our evaluation reveals that documentation gaps and implementation flaws in target libraries significantly impede code generation. Results show only GPT-4.1 achieves consistent success across all tasks—outperforming all other models substantially. This work establishes a novel benchmark, methodology, and empirical foundation for trustworthy LLM-driven code generation in scientific automation.

This work addresses the high manual overhead and conceptual abstraction challenges faced by researchers and developers in Python package development. We propose a human-AI collaborative, end-to-end package auto-generation framework. Our method introduces a novel multi-stage large language model (LLM) orchestration paradigm, integrating structured prompt distillation, prompt augmentation, and a dual-track Human/LLM evaluation mechanism. Leveraging open-source autoregressive models—including CodeLlama and Phi-3—it jointly generates production-ready code, modular architecture, unit tests, and comprehensive documentation. Empirical evaluation demonstrates an 89% human-verified pass rate for generated packages, a 3.2× improvement in documentation completeness, and a 76% reduction in development cycle time. All source code, prompts, and usage examples are publicly released under an open license, enabling reproducible, extensible, and ethically grounded AI-augmented software engineering practice.

This work addresses the challenge of reproducibility in data visualization scripts, which often lack essential components such as source code, input data, execution environment, or output artifacts. To bridge this gap, we propose yProv4DV—a lightweight Python library that, for the first time, targets script-based visualization workflows by automatically capturing comprehensive provenance information—including source code, input data, runtime environment, and output results—through a single function call. Designed to be minimally invasive and ready-to-use, yProv4DV enables full reproducibility of visualization outputs without requiring any modification to existing scripts. This approach significantly reduces the development burden on researchers striving to ensure reproducibility and fills a critical void in automated provenance support within visualization pipelines.

Scientific computing artifacts—such as analysis scripts and software prototypes—frequently suffer from poor reproducibility due to environmental heterogeneity, dependency drift, and inadequate documentation, thereby undermining research credibility. To address this, we introduce the first cross-disciplinary, structured, and standardized benchmark dataset for computational experiments, encompassing workflows ranging from single-script executions to multi-language, complex pipelines. Our framework uniformly models metadata, standardizes dependency declarations (e.g., requirements.txt, Dockerfiles), encapsulates multi-language execution procedures, and prescribes a rigorous documentation protocol. The dataset comprises dozens of human-validated, fully reproducible experimental cases, enabling objective, comparable, and reproducible evaluation of reproducibility tools. This work fills a critical gap in the field by providing the first systematic, community-grounded benchmark for assessing computational reproducibility, thereby significantly enhancing the rigor, transparency, and comparability of reproducibility research.

This work addresses the time-consuming, error-prone manual development of Galaxy wrappers for command-line tools, which hinders scientific reproducibility. The authors propose an automated approach that generates compliant Galaxy XML wrappers by parsing structured metadata from Python tools’ argparse interfaces—specifically leveraging the metavar attribute to embed convention-based meta-information. This method enables fully automated, end-to-end integration into Galaxy without human intervention. Demonstrating both novelty and scalability, the approach has successfully generated a complete Galaxy tool suite for the anvi’o bioinformatics framework, encompassing hundreds of programs, thereby enabling seamless workflow execution within the Galaxy platform.

This work addresses the persistent challenge of inconsistent development and execution environments faced by researchers operating across heterogeneous computing platforms—ranging from laptops and workstations to supercomputers and cloud infrastructures. To overcome this, the authors propose a modular and portable software ecosystem featuring a unified command-line interface that enables seamless orchestration and execution of scientific workflows. The system ensures cross-platform consistency, reproducibility, and scalability, thereby streamlining computational research across diverse hardware configurations. Its practical efficacy has been demonstrated through successful integration into the plan4res project under the European Union’s Horizon 2020 initiative, where it effectively supported complex, large-scale scientific workflows in varied computing environments.

This study addresses the lack of systematic understanding regarding the implementation and maintenance of the Model Context Protocol (MCP) in real-world open-source projects. To bridge this gap, we introduce a transparent, reproducible multi-stage validation pipeline that integrates GitHub REST/GraphQL APIs with custom Python scripts to systematically annotate structural evidence, classify repository roles, and filter out non-functional examples from 3,238 candidate repositories. This process yields a high-quality dataset of 2,297 verified MCP projects, achieving a validation precision of 83% at 95% confidence. Our analysis reveals Python and TypeScript as the dominant implementation languages and identifies hybrid architecture as the most prevalent design pattern, thereby establishing the first large-scale empirical benchmark for MCP ecosystem research.

Current AI agents struggle to autonomously process raw scientific data, hindering the realization of end-to-end automated research. This work proposes a scientific data-centric multi-agent system that establishes a complete autonomous research loop by collaboratively interpreting raw data, generating data-driven hypotheses and experimental designs, and automatically executing code. The system innovatively integrates a self-evolving memory mechanism and a critic-guided feedback loop, leveraging large language models within a modular Python engineering framework. Evaluated on three scientific benchmarks, it significantly outperforms both general-purpose agents and state-of-the-art models. To facilitate broad adoption in scientific workflows, the authors provide a PyPI package and a lightweight web interface.

Automatically generating verifiable Python formal specifications remains challenging, and developers often abandon automated verification tools due to the tediousness of manually writing contracts. This work proposes a closed-loop approach that integrates large language models with symbolic execution (CrossHair) to automatically generate and iteratively refine icontract-style contract annotations without modifying the original code. The method leverages feedback from symbolic execution to drive specification refinement and simultaneously produces coverage-guided pytest stubs and debugging artifacts. Experimental results demonstrate that the approach successfully generates CrossHair-compatible specifications for most programs, significantly enhancing the practical feasibility of automated verification, while also revealing real-world limitations arising from the boundaries of symbolic exploration and behavioral discrepancies in large language models.