Coverage for binette/pipeline.py: 100%

202 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-17 13:33 +0000

1""" 

2Module : pipeline 

3Description : Orchestration of a Binette run, from input parsing to final bin selection. 

4Copyright : (c) Jean Mainguy 

5License : GPL-3.0 

6""" 

7 

8import hashlib 

9import logging 

10from collections import Counter 

11from dataclasses import dataclass 

12from pathlib import Path 

13from typing import Any 

14 

15import pyfastx 

16 

17import binette as binette_init 

18from binette import bin_manager, bin_quality, cds, checkpoint, contig_manager, diamond 

19from binette import io_manager as io 

20from binette.bin_manager import Bin 

21from binette.config import OutputPaths, RunConfig 

22 

23logger = logging.getLogger(__name__) 

24 

25# High quality thresholds, only used to log the number of high quality bins. 

26HQ_MIN_COMPLETENESS = 90 

27HQ_MAX_CONTAMINATION = 5 

28 

29 

30@dataclass 

31class InputData: 

32 """Bins and contigs parsed from the input files.""" 

33 

34 contig_key_to_original_bin: dict[Any, Bin] 

35 contigs_in_bins: list[str] 

36 contig_to_length: dict[int, int] 

37 contig_to_index: dict[str, int] 

38 fingerprints: dict[str, str] 

39 

40 

41def run(config: RunConfig) -> int: 

42 """ 

43 Run Binette. 

44 

45 :param config: Parameters of the run. 

46 :raises checkpoint.OutputDirConflictError: If the output directory holds results 

47 of a run with different inputs (and ``config.force`` is not set). 

48 :return: Exit code. 

49 """ 

50 paths = OutputPaths.from_outdir(config.outdir) 

51 

52 inputs = parse_input_files( 

53 config.bin_dirs, 

54 config.contig2bin_tables, 

55 config.contigs, 

56 fasta_extensions=set(config.fasta_extensions), 

57 ) 

58 

59 diamond_db_path = diamond.resolve_checkm2_db(config.checkm2_db) 

60 run_inputs = make_run_inputs(config, inputs, diamond_db_path) 

61 

62 ckpt = checkpoint.check_outdir( 

63 config.outdir, paths.manifest, run_inputs, config.force 

64 ) 

65 

66 if config.resume and not ckpt.data["steps"]: 

67 logger.info( 

68 "No intermediate results from a previous run to resume from: starting from scratch" 

69 ) 

70 

71 if is_already_completed(config, paths, ckpt, run_inputs): 

72 return 0 

73 

74 # Results of this run will be rewritten: they no longer reflect a completed run. 

75 ckpt.invalidate("final", "bins_fasta") 

76 

77 if config.debug: 

78 write_index_to_contig(inputs.contigs_in_bins, paths.index_to_contig_file) 

79 

80 contig_metadata, contig_to_coding_length, diamond_step_inputs = annotate_contigs( 

81 config, paths, inputs, ckpt, run_inputs, diamond_db_path 

82 ) 

83 

84 contig_key_to_original_bin = assess_input_bins( 

85 config, paths, inputs, contig_metadata, contig_to_coding_length 

86 ) 

87 

88 contig_key_to_all_bin = create_and_assess_intermediate_bins( 

89 config, paths, inputs, contig_key_to_original_bin, contig_metadata 

90 ) 

91 

92 selected_bins = select_bins(config, contig_key_to_all_bin, contig_to_coding_length) 

93 

94 write_final_outputs( 

95 config, 

96 paths, 

97 inputs, 

98 selected_bins, 

99 ckpt, 

100 final_step_inputs(config, diamond_step_inputs), 

101 ) 

102 

103 return 0 

104 

105 

106# Inputs # 

107 

108 

109def parse_input_files( 

110 bin_dirs: list[Path] | None, 

111 contig2bin_tables: list[Path] | None, 

112 contigs_fasta: Path, 

113 fasta_extensions: set[str] | None = None, 

114) -> InputData: 

