Oncodrive3D 1.0.4__py3-none-any.whl

scripts/datasets/af_merge.py

@@ -0,0 +1,344 @@
+"""
+Module to merge overlapping fragments produced by AlphaFold 2
+for the predictions of proteins larger than 2700 amino acids.
+
+The module uses an adapted version of the code written by the
+authors of DEGRONOPEDIA (Natalia A. Szulc, nszulc@iimcb.gov.pl).
+DEGRONOPEDIA - a web server for proteome-wide inspection of degrons
+doi: 10.1101/2022.05.19.492622.
+"""
+
+import gzip
+import logging
+import os
+import re
+import shutil
+import subprocess
+from os import sep
+
+import daiquiri
+import pandas as pd
+from Bio.PDB import PDBExceptions, PDBParser, Structure, Superimposer
+from Bio.PDB.PDBIO import PDBIO
+from tqdm import tqdm
+
+from scripts import __logger_name__
+
+logger = daiquiri.getLogger(__logger_name__ + ".build.af_merge")
+
+daiquiri.getLogger('py.warnings').setLevel(logging.ERROR)
+
+
+## DEGRONOPEDIA script
+
+def degronopedia_af_merge(struct_name, input_path, afold_version, output_path, zip):
+    """
+    DEGRONOPEDIA script to merge any AlphaFold fragments into a unique structure.
+
+    DEGRONOPEDIA - a web server for proteome-wide inspection of degrons
+    doi: 10.1101/2022.05.19.492622
+    https://degronopedia.com/degronopedia/about
+    """
+
+    ###  ARGUMENTS PARSING  ###
+
+    if input_path[-1] == sep:
+        input_path = input_path[:-1]
+
+    if output_path:
+        if output_path[-1] == sep:
+            output_path = output_path[:-1]
+        save_path = output_path
+    else:
+        save_path = input_path
+
+    ### FIND OUT HOW MANY PIECES ###
+
+    how_many_pieces = 0
+    if zip:
+        onlyfiles = [f for f in os.listdir(input_path) if f.endswith(".pdb.gz") and os.path.isfile(os.path.join(input_path, f))]
+    else:
+        onlyfiles = [f for f in os.listdir(input_path) if f.endswith(".pdb") and os.path.isfile(os.path.join(input_path, f))]
+
+    for f in onlyfiles:
+        if struct_name in f and f[0] != '.': # do not include hidden files
+            how_many_pieces += 1
+
+    ### MERGING ###
+
+    Bio_parser = PDBParser()
+    c = 1
+    while c < how_many_pieces :
+
+        struct_save_path = os.path.join(save_path, f"AF-{struct_name}-FM-model_v{afold_version}.pdb")
+
+        # Read reference structure
+        if c == 1:
+            struct_ref_path = os.path.join(input_path, f"AF-{struct_name}-F{c}-model_v{afold_version}.pdb")
+            if zip:
+                with gzip.open(f'{struct_ref_path}.gz', 'rt') as handle:
+                    struct_ref = Bio_parser.get_structure("ref", handle)
+            else:
+                with open(struct_ref_path, 'r') as handle:
+                    struct_ref = Bio_parser.get_structure("ref", handle)
+        else:
+            struct_ref = Bio_parser.get_structure("ref", struct_save_path)
+        model_ref = struct_ref[0]
+
+        # Read structure to superimpose
+        struct_si_path = os.path.join(input_path, f"AF-{struct_name}-F{c+1}-model_v{afold_version}.pdb")
+        if zip:
+            with gzip.open(f'{struct_si_path}.gz', 'rt') as handle:
+                structure_to_superpose = Bio_parser.get_structure("ref", handle)
+        else:
+            with open(struct_si_path, 'r') as handle:
+                structure_to_superpose = Bio_parser.get_structure("ref", handle)
+        model_to_super = structure_to_superpose[0]
+
+        # Append atoms from the nine last residues except for the very last one (it is C-end, has one more atom more)
+        model_ref_atoms = []
+        for j in range(len(model_ref['A'])-9, len(model_ref['A'])):
+            for atom in model_ref['A'][j]:
+                model_ref_atoms.append(atom)
+
+        # Append atoms from the 1191-1999 residues which correspond the abovementioned residues from the reference
+        model_to_superpose_atoms = []
+        for j in range(1191, 1200):
+            for atom in model_to_super['A'][j]:
+                model_to_superpose_atoms.append(atom)
+
+        # Superimpose
+        sup = Superimposer()
+        sup.set_atoms(model_ref_atoms, model_to_superpose_atoms)
+
+        # Update coords of the residues from the structure to be superimposed
+        sup.apply(model_to_super.get_atoms())
+
+        # Delete last residue (C-end residue, with one atom more) from the reference structure
+        model_ref['A'].detach_child((' ', len(model_ref['A']), ' '))
+
+        # Delete first 1199 residues from the superimposed structure
+        for i in range(1, 1200):
+            model_to_super['A'].detach_child((' ', i, ' '))
+
+        # Renumber residues in the superimposed structure
+        # Do it twice as you cannot assign a number to a residue that another residue already has
+        tmp_resnums = [i+1 for i in range(len(model_to_super['A']))]
+
+        for i, residue in enumerate(model_to_super['A'].get_residues()):
+            res_id = list(residue.id)
+            res_id[1] = tmp_resnums[i]
+            residue.id = tuple(res_id)
+
+        new_resnums = [i+len(model_ref['A'])+1 for i in range(len(model_to_super['A']))]
+
+        for i, residue in enumerate(model_to_super['A'].get_residues()):
+            res_id = list(residue.id)
+            res_id[1] = new_resnums[i]
+            residue.id = tuple(res_id)
+
+        # Merge and save both structures however as two models
+        merged = Structure.Structure("master")
+        merged.add(model_ref)
+        model_to_super.id='B'
+        merged.add(model_to_super)
+
+        io = PDBIO()
+        io.set_structure(merged)
+        io.save(struct_save_path)
+
+        # Unify models
+        bashCommand1 = os.path.join("sed '", "TER", f"d' {save_path}", f"AF-{struct_name}-FM-model_v{afold_version}.pdb > {save_path}", "tmp.pdb")
+        bashCommand2 = os.path.join("sed '", "MODEL", f"d' {save_path}", f"tmp.pdb > {save_path}", "tmp1.pdb")
+        bashCommand3 = os.path.join("sed '", "ENDMDL", f"d' {save_path}", f"tmp1.pdb > {save_path}", "tmp2.pdb")
+
+        subprocess.run(bashCommand1, check=True, text=True, shell=True)
+        subprocess.run(bashCommand2, check=True, text=True, shell=True)
+        subprocess.run(bashCommand3, check=True, text=True, shell=True)
+
+        # Re-read the structure in Biopython and save
+        structure_ok = Bio_parser.get_structure("ok", os.path.join(save_path, "tmp2.pdb"))
+        io.set_structure(structure_ok)
+        io.save(struct_save_path)
+
+        c += 1
+
+    # Add MODEL 1 at the beggining of the file
+    bashCommand4 = os.path.join(f"sed -i '1iMODEL        1                                                                  ' {save_path}", f"AF-{struct_name}-FM-model_v{afold_version}.pdb")
+    subprocess.run(bashCommand4, check=True, shell=True)
+
+    # Provide proper file ending
+    bashCommand5 = os.path.join(f"sed -i '$ d' {save_path}", f"AF-{struct_name}-FM-model_v{afold_version}.pdb")
+    bashCommand6 = os.path.join(f"echo 'ENDMDL                                                                          ' >> {save_path}", f"AF-{struct_name}-FM-model_v{afold_version}.pdb")
+    bashCommand7 = os.path.join(f"echo 'END                                                                             ' >> {save_path}", f"AF-{struct_name}-FM-model_v{afold_version}.pdb")
+    subprocess.run(bashCommand5, check=True, shell=True)
+    subprocess.run(bashCommand6, check=True, text=True, shell=True)
+    subprocess.run(bashCommand7, check=True, text=True, shell=True)
+
+    # Delete tmp files
+    bashCommand8 = os.path.join(f"rm {save_path}", f"tmp.pdb {save_path}", f"tmp1.pdb {save_path}", "tmp2.pdb")
+    subprocess.run(bashCommand8, check=True, text=True, shell=True)
+
+
+## In-house scripts
+
+# Add SEQREF record to pdb file
+
+def get_res_from_chain(pdb_path):
+    """
+    Get sequense of amino acid residues from the structure chain.
+    """
+
+    # Load structure
+    parser = PDBParser()
+    structure = parser.get_structure("ID", pdb_path)
+
+    # Get seq from chain
+    residues = []
+    chain = structure[0]["A"]
+    for residue in chain.get_residues():
+        residues.append(residue.resname)
+
+    return residues
+
+
+def get_pdb_seqres_records(lst_res):
+    """
+    Construct the fixed-width records of a pdb file.
+    """
+
+    records = []
+    num_residues = len(lst_res)
+    record_counter = 0
+    while record_counter * 13 < num_residues:
+        start_idx = record_counter * 13
+        end_idx = min(start_idx + 13, num_residues)
+        residue_subset = lst_res[start_idx:end_idx]
+        record = 'SEQRES {:>3} {} {:>4}  {:52}\n'.format(record_counter+1, "A", num_residues, ' '.join(residue_subset))
+        records.append(record)
+        record_counter += 1
+
+    return records
+
+
+def add_refseq_record_to_pdb(path_structure):
+    """
+    Add the SEQREF records to the pdb file.
+    """
+
+    # Open the PDB file and get SEQRES insert index
+    with open(path_structure, 'r') as file:
+        pdb_lines = file.readlines()
+        insert_index = next(i for i, line in enumerate(pdb_lines) if line.startswith('MODEL'))
+
+    # Get seares records
+    residues = get_res_from_chain(path_structure)
+    seqres_records = get_pdb_seqres_records(residues)
+
+    # Insert the SEQRES records
+    pdb_lines[insert_index:insert_index] = seqres_records
+
+    # Save
+    with open(path_structure, 'w') as output_file:
+        output_file.truncate()
+        output_file.writelines(pdb_lines)
+
+
+# Other functions
+
+def get_list_fragmented_pdb(pdb_dir):
+    """
+    Given a directory including pdb files, return a list of tuples (Uniprot_ID, max AF_F).
+    """
+
+    # List pdb files
+    list_pdb = os.listdir(pdb_dir)
+    list_pdb = [file for file in list_pdb if not file.startswith("tmp") and file.endswith(".pdb") or file.endswith(".pdb.gz")]
+    list_pdb = [(file.split("-")[1], re.sub(r"\D", "", file.split("-")[2])) for file in list_pdb if file.split("-")[2][-1] != "M"]
+
+    # Get df with max fragment
+    df = pd.DataFrame(list_pdb, columns=["Uniprot_ID", "F"])
+    df["F"] = pd.to_numeric(df["F"])
+    df = df.groupby("Uniprot_ID").max()
+
+    # Get fragmented structures as list of (Uniprot_ID AF_F) tuples
+    df = df[df["F"] > 1].reset_index()
+
+    return list(df.to_records(index=False))
+
+
+def save_unprocessed_ids(uni_ids, filename):
+
+    with open(filename, 'a') as file:
+        for id in uni_ids:
+            file.write(id + '\n')
+
+
+# Wrapper function
+
+def merge_af_fragments(input_dir, output_dir=None, af_version=4, gzip=False):
+    """
+    Run and parse DEGRONOPEDIA script to merge any AlphaFold fragments into a unique structure.
+
+    DEGRONOPEDIA - a web server for proteome-wide inspection of degrons
+    doi: 10.1101/2022.05.19.492622
+    https://degronopedia.com/degronopedia/about
+    """
+
+    if output_dir is None:
+        output_dir = input_dir
+    if gzip:
+        zip_ext = ".gz"
+    else:
+        zip_ext = ""
+
+    fragments = get_list_fragmented_pdb(input_dir)
+    if len(fragments) > 0:
+
+        # Create dir where to move original fragmented structures
+        path_original_frag = os.path.join(output_dir, "fragmented_pdbs")
+        if not os.path.exists(path_original_frag):
+            os.makedirs(path_original_frag)
+        checkpoint = os.path.join(path_original_frag, '.checkpoint.merge.txt')
+
+        if os.path.exists(checkpoint):
+            logger.debug("Merge fragments already performed: Skipping...")
+        else:
+            # Get list of fragmented Uniprot ID and max AF-F
+            not_processed = []
+            for uni_id, max_f in tqdm(fragments, total=len(fragments), desc="Merging AF fragments"):
+
+                processed = False
+
+                try:
+                    degronopedia_af_merge(uni_id, input_dir, af_version, output_dir, gzip)
+                    processed = True
+                except (PDBExceptions.PDBIOException, PDBExceptions.PDBConstructionException):
+                    logger.warning(f"Could not process {uni_id} ({max_f} fragments)")
+                    not_processed.append(uni_id)
+                    f_path = os.path.join(output_dir, f"AF-{uni_id}-FM-model_v{af_version}.pdb")
+                    if os.path.exists(f_path):
+                        os.remove(f_path)
+                # Move the original fragmented structures
+                for f in range(1, max_f+1):
+                    file = f"AF-{uni_id}-F{f}-model_v{af_version}.pdb{zip_ext}"
+                    shutil.move(os.path.join(input_dir, file), path_original_frag)
+
+                # Rename merged structure and add refseq records to pdb
+                if processed:
+                    tmp_name = os.path.join(output_dir, f"AF-{uni_id}-FM-model_v{af_version}.pdb")
+                    name = os.path.join(output_dir, f"AF-{uni_id}-F{max_f}M-model_v{af_version}.pdb")
+                    os.rename(tmp_name, name)
+                    add_refseq_record_to_pdb(name)
+
+            if len(not_processed) > 0:
+                logger.warning(f"Not processed: {not_processed}")
+            with open(checkpoint, "w") as f:
+                f.write('')
+
+            save_unprocessed_ids(not_processed,
+                                os.path.join(output_dir, "fragmented_pdbs", "ids_not_merged.txt"))
+            logger.info("Merge of structures completed!")
+
+    else:
+        logger.debug("Nothing to merge: Skipping...")

