Coverage for binette/pipeline.py: 100%
202 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-17 13:33 +0000
« 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"""
8import hashlib
9import logging
10from collections import Counter
11from dataclasses import dataclass
12from pathlib import Path
13from typing import Any
15import pyfastx
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
23logger = logging.getLogger(__name__)
25# High quality thresholds, only used to log the number of high quality bins.
26HQ_MIN_COMPLETENESS = 90
27HQ_MAX_CONTAMINATION = 5
30@dataclass
31class InputData:
32 """Bins and contigs parsed from the input files."""
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]
41def run(config: RunConfig) -> int:
42 """
43 Run Binette.
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)
52 inputs = parse_input_files(
53 config.bin_dirs,
54 config.contig2bin_tables,
55 config.contigs,
56 fasta_extensions=set(config.fasta_extensions),
57 )
59 diamond_db_path = diamond.resolve_checkm2_db(config.checkm2_db)
60 run_inputs = make_run_inputs(config, inputs, diamond_db_path)
62 ckpt = checkpoint.check_outdir(
63 config.outdir, paths.manifest, run_inputs, config.force
64 )
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 )
71 if is_already_completed(config, paths, ckpt, run_inputs):
72 return 0
74 # Results of this run will be rewritten: they no longer reflect a completed run.
75 ckpt.invalidate("final", "bins_fasta")
77 if config.debug:
78 write_index_to_contig(inputs.contigs_in_bins, paths.index_to_contig_file)
80 contig_metadata, contig_to_coding_length, diamond_step_inputs = annotate_contigs(
81 config, paths, inputs, ckpt, run_inputs, diamond_db_path
82 )
84 contig_key_to_original_bin = assess_input_bins(
85 config, paths, inputs, contig_metadata, contig_to_coding_length
86 )
88 contig_key_to_all_bin = create_and_assess_intermediate_bins(
89 config, paths, inputs, contig_key_to_original_bin, contig_metadata
90 )
92 selected_bins = select_bins(config, contig_key_to_all_bin, contig_to_coding_length)
94 write_final_outputs(
95 config,
96 paths,
97 inputs,
98 selected_bins,
99 ckpt,
100 final_step_inputs(config, diamond_step_inputs),
101 )
103 return 0
106# Inputs #
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.
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.
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"}
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 )
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")
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")
151 contig_to_index = contig_manager.make_contig_index(contigs_in_bins)
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 )
157 logger.info(
158 f"Parsing contig fasta file '{contigs_fasta}' to retrieve contig lengths"
159 )
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()
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 }
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")
185 contig_id_to_length = {
186 contig_to_index[name]: length for name, length in contig_to_length.items()
187 }
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 )
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))))
208# Checkpoint steps #
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 }
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 }
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 }
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)}
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 )
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.
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
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)
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
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
336# Proteins and DIAMOND #
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.
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.
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 )
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
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)
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]
407 return contig_to_genes, contig_to_coding_len, outputs
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.
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.
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 )
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 )
450 logger.info("Parsing diamond results")
451 contig_to_kegg_counter = diamond.get_contig_to_kegg_id(
452 diamond_result_file.as_posix()
453 )
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 )
463 return contig_to_kegg_counter
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.
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)
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")
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)
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")
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])
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 )
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
547 return contig_metadata, contig_to_coding_length, diamond_step_inputs
550# Bins #
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.
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 )
574 bin_quality.add_bin_size_and_N50(original_bins, inputs.contig_to_length)
576 if contig_to_coding_length:
577 bin_quality.add_bin_coding_density(original_bins, contig_to_coding_length)
579 io.clear_previous_outputs(paths.final_bins_dir, paths.original_bin_report_dir)
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)
586 return {b.contigs_key: b for b in original_bins}
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.
599 :return: Mapping of contig key to all bins (input and intermediate).
600 """
601 logger.info("Creating intermediate bins")
603 contig_lengths = bin_quality.prepare_contig_sizes(inputs.contig_to_length)
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 )
615 logger.info(f"Assessing quality for {len(contig_key_to_new_bin)} intermediate bins")
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}
626 contig_key_to_all_bin = contig_key_to_original_bin | contig_key_to_new_bin
628 bin_quality.add_bin_size_and_N50(
629 contig_key_to_all_bin.values(), inputs.contig_to_length
630 )
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 )
638 return contig_key_to_all_bin
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 )
654 if contig_to_coding_length:
655 bin_quality.add_bin_coding_density(selected_bins, contig_to_coding_length)
657 return selected_bins
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)
672 io.write_contig2bin_table(
673 selected_bins,
674 paths.final_contig2bin_table,
675 inputs.contigs_in_bins,
676 )
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 )
687 bin_quality.log_selected_bin_info(
688 selected_bins, HQ_MIN_COMPLETENESS, HQ_MAX_CONTAMINATION
689 )
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)
700 if config.write_fasta_bins:
701 record_bins_fasta_step(ckpt, paths.final_contig2bin_table, paths.final_bins_dir)