115 """ 

116 Parses input files to retrieve information related to bins and contigs. 

117 

118 :param bin_dirs: List of paths to directories containing bin FASTA files. 

119 :param contig2bin_tables: List of paths to contig-to-bin tables. 

120 :param contigs_fasta: Path to the contigs FASTA file. 

121 :param fasta_extensions: Possible fasta extensions to look for in the bin directory. 

122 

123 :return: Parsed bins and contigs, with input fingerprints ("contigs" and "bins") 

124 identifying the run. 

125 """ 

126 if fasta_extensions is None: 

127 fasta_extensions = {".fasta", ".fa", ".fna"} 

128 

129 if bin_dirs: 

130 logger.info("Parsing bin directories") 

131 bin_name_to_bin_dir = io.infer_bin_set_names_from_input_paths(bin_dirs) 

132 bin_set_name_to_bins_info = bin_manager.parse_bin_directories( 

133 bin_name_to_bin_dir, fasta_extensions 

134 ) 

135 else: 

136 logger.info("Parsing bin2contig files") 

137 bin_name_to_bin_table = io.infer_bin_set_names_from_input_paths( 

138 contig2bin_tables 

139 ) 

140 bin_set_name_to_bins_info = bin_manager.parse_contig2bin_tables( 

141 bin_name_to_bin_table 

142 ) 

143 

144 logger.info(f"Processing {len(bin_set_name_to_bins_info)} bin sets") 

145 for bin_set_id, bins_info in bin_set_name_to_bins_info.items(): 

146 logger.info(f" {bin_set_id} - {len(bins_info)} bins") 

147 

148 contigs_in_bins = bin_manager.get_contigs_in_bin_sets(bin_set_name_to_bins_info) 

149 logger.info(f"Found {len(contigs_in_bins)} contigs in input bins") 

150 

151 contig_to_index = contig_manager.make_contig_index(contigs_in_bins) 

152 

153 contig_key_to_bin = bin_manager.make_bins_from_bins_info( 

154 bin_set_name_to_bins_info, contig_to_index, are_original_bins=True 

155 ) 

156 

157 logger.info( 

158 f"Parsing contig fasta file '{contigs_fasta}' to retrieve contig lengths" 

159 ) 

160 

161 contigs_in_bins_set = set(contigs_in_bins) 

162 contig_to_length = {} 

163 contig_to_seq_digest = {} 

164 for name, seq in pyfastx.Fastx(contigs_fasta.as_posix()): 

165 if name in contigs_in_bins_set: 

166 contig_to_length[name] = len(seq) 

167 contig_to_seq_digest[name] = hashlib.sha256(seq.encode()).hexdigest() 

168 

169 logger.debug("Finished parsing contig fasta file") 

170 # check if all contigs from input bins are present in contigs file 

171 unexpected_contigs = { 

172 contig for contig in contigs_in_bins if contig not in contig_to_length 

173 } 

174 

175 if len(unexpected_contigs): 

176 raise ValueError( 

177 f"{len(unexpected_contigs)} contigs from the input bins were not " 

178 f"found in the contigs file '{contigs_fasta}'. " 

179 f"The missing contigs are: {', '.join(unexpected_contigs)}. " 

180 f"Please ensure all contigs from input bins are present in " 

181 f"contig file." 

182 ) 

183 logger.debug("No unexpected contigs found") 

184 

185 contig_id_to_length = { 

186 contig_to_index[name]: length for name, length in contig_to_length.items() 

187 } 

188 

189 return InputData( 

190 contig_key_to_original_bin=contig_key_to_bin, 

191 contigs_in_bins=contigs_in_bins, 

192 contig_to_length=contig_id_to_length, 

193 contig_to_index=contig_to_index, 

194 fingerprints={ 

195 "contigs": checkpoint.contigs_fingerprint(contig_to_seq_digest), 

196 "bins": checkpoint.bins_fingerprint(bin_set_name_to_bins_info), 

197 }, 

198 ) 

199 

200 

201def write_index_to_contig(contigs_in_bins: list[str], output_file: Path) -> None: 