scripts/datasets/build_datasets.py

@@ -0,0 +1,125 @@
+"""
+Module to generate datasets necessary to run Oncodrive3D.
+
+The build is a pipeline that perform the following tasks:
+    - Download the PDB structures of the selected proteome
+      predicted by AlphaFold 2 from AlphaFold DB.
+    - Merge the overlapping structures processed as fragments.
+    - Extract AlphaFold model confidence (pLDDT).
+    - Generate a dataframe including Uniprot_ID, HUGO Symbol,
+      protein, DNA sequence, and other gene's information.
+    - Download AlphaFold predicted aligned error (PAE) from
+      AlphaFold DB and convert the files into npy format.
+    - Use the PDB structure and PAE to create maps of
+      probability of contacts (pCMAPs) for any protein of the
+      downloaded proteome with available PAE.
+    - Remove unnecessary temp files.
+"""
+
+
+import os
+
+import daiquiri
+
+from scripts import __logger_name__
+from scripts.datasets.af_merge import merge_af_fragments
+from scripts.datasets.get_pae import get_pae
+from scripts.datasets.get_structures import get_structures, mv_mane_pdb
+from scripts.datasets.model_confidence import get_confidence
+from scripts.datasets.parse_pae import parse_pae
+from scripts.datasets.prob_contact_maps import get_prob_cmaps_mp
+from scripts.datasets.seq_for_mut_prob import get_seq_df
+from scripts.datasets.utils import get_species
+from scripts.globals import clean_dir, clean_temp_files
+
+logger = daiquiri.getLogger(__logger_name__ + ".build")
+
+def build(output_datasets,
+          organism,
+          mane,
+          distance_threshold,
+          num_cores,
+          af_version,
+          mane_version):
+    """
+    Build datasets necessary to run Oncodrive3D.
+    """
+
+    # Empty directory
+    clean_dir(output_datasets, 'd', txt_file=True)
+
+    # Download PDB structures
+    species = get_species(organism)
+    logger.info("Downloading AlphaFold (AF) predicted structures...")
+    get_structures(path=os.path.join(output_datasets,"pdb_structures"),
+                   species=species,
+                   af_version=str(af_version),
+                   threads=num_cores)
+    logger.info("Download of structures completed!")
+
+    # Merge fragmented structures
+    logger.info("Merging fragmented structures...")
+    merge_af_fragments(input_dir=os.path.join(output_datasets,"pdb_structures"),
+                       gzip=True)
+
+    # Download PDB MANE structures
+    if species == "Homo sapiens" and mane == True:
+        logger.info("Downloading AlphaFold (AF) predicted structures overlap with MANE...")
+        get_structures(path=os.path.join(output_datasets,"pdb_structures_mane"),
+                      species=species,
+                      mane=True,
+                      threads=num_cores)
+        mv_mane_pdb(output_datasets, "pdb_structures", "pdb_structures_mane")
+        logger.info("Download of MANE structures completed!")
+
+    # Create df including genes and proteins sequences & Hugo to Uniprot_ID mapping
+    logger.info("Generating dataframe for genes and proteins sequences...")
+    seq_df = get_seq_df(datasets_dir=output_datasets,
+                        output_seq_df=os.path.join(output_datasets, "seq_for_mut_prob.tsv"),
+                        organism=species,
+                        mane=mane,
+                        num_cores=num_cores,
+                        mane_version=mane_version)
+    logger.info("Generation of sequences dataframe completed!")
+
+    # Get model confidence
+    logger.info("Extracting AF model confidence...")
+    get_confidence(input=os.path.join(output_datasets, "pdb_structures"),
+                   output_dir=os.path.join(output_datasets),
+                   seq_df=seq_df)
+
+    # Get PAE
+    logger.info("Downloading AF predicted aligned error (PAE)...")
+    get_pae(input_dir=os.path.join(output_datasets,"pdb_structures"),
+            output_dir=os.path.join(output_datasets,"pae"),
+            num_cores=num_cores,
+            af_version=str(af_version))
+
+    # Parse PAE
+    logger.info("Parsing PAE...")
+    parse_pae(input=os.path.join(output_datasets, 'pae'))
+    logger.info("Parsing PAE completed!")
+
+    # Get pCAMPs
+    logger.info("Generating contact probability maps (pCMAPs)..")
+    get_prob_cmaps_mp(input_pdb=os.path.join(output_datasets, "pdb_structures"),
+                      input_pae=os.path.join(output_datasets, "pae"),
+                      output=os.path.join(output_datasets,"prob_cmaps"),
+                      distance=distance_threshold,
+                      num_cores=num_cores)
+    logger.info("Generation pCMAPs completed!")
+
+    # Clean datasets
+    logger.info("Cleaning datasets...")
+    clean_temp_files(path=output_datasets)
+    logger.info("Datasets cleaning completed!")
+    logger.info("Datasets have been successfully built and are ready for analysis!")
+
+if __name__ == "__main__":
+    build(output_datasets="/workspace/nobackup/scratch/oncodrive3d/datasets_mane",
+        organism="Homo sapiens",
+        mane=True,
+        distance_threshold=10,
+        num_cores=8,
+        af_version=4,
+        mane_version=1.3)

