How gaius-augustus/galba works
Based on our analysis of the file tree and the detailed README, the GALBA project is a bioinformatics pipeline designed for automated gene structure annotation. It builds on well‐established tools (like AUGUSTUS, Miniprot, DIAMOND, TSEBRA, and others) and is written primarily in Perl (with some Python scripts) to run a complex workflow that takes protein sequences and a target genome as input, creates training data, and then predicts gene structures. The project is distributed with a Dockerfile and Singularity image for containerized deployment, along with a comprehensive set of documentation and example test runs.
Main Components
• Main Pipeline Controller: The central entry point is the “galba.pl” script. This component orchestrates the whole workflow.
• Protein-to-Genome Alignment Module: This module can use one of two aligners – either Miniprot (default) or GenomeThreader (gth option). Supporting scripts (e.g., startAlign.pl, aln2hints.pl) fall into this category.
• Training & Prediction Module: Once evidence is produced (e.g., hints files), AUGUSTUS is trained and then used for gene prediction. This module involves multiple iterative training steps (with additional scripts like galba_cleanup.py and optimize_augustus.pl – even though the latter might be part of AUGUSTUS itself).
• Filtering and Post-processing: DIAMOND filtering, TSEBRA for selecting transcripts, and scripts for checking and cleaning predictions (scripts such as filterIntronsFindStrand.pl, gtf_sanity_check.py, etc.) form another group.
• Optional Hub Generation: MakeHub and UCSC track hub creation pipeline (using MakeHub in the container) are also part of the architecture.
• Testing & Validation: The “t” and “example” directories house test cases and example results—important for ensuring proper execution on sample data.
• Environment and Configuration Components: Dockerfile, Singularity instructions, and configuration scripts (as seen by the existence of “cpanfile”, “scripts/cfg” etc.) indicate environment setup and dependency management.
Relationships and Data Flow
• Inputs: Genome file (FASTA) and protein sequences serve as the input.
• The main pipeline script (galba.pl) first calls protein alignment module (using the chosen aligner). Results are converted into “hints” (GFF or similar), then these hints feed into the training module (where training genes are selected and used to parameterize AUGUSTUS).
• AUGUSTUS is then run (both in prediction-with-hints mode and optionally in ab initio mode). Output files (GTF, GFF3, FASTA coding sequences, protein sequences) are produced.
• Optional post-processing modules (DIAMOND filtering, TSEBRA, and hub creation with MakeHub) operate on these outputs.
• Multiple external dependencies (Miniprot, DIAMOND, AUGUSTUS, TSEBRA, Pygustus, etc.) are called as separate programs via command-line from within one or more scripts.
• The Docker/Singularity containerization ensures that many of these components are preconfigured and that the environment (e.g., paths to executables, writable configuration directories) is maintained.
Architectural Patterns and Design Principles
• Modular Structure: The separation into distinct scripting components (each handling a specific task) suggests a modular, “pipeline-style” architecture.
• Dependency Injection & Configuration: The project relies extensively on environment variables (e.g., AUGUSTUS_CONFIG_PATH, MINIPROT_PATH, DIAMOND_PATH) and command-line options to dynamically assign paths and parameters.
• Containerization: Dockerfile and Singularity instructions encapsulate the runtime environment.
• Logging/Testing: The “t” directory and example test scripts ensure the robust testing and validation of each module.