202 """Write the mapping of contig index to contig name (debug mode).""" 

203 logger.info(f"Writing index to contig mapping to '{output_file}'") 

204 with open(output_file, "w") as flout: 

205 flout.write("\n".join((f"{i}\t{c}" for i, c in enumerate(contigs_in_bins)))) 

206 

207 

208# Checkpoint steps # 

209 

210 

211def make_run_inputs( 

212 config: RunConfig, inputs: InputData, diamond_db_path: Path 

213) -> dict[str, Any]: 

214 """ 

215 Identity of the run: data inputs only. Parameters that only affect bin 

216 selection can change between runs sharing an output directory. 

217 """ 

218 return { 

219 "contigs": inputs.fingerprints["contigs"], 

220 "bins": inputs.fingerprints["bins"], 

221 "proteins": checkpoint.sha256_file(config.proteins) 

222 if config.proteins 

223 else None, 

224 "checkm2_db": checkpoint.checkm2_db_identity(diamond_db_path), 

225 } 

226 

227 

228def make_diamond_step_inputs( 

229 ckpt: checkpoint.Checkpoint, faa_file: Path, checkm2_db: dict, low_mem: bool 

230) -> dict: 

231 """ 

232 Inputs of the DIAMOND step: the proteins it runs on (as recorded in the 

233 checkpoint), the CheckM2 database and the DIAMOND parameters. 

234 """ 

235 return { 

236 "proteins_sha256": ckpt.step_output_digest("proteins", faa_file), 

237 "checkm2_db": checkm2_db, 

238 "parameters": diamond.result_parameters(low_mem), 

239 } 

240 

241 

242def final_step_inputs(config: RunConfig, diamond_step_inputs: dict) -> dict: 

243 """ 

244 Inputs of the final results step. It chains to upstream steps: final results are 

245 only reusable if the DIAMOND results (and through them, the proteins) match. 

246 """ 

247 return { 

248 "binette_version": binette_init.__version__, 

249 "parameters": config.selection_parameters(), 

250 "diamond": diamond_step_inputs, 

251 } 

252 

253 

254def bins_fasta_step_inputs(contig2bin_table: Path) -> dict: 

255 """Inputs of the bins FASTA step: the final bins it was written from.""" 

256 return {"contig2bin_table_sha256": checkpoint.sha256_file(contig2bin_table)} 

257 

258 

259def record_bins_fasta_step( 

260 ckpt: checkpoint.Checkpoint, contig2bin_table: Path, final_bins_dir: Path 

261) -> None: 

262 """Record the final bins FASTA files in the checkpoint.""" 

263 ckpt.record_step( 

264 "bins_fasta", 

265 bins_fasta_step_inputs(contig2bin_table), 

266 sorted(final_bins_dir.glob("*.fa")), 

267 ) 

268 

269 

270def ensure_bins_fasta( 

271 ckpt: checkpoint.Checkpoint, 

272 contig2bin_table: Path, 

273 contigs_fasta: Path, 

274 final_bins_dir: Path, 

275) -> None: 

276 """ 

277 Make sure the FASTA files of the final bins of a completed run are present and 

278 intact. Missing or modified files are written again from the final contig2bin 

279 table, without recomputing bin selection. 

280 

281 :param ckpt: Checkpoint of the run. 

282 :param contig2bin_table: Final contig2bin table of the completed run. 

283 :param contigs_fasta: Path to the contigs FASTA file. 

284 :param final_bins_dir: Directory of the final bins FASTA files. 

285 """ 

286 is_valid, reason = ckpt.step_status( 

287 "bins_fasta", bins_fasta_step_inputs(contig2bin_table) 

288 ) 

289 if is_valid: 

290 return 

291 

292 logger.info( 

293 f"Writing selected bins FASTA files to '{final_bins_dir}' from " 

294 f"'{contig2bin_table}' ({reason})" 

295 ) 

296 for fasta_file in final_bins_dir.glob("*.fa"): 

297 fasta_file.unlink() 

