python library integration

Existing Python library migration tools are largely restricted to API-level mapping or specific library pairs, suffering from narrow coverage and low automation. This paper introduces the first end-to-end, general-purpose Python library migration framework, leveraging large language models (LLMs) as its core engine and integrating static analysis (to extract contextual dependencies) with dynamic analysis (to verify behavioral consistency), enabling fully automated code migration between functionally similar libraries. We propose a novel program-analysis-driven LLM post-processing optimization mechanism, significantly enhancing migration accuracy and robustness. Our command-line implementation is evaluated on 717 real-world projects: 32% achieve fully correct migrations, and in over 50% of projects, developers need to address fewer than 14% of residual changes—substantially reducing manual effort and error rates.

Large language models (LLMs) exhibit structural deficiencies in dependency management when generating production-ready Python code, particularly in recommending installable and executable third-party libraries. Method: This study conducts the first systematic evaluation of six mainstream LLMs on real-world Stack Overflow Python questions, using a standardized benchmark that integrates prompt engineering, automated dependency parsing, and license analysis to quantify installability, naming consistency (i.e., alignment between package names and import identifiers), and deployment feasibility of recommended libraries. Contribution/Results: LLMs strongly favor third-party libraries, yet 4.6% of recommendations fail installation due to package–import name mismatches; only two models provide installation commands; and while most generated code is syntactically correct, it frequently lacks executable dependency support. The findings expose critical gaps in LLMs’ handling of software dependencies for production use and propose three concrete improvements to enhance library recommendation usability: (1) enforcing naming consistency, (2) integrating dependency resolution into generation, and (3) augmenting prompts with installation-context awareness.

This study addresses the lack of empirical guidance in selecting model export formats during AI system development. We systematically evaluate five formats—ONNX, SavedModel, TorchScript, Pickle, and Joblib—across integration efficiency, cross-platform compatibility, and maintenance cost. Employing an embedded multi-case empirical design—including two industrial systems and three distinct technology stacks—we integrate questionnaire surveys (n=17), structured on-site observations, and qualitative thematic analysis. Our findings reveal that ONNX achieves the best overall balance in cross-framework portability and integration efficiency; SavedModel uniquely excels in end-to-end deep learning pipelines, particularly in preprocessing encapsulation; whereas Pickle and Joblib exhibit pervasive security vulnerabilities and environment coupling, incurring the highest integration costs. This work provides the first engineering-oriented, empirically grounded basis for model serialization format selection in production AI deployment.

This study addresses the challenges of integrating machine learning (ML) models into software systems—namely, poor integration practices, low reusability, and unclear architectural boundaries. It presents the first large-scale empirical investigation across 2,928 open-source ML-enabled systems. Leveraging GitHub code mining, static analysis, topic modeling, and architectural pattern identification, the work systematically characterizes ML integration topologies, code/model reuse practices, and maintenance bottlenecks. Key contributions include: (1) the first comprehensive classification framework and architectural pattern atlas for ML-enabled systems; (2) identification of seven prevalent integration topologies and four model reuse patterns; and (3) uncovering critical interdisciplinary collaboration barriers in ML-software co-development. The findings bridge the methodological gap between data science and software engineering at the model embedding stage, providing industry-practical architectural guidelines that significantly enhance the maintainability and reusability of ML systems.

This work addresses the low accuracy of large language models (LLMs) in predicting code edits during machine learning (ML) Jupyter notebook maintenance. We introduce the first large-scale, real-world, fine-grained edit dataset—comprising 48,398 cell- and line-level edits—automatically extracted and manually annotated from GitHub revision histories. We establish the first benchmark for ML notebook maintenance, revealing two key empirical patterns: edits are highly localized (mean span: 166 lines) and strongly context-sensitive. To model such edits, we propose a joint cell- and line-level edit prediction framework and conduct a systematic evaluation of LLMs across multiple scales, including zero-shot prediction and supervised fine-tuning. Results show that larger models consistently outperform smaller ones, yet overall accuracy remains limited—highlighting the intrinsic complexity of real-world ML maintenance tasks. Crucially, explicit contextual modeling is validated as the most effective pathway to performance improvement.

This work addresses the time-consuming and error-prone nature of manually migrating third-party libraries in Python projects, particularly when the original libraries become outdated or deprecated. To tackle this challenge, we propose MigMate—the first end-to-end, large language model (LLM)-based library migration plugin for Visual Studio Code—that seamlessly integrates automated migration capabilities into developers’ workflows. Built upon MigrateLib, MigMate leverages LLMs to generate migration code and provides an interactive preview and confirmation interface. Preliminary user studies demonstrate that MigMate significantly reduces the time required for migration tasks and achieves high scores on the System Usability Scale (SUS), confirming its effectiveness and practical utility.

This study addresses the challenge that existing AI models are often difficult to reuse due to missing or outdated documentation that lags behind community practices. To tackle this issue, the authors propose an agile, data-driven, and community-driven approach to documentation generation. They introduce a novel mechanism for dynamically updating documentation templates based on evolving community practices, leveraging the Hugging Face model hub and Zero Draft templates. Documentation quality is evaluated through structural analysis of directory organization and term frequency metrics, supported by a continuous comparison infrastructure. Experimental results demonstrate a statistically significant positive correlation between documentation quality and model popularity—measured by download counts and likes—thereby validating that high-quality documentation substantially enhances model reusability.

This study addresses the limitation of existing research in effectively measuring whether open-source models are genuinely translated into publicly accessible applications, as metrics based solely on release, visibility, or technical reuse inadequately capture real-world impact. To bridge this gap, the paper introduces “public application translation” as a distinct dimension of model influence and constructs a large-scale dataset leveraging Model-Space links from the Hugging Face platform. Through systematic analysis combining metadata readiness assessment with heterogeneous space configuration, the work reveals that only a small fraction of models are linked to Spaces—and these are highly concentrated. Models successfully translated into public applications exhibit higher metadata quality and are deeply embedded within a diverse ecosystem encompassing datasets, SDKs, and task categories, thereby extending the evaluative framework for open-source model impact.

This study addresses the widespread absence of source repository and donation links in PyPI packages, which undermines transparency, trustworthiness, and sustainability in open-source projects. To investigate the underlying causes, we conduct the first large-scale empirical survey, distributing questionnaires to 50,000 PyPI authors and obtaining over 1,400 valid responses. Leveraging large language model (LLM)-driven thematic modeling, cross-round semantic similarity assessment, and expert validation (Randolph’s kappa), our analysis reveals that repository links primarily facilitate collaboration and transparency, whereas donation links are hindered by developers’ distrust of platforms and technical friction. We also identify pervasive issues of outdated links and insufficient awareness. Based on these findings, we propose concrete recommendations to improve PyPI metadata practices and demonstrate the effectiveness and robustness of LLMs in analyzing short-text survey responses.

Large language models struggle to coordinate multidimensional knowledge—such as function signatures, module paths, input-output contracts, and semantics—when encountering novel APIs absent from their training data. To address this, this work proposes NovelAPIBench, the first fully automated benchmark that supports dynamic API discovery and fine-grained failure diagnosis by automatically mining APIs, decomposing knowledge units, generating executable tasks, and attributing errors. Experiments reveal that in-context examples constitute the strongest single knowledge signal; incorporating source code context can inadvertently introduce import errors; and fine-tuning primarily enhances the model’s ability to leverage external knowledge, with demonstrated generalization to unseen libraries. The study further demonstrates that retrieval and parameterized adaptation play complementary rather than substitutive roles in enabling effective use of novel APIs.