scripts/datasets/get_pae.py

@@ -0,0 +1,78 @@
+import os
+
+import daiquiri
+import requests
+import time
+import concurrent.futures
+from tqdm import tqdm
+
+from scripts import __logger_name__
+
+logger = daiquiri.getLogger(__logger_name__ + ".build.PAE")
+
+
+def download_pae(uniprot_id: str, af_version: int, output_dir: str) -> None:
+    """
+    Download Predicted Aligned Error (PAE) file from AlphaFold DB.
+
+    Args:
+        uniprot_id (str): Uniprot ID of the structure.
+        af_version (int): AlphaFold 2 version.
+        output_dir (str): Output directory where to download the PAE files.
+    """
+
+    file_path = os.path.join(output_dir, f"{uniprot_id}-F1-predicted_aligned_error.json")
+    download_url = f"https://alphafold.ebi.ac.uk/files/AF-{uniprot_id}-F1-predicted_aligned_error_v{af_version}.json"
+
+    i = 0
+    status = "INIT"
+    while status != "FINISHED":
+        i += 1
+        if status != "INIT":
+            time.sleep(30)
+        try:
+            response = requests.get(download_url, timeout=30)
+            content = response.content
+            if content.endswith(b'}]') and not content.endswith(b'</Error>'):
+                with open(file_path, 'wb') as output_file:
+                    output_file.write(content)
+                status = "FINISHED"
+        except requests.exceptions.RequestException as e:
+            status = "ERROR"
+            if i % 10 == 0:
+                logger.debug(f"Request failed {e}: Retrying")
+
+
+def get_pae(input_dir: str, output_dir: str, num_cores: int, af_version: int = 4) -> None:
+    """
+    Download Predicted Aligned Error (PAE) files for all non-fragmented PDB
+    structures in the input directory.
+
+    Args:
+        input_dir (str): Input directory including the PDB structures.
+        output_dir (str): Output directory where to download the PAE files.
+        num_cores (int): Number of cores for multithreading download.
+        af_version (int): AlphaFold 2 version (default is 4).
+    """
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    checkpoint = os.path.join(output_dir, '.checkpoint.txt')
+    if os.path.exists(checkpoint):
+        logger.debug("PAE already downloaded: Skipping...")
+        return
+
+    pdb_files = [file for file in os.listdir(input_dir) if file.startswith("AF-") and file.endswith(f"-model_v{af_version}.pdb.gz")]
+    uniprot_ids = [pdb_file.split("-")[1] for pdb_file in pdb_files]
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=num_cores) as executor:
+        tasks = [executor.submit(download_pae, uniprot_id, af_version, output_dir) for uniprot_id in uniprot_ids]
+
+        for _ in tqdm(concurrent.futures.as_completed(tasks), total=len(tasks), desc="Downloading PAE"):
+            pass
+
+    with open(checkpoint, "w") as f:
+        f.write('')
+
+    logger.info('Download of PAE completed!')