298 io.write_bins_fasta_from_contig_to_bin( 

299 io.read_contig2bin_table(contig2bin_table), contigs_fasta, final_bins_dir 

300 ) 

301 record_bins_fasta_step(ckpt, contig2bin_table, final_bins_dir) 

302 

303 

304def is_already_completed( 

305 config: RunConfig, 

306 paths: OutputPaths, 

307 ckpt: checkpoint.Checkpoint, 

308 run_inputs: dict[str, Any], 

309) -> bool: 

310 """ 

311 Check whether a previous run completed with the same inputs and parameters. 

312 If so, missing bin FASTA files are written again when requested. 

313 """ 

314 diamond_step_inputs = make_diamond_step_inputs( 

315 ckpt, paths.faa_file, run_inputs["checkm2_db"], config.low_mem 

316 ) 

317 if not ckpt.can_reuse( 

318 "final", 

319 final_step_inputs(config, diamond_step_inputs), 

320 config.resume, 

321 "final results", 

322 ): 

323 return False 

324 

325 if config.write_fasta_bins: 

326 ensure_bins_fasta( 

327 ckpt, paths.final_contig2bin_table, config.contigs, paths.final_bins_dir 

328 ) 

329 logger.info( 

330 f"Binette already completed with identical inputs and parameters in '{config.outdir}': " 

331 "nothing to do. Use --no-resume to rerun." 

332 ) 

333 return True 

334 

335 

336# Proteins and DIAMOND # 

337 

338 

339def get_proteins( 

340 faa_file: Path, 

341 coding_length_file: Path, 

342 contigs_fasta: Path, 

343 contigs_in_bins: set[str], 

344 proteins: Path | None, 

345 threads: int, 

346 reuse: bool, 

347) -> tuple[dict[str, list[str]], dict[str, int | None] | None, list[Path]]: 

348 """ 

349 Predict genes, filter user-provided proteins, or reuse proteins from a previous run. 

350 

351 :param faa_file: Path of the protein file used by Binette. 

352 :param coding_length_file: Path of the file storing contig coding lengths. 

353 :param contigs_fasta: Path to the contigs FASTA file. 

354 :param contigs_in_bins: Set of contigs in bins. 

355 :param proteins: Protein file provided by the user, or None to predict genes. 

356 :param threads: Number of threads for gene prediction. 

357 :param reuse: Reuse files of a previous run instead of computing them. 

358 

359 :return: contig_to_genes, contig_to_coding_length (None when not computable) and 

360 the list of files produced. 

361 """ 

362 if reuse: 

363 logger.info(f"Parsing protein sequences from '{faa_file}'") 

364 contig_to_genes = cds.parse_faa_file(faa_file.as_posix()) 

365 contig_to_coding_len = ( 

366 None if proteins else io.read_contig_coding_length(coding_length_file) 

367 ) 

368 

369 elif proteins: 

370 logger.info(f"Using the provided protein sequences file '{proteins}'") 

371 cds.filter_faa_file( 

372 contigs_in_bins, 

373 input_faa_file=proteins, 

374 filtered_faa_file=faa_file, 

375 ) 

376 logger.info(f"Parsing protein sequences from '{faa_file}'") 

377 contig_to_genes = cds.parse_faa_file(faa_file.as_posix()) 

378 contig_to_coding_len = None 

379 

380 else: 

381 logger.info(f"Loading {len(contigs_in_bins)} contigs from '{contigs_fasta}'") 

382 contigs_iterator = ( 

383 (name, seq) 

384 for name, seq in pyfastx.Fastx(contigs_fasta.as_posix()) 

385 if name in contigs_in_bins 

386 ) 

387 contig_to_genes, contig_to_coding_len = cds.predict( 

388 contigs_iterator, faa_file.as_posix(), threads 

389 ) 

390 io.write_contig_coding_length(contig_to_coding_len, coding_length_file) 

391 

392 if proteins: 

393 io.check_contig_consistency( 

394 contigs_in_bins, 

395 contig_to_genes, 

396 contigs_fasta.as_posix(), 

397 faa_file.as_posix(), 

398 ) 

399 logger.info( 

400 "Coding density will not be computed (using provided protein sequences)" 

401 ) 

402 outputs = [faa_file] 

403 else: 

404 logger.info("Coding density will be computed from identified genes") 

405 outputs = [faa_file, coding_length_file] 

406 

407 return contig_to_genes, contig_to_coding_len, outputs 

408 

409 

410def get_diamond_hits( 

411 faa_file: Path, 

412 contigs_fasta: Path, 

413 contigs_in_bins: set[str], 

414 diamond_result_file: Path, 

415 diamond_db_path: Path, 

416 threads: int, 

417 low_mem: bool, 

418 reuse: bool, 

419) -> dict[str, Counter]: 

420 """ 

421 Run DIAMOND on proteins against the CheckM2 database (or reuse a previous result) 

422 and parse its results. 

423 

424 :param faa_file: Path to the protein file. 

425 :param contigs_fasta: Path to the contigs FASTA file. 

426 :param contigs_in_bins: Set of contigs in bins. 

427 :param diamond_result_file: Path of the DIAMOND result file. 

428 :param diamond_db_path: Path of the CheckM2 diamond database. 

429 :param threads: Number of threads. 

430 :param low_mem: Use DIAMOND low memory mode. 

431 :param reuse: Reuse the result file of a previous run instead of running DIAMOND. 

432 

433 :return: Mapping of contig name to a counter of KEGG annotations. 

434 """ 

435 if not reuse: 

436 diamond_log = ( 

437 diamond_result_file.parents[0] 

438 / f"{diamond_result_file.stem.split('.')[0]}.log" 

439 ) 

440 

441 diamond.run( 

442 faa_file.as_posix(), 

443 diamond_result_file.as_posix(), 

444 diamond_db_path.as_posix(), 

445 diamond_log.as_posix(), 

446 threads, 

447 low_mem=low_mem, 

448 ) 

449 

450 logger.info("Parsing diamond results") 

451 contig_to_kegg_counter = diamond.get_contig_to_kegg_id( 

452 diamond_result_file.as_posix() 

453 ) 

454 

455 # Check contigs from diamond vs input assembly consistency 

456 io.check_contig_consistency( 

457 contigs_in_bins, 

458 contig_to_kegg_counter, 

459 contigs_fasta.as_posix(), 

460 diamond_result_file.as_posix(), 

461 ) 

462 

463 return contig_to_kegg_counter 

464 

465 

466def annotate_contigs( 

467 config: RunConfig, 

468 paths: OutputPaths, 

469 inputs: InputData, 

470 ckpt: checkpoint.Checkpoint, 

471 run_inputs: dict[str, Any], 

472 diamond_db_path: Path, 

473) -> tuple[dict, dict[int, int | None] | None, dict]: 

474 """ 

475 Get proteins and DIAMOND hits (computed or reused from a previous run) and build 

476 the contig metadata used to assess bin quality. 

477 

478 :return: contig metadata, contig coding lengths (None when using user-provided 

479 proteins), both indexed by contig index, and the inputs of the DIAMOND step. 

480 """ 

481 contigs_in_bins = set(inputs.contigs_in_bins) 

482 

483 # Proteins # 

484 proteins_step_inputs = { 

485 "contigs": run_inputs["contigs"], 

486 "proteins": run_inputs["proteins"], 

487 } 

488 reuse_proteins = ckpt.can_reuse( 

489 "proteins", proteins_step_inputs, config.resume, "protein sequences" 

490 ) 

491 if not reuse_proteins: 

492 ckpt.invalidate("proteins", "diamond") 

493 

494 contig_name_to_genes, contig_to_coding_length, protein_outputs = get_proteins( 

495 faa_file=paths.faa_file, 

496 coding_length_file=paths.coding_length_file, 

497 contigs_fasta=config.contigs, 

498 contigs_in_bins=contigs_in_bins, 

499 proteins=config.proteins, 

500 threads=config.threads, 

501 reuse=reuse_proteins, 

502 ) 

503 if not reuse_proteins: 