scripts/datasets/get_structures.py

@@ -0,0 +1,107 @@
+import logging
+import os
+
+import daiquiri
+import time
+import subprocess
+import shutil
+
+from scripts import __logger_name__
+from scripts.datasets.utils import calculate_hash, download_single_file, extract_tar_file, assert_proteome_integrity, CHECKSUM
+
+logger = daiquiri.getLogger(__logger_name__ + ".build.AF-pdb")
+
+logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
+
+
+def mv_mane_pdb(path_datasets, pdb_dir, mane_pdb_dir) -> None:
+    """
+    Move AF structures with overlap with MANE Select
+    transcripts to directory with AF structures from
+    human proteome. Overwrite any overlapping AF ID.
+    """
+
+    path_pdb = os.path.join(path_datasets, pdb_dir)
+    path_mane_pdb = os.path.join(path_datasets, mane_pdb_dir)
+    if not os.path.exists(path_mane_pdb):
+        os.makedirs(path_mane_pdb)
+
+    # Move MANE structures
+    for filename in [file for file in os.listdir(path_mane_pdb) if file.endswith(".pdb.gz") or file.endswith(".pdb")]:
+        pdb = os.path.join(path_pdb, filename)
+        pdb_mane = os.path.join(path_mane_pdb, filename)
+        shutil.move(pdb_mane, pdb)
+
+    # Move MANE metadata files
+    for filename in [file for file in os.listdir(os.path.join(path_mane_pdb)) if file.endswith(".csv") or file.endswith("readme.txt")]:
+        source_file = os.path.join(path_mane_pdb, filename)
+        dest_file = os.path.join(path_datasets, f"mane_{filename}")
+        shutil.move(source_file, dest_file)
+
+
+def get_structures(path: str,
+                   species: str = 'Homo sapiens',
+                   mane: bool = False,
+                   af_version: str = '4',
+                   threads: int = 1,
+                   max_attempts: int = 30) -> None:
+    """
+    Downloads AlphaFold predicted structures for a given organism and version.
+
+    Args:
+        path (str): Path where to save PDB structures.
+        species (str, optional): Species (human (default) or mouse). Defaults to 'human'.
+        af_version (str, optional): AlphaFold 2 version (4 as default). Defaults to '4'.
+        verbose (str, optional): Verbose (True (default) or False). Defaults to 'False'.
+
+    Example:
+        get_structures('datasets/pdb_structures', species='human', verbose='True')
+    """
+
+    logger.info(f"Selected species: {species}")
+
+    if not os.path.isdir(path):
+        os.makedirs(path)
+        logger.debug(f'mkdir {path}')
+
+    # Select proteome
+    if mane:
+        if species == "Homo sapiens":
+            proteome = f"mane_overlap_v{af_version}"
+        else:
+            raise RuntimeError(f"Structures with MANE transcripts overlap are available only for 'Homo sapiens'. Exiting...")
+    else:
+        if species == "Homo sapiens":
+            proteome = f"UP000005640_9606_HUMAN_v{af_version}"
+        elif species == "Mus musculus":
+            proteome = f"UP000000589_10090_MOUSE_v{af_version}"
+        else:
+            raise RuntimeError(f"Failed to recognize '{species}' as organism. Currently accepted ones are 'Homo sapiens' and 'Mus musculus'. Exiting...")
+
+    logger.debug(f"Proteome to download: {proteome}")
+    af_url = f"https://ftp.ebi.ac.uk/pub/databases/alphafold/latest/{proteome}.tar"
+    file_path = os.path.join(path, f"{proteome}.tar")
+
+    try:
+        ## STEP1 --- Download file
+        attempts = 0
+        status = "INIT"
+        while status != "PASS":
+            download_single_file(af_url, file_path, threads, proteome)
+            status = assert_proteome_integrity(file_path, proteome)
+            attempts += 1
+            if attempts >= max_attempts:
+                raise RuntimeError(f"Failed to download with integrity after {max_attempts} attempts. Exiting...")
+            time.sleep(10)
+
+        ## STEP2 --- Extract structures
+        logger.info(f'Extracting {file_path}')
+        extract_tar_file(file_path, path)
+
+        logger.info('Download structure: SUCCESS')
+        logger.debug(f"Structures downloaded in directory {path}")
+
+    except Exception as e:
+        logger.error('Download structure: FAIL')
+        logger.error(f"Error while downloading structures: {e}")
+        raise e