504 ckpt.record_step("proteins", proteins_step_inputs, protein_outputs) 

505 

506 # DIAMOND # 

507 diamond_step_inputs = make_diamond_step_inputs( 

508 ckpt, paths.faa_file, run_inputs["checkm2_db"], config.low_mem 

509 ) 

510 reuse_diamond = ckpt.can_reuse( 

511 "diamond", diamond_step_inputs, config.resume, "DIAMOND results" 

512 ) 

513 if not reuse_diamond: 

514 ckpt.invalidate("diamond") 

515 

516 contig_name_to_kegg_counter = get_diamond_hits( 

517 faa_file=paths.faa_file, 

518 contigs_fasta=config.contigs, 

519 contigs_in_bins=contigs_in_bins, 

520 diamond_result_file=paths.diamond_result_file, 

521 diamond_db_path=diamond_db_path, 

522 threads=config.threads, 

523 low_mem=config.low_mem, 

524 reuse=reuse_diamond, 

525 ) 

526 if not reuse_diamond: 

527 ckpt.record_step("diamond", diamond_step_inputs, [paths.diamond_result_file]) 

528 

529 # Contig metadata # 

530 contig_to_index = inputs.contig_to_index 

531 contig_to_kegg_counter = contig_manager.apply_contig_index( 

532 contig_to_index, contig_name_to_kegg_counter 

533 ) 

534 contig_to_genes = contig_manager.apply_contig_index( 

535 contig_to_index, contig_name_to_genes 

536 ) 

537 if contig_to_coding_length: 

538 contig_to_coding_length = contig_manager.apply_contig_index( 

539 contig_to_index, contig_to_coding_length 

540 ) 

541 

542 logger.info("Computing CDS metadata") 

543 contig_metadata = cds.get_contig_cds_metadata(contig_to_genes, config.threads) 

544 contig_metadata["contig_to_kegg_counter"] = contig_to_kegg_counter 

545 contig_metadata["contig_to_length"] = inputs.contig_to_length 

546 

547 return contig_metadata, contig_to_coding_length, diamond_step_inputs 

548 

549 

550# Bins # 

551 

552 

553def assess_input_bins( 

554 config: RunConfig, 

555 paths: OutputPaths, 

556 inputs: InputData, 

557 contig_metadata: dict, 

558 contig_to_coding_length: dict[int, int | None] | None, 

559) -> dict[Any, Bin]: 

560 """ 

561 Assess quality of the input bins and write their metrics. 

562 

563 :return: Mapping of contig key to input bins with quality metrics. 

564 """ 

565 logger.info("Adding size and assessing quality of input bins") 

566 original_bins = bin_quality.add_bin_metrics( 

567 list(inputs.contig_key_to_original_bin.values()), 

568 contig_metadata, 

569 config.contamination_weight, 

570 config.threads, 

571 disable_progress_bar=not config.show_progress, 

572 ) 

573 

574 bin_quality.add_bin_size_and_N50(original_bins, inputs.contig_to_length) 

575 

576 if contig_to_coding_length: 

577 bin_quality.add_bin_coding_density(original_bins, contig_to_coding_length) 

578 

579 io.clear_previous_outputs(paths.final_bins_dir, paths.original_bin_report_dir) 

580 

581 logger.info( 

582 f"Writing original input bin metrics to directory '{paths.original_bin_report_dir}'" 

583 ) 

584 io.write_original_bin_metrics(original_bins, paths.original_bin_report_dir) 

585 

586 return {b.contigs_key: b for b in original_bins} 

587 

588 

589def create_and_assess_intermediate_bins( 

590 config: RunConfig, 

591 paths: OutputPaths, 

592 inputs: InputData, 

593 contig_key_to_original_bin: dict[Any, Bin], 

594 contig_metadata: dict, 

595) -> dict[Any, Bin]: 

596 """ 

597 Create intermediate bins from the input bins and assess their quality. 

598 

599 :return: Mapping of contig key to all bins (input and intermediate). 

600 """ 

601 logger.info("Creating intermediate bins") 

602 

603 contig_lengths = bin_quality.prepare_contig_sizes(inputs.contig_to_length) 

604 

605 contig_key_to_new_bin = bin_manager.create_intermediate_bins( 

606 contig_key_to_original_bin, 

607 contig_lengths=contig_lengths, 

608 min_comp=config.min_completeness, 

609 max_conta=config.max_contamination, 

610 min_len=config.min_length, 

611 max_len=config.max_length, 

612 disable_progress_bar=not config.show_progress, 

613 ) 

614 

615 logger.info(f"Assessing quality for {len(contig_key_to_new_bin)} intermediate bins") 

616 

617 new_bins = bin_quality.add_bin_metrics( 

618 bins=contig_key_to_new_bin.values(), 

619 contig_info=contig_metadata, 

620 contamination_weight=config.contamination_weight, 

621 threads=config.threads, 

622 disable_progress_bar=not config.show_progress, 

623 ) 

624 contig_key_to_new_bin = {b.contigs_key: b for b in new_bins} 

625 

626 contig_key_to_all_bin = contig_key_to_original_bin | contig_key_to_new_bin 

627 

628 bin_quality.add_bin_size_and_N50( 

629 contig_key_to_all_bin.values(), inputs.contig_to_length 

630 ) 

631 

632 if config.debug: 

633 logger.info(f"Writing all bins to '{paths.all_bin_compo_file}'") 

634 io.write_bin_info( 

635 contig_key_to_all_bin.values(), paths.all_bin_compo_file, add_contigs=True 

636 ) 

637 

638 return contig_key_to_all_bin 

639 

640 

641def select_bins( 

642 config: RunConfig, 

643 contig_key_to_all_bin: dict[Any, Bin], 

644 contig_to_coding_length: dict[int, int | None] | None, 

645) -> list[Bin]: 

646 """Select the best non-overlapping bins.""" 

647 selected_bins = bin_manager.select_best_bins( 

648 contig_key_to_all_bin, 

649 min_completeness=config.min_completeness, 

650 max_contamination=config.max_contamination, 

651 prefix=config.prefix, 

652 ) 

653 

654 if contig_to_coding_length: 

655 bin_quality.add_bin_coding_density(selected_bins, contig_to_coding_length) 

656 

657 return selected_bins 

658 

659 

660def write_final_outputs( 

661 config: RunConfig, 

662 paths: OutputPaths, 

663 inputs: InputData, 

664 selected_bins: list[Bin], 

665 ckpt: checkpoint.Checkpoint, 

666 final_inputs: dict, 

667) -> None: 

668 """Write the final results and record them in the checkpoint.""" 

669 logger.info(f"Writing selected bins information to '{paths.final_bin_report}'") 

670 io.write_bin_info(selected_bins, output=paths.final_bin_report) 

671 

672 io.write_contig2bin_table( 

673 selected_bins, 

674 paths.final_contig2bin_table, 

675 inputs.contigs_in_bins, 

676 ) 

677 

678 if config.write_fasta_bins: 

679 logger.info(f"Writing selected bins FASTA files to '{paths.final_bins_dir}'") 

680 io.write_bins_fasta( 

681 selected_bins, 

682 config.contigs, 

683 outdir=paths.final_bins_dir, 

684 contigs_names=inputs.contigs_in_bins, 

685 ) 

686 

687 bin_quality.log_selected_bin_info( 

688 selected_bins, HQ_MIN_COMPLETENESS, HQ_MAX_CONTAMINATION 

689 ) 

690 

691 final_outputs = [ 

692 paths.final_bin_report, 

693 paths.final_contig2bin_table, 

694 *sorted(paths.original_bin_report_dir.glob("input_bins_*.tsv")), 

695 ] 

696 if config.debug: 

697 final_outputs += [paths.index_to_contig_file, paths.all_bin_compo_file] 

698 ckpt.record_step("final", final_inputs, final_outputs) 

699 

700 if config.write_fasta_bins: 

701 record_bins_fasta_step(ckpt, paths.final_contig2bin_table, paths.final_bins_dir)