biobb-io 4.2.0__py3-none-any.whl → 5.0.1__py3-none-any.whl

biobb_io/api/common.py

@@ -1,39 +1,50 @@
-""" Common functions for package api """
-import os
+"""Common functions for package api"""
+
 import json
-import requests
+import os
 import re
 import urllib.request
 from pathlib import Path, PurePath
+
+import requests
 from biobb_common.tools import file_utils as fu
 
 
-def check_output_path(path, argument, optional, out_log, classname):
-    """ Checks output file """
+def check_output_path(path, argument, optional, out_log, classname) -> str:
+    """Checks output file"""
     if optional and not path:
-        return None
+        return ""
     if PurePath(path).parent and not Path(PurePath(path).parent).exists():
-        fu.log(classname + ': Unexisting %s folder, exiting' % argument, out_log)
-        raise SystemExit(classname + ': Unexisting %s folder' % argument)
+        fu.log(classname + ": Unexisting %s folder, exiting" % argument, out_log)
+        raise SystemExit(classname + ": Unexisting %s folder" % argument)
     file_extension = PurePath(path).suffix
     if not is_valid_file(file_extension[1:], argument):
-        fu.log(classname + ': Format %s in %s file is not compatible' % (file_extension[1:], argument), out_log)
-        raise SystemExit(classname + ': Format %s in %s file is not compatible' % (file_extension[1:], argument))
+        fu.log(
+            classname
+            + ": Format %s in %s file is not compatible"
+            % (file_extension[1:], argument),
+            out_log,
+        )
+        raise SystemExit(
+            classname
+            + ": Format %s in %s file is not compatible"
+            % (file_extension[1:], argument)
+        )
     return path
 
 
 def is_valid_file(ext, argument):
-    """ Checks if file format is compatible """
+    """Checks if file format is compatible"""
     formats = {
-        'output_sdf_path': ['sdf'],
-        'output_pdb_path': ['pdb'],
-        'output_simulations': ['json'],
-        'output_simulation': ['zip'],
-        'output_pdb_zip_path': ['zip'],
-        'output_mutations_list_txt': ['txt'],
-        'output_json_path': ['json'],
-        'output_fasta_path': ['fasta'],
-        'output_mmcif_path': ['mmcif', 'cif'],
+        "output_sdf_path": ["sdf"],
+        "output_pdb_path": ["pdb"],
+        "output_simulations": ["json"],
+        "output_simulation": ["zip"],
+        "output_pdb_zip_path": ["zip"],
+        "output_mutations_list_txt": ["txt"],
+        "output_json_path": ["json"],
+        "output_fasta_path": ["fasta"],
+        "output_mmcif_path": ["mmcif", "cif"],
     }
     return ext in formats[argument]
 
@@ -44,15 +55,15 @@ def download_pdb(pdb_code, api_id, out_log=None, global_log=None):
         String: Content of the pdb file.
     """
 
-    if api_id == 'mmb':
+    if api_id == "mmb":
         url = "https://mmb.irbbarcelona.org/api/pdb/" + pdb_code + "/coords/?"
-    elif api_id == 'pdb':
+    elif api_id == "pdb":
         url = "https://files.rcsb.org/download/" + pdb_code + ".pdb"
-    elif api_id == 'pdbe':
+    elif api_id == "pdbe":
         url = "https://www.ebi.ac.uk/pdbe/entry-files/download/pdb" + pdb_code + ".ent"
 
     fu.log("Downloading %s from: %s" % (pdb_code, url), out_log, global_log)
-    return requests.get(url).content.decode('utf-8')
+    return requests.get(url).content.decode("utf-8")
 
 
 def download_af(uniprot_code, out_log=None, global_log=None, classname=None):
@@ -66,11 +77,11 @@ def download_af(uniprot_code, out_log=None, global_log=None, classname=None):
     fu.log("Downloading %s from: %s" % (uniprot_code, url), out_log, global_log)
 
     r = requests.get(url)
-    if (r.status_code == 404):
-        fu.log(classname + ': Incorrect Uniprot Code: %s' % (uniprot_code), out_log)
-        raise SystemExit(classname + ': Incorrect Uniprot Code: %s' % (uniprot_code))
+    if r.status_code == 404:
+        fu.log(classname + ": Incorrect Uniprot Code: %s" % (uniprot_code), out_log)
+        raise SystemExit(classname + ": Incorrect Uniprot Code: %s" % (uniprot_code))
 
-    return r.content.decode('utf-8')
+    return r.content.decode("utf-8")
 
 
 def download_mmcif(pdb_code, api_id, out_log=None, global_log=None):
@@ -79,15 +90,15 @@ def download_mmcif(pdb_code, api_id, out_log=None, global_log=None):
         String: Content of the mmcif file.
     """
 
-    if api_id == 'mmb':
+    if api_id == "mmb":
         url = "http://mmb.irbbarcelona.org/api/pdb/" + pdb_code + ".cif"
-    elif api_id == 'pdb':
+    elif api_id == "pdb":
         url = "https://files.rcsb.org/download/" + pdb_code + ".cif"
-    elif api_id == 'pdbe':
+    elif api_id == "pdbe":
         url = "https://www.ebi.ac.uk/pdbe/entry-files/download/" + pdb_code + ".cif"
 
     fu.log("Downloading %s from: %s" % (pdb_code, url), out_log, global_log)
-    return requests.get(url, verify=False).content.decode('utf-8')
+    return requests.get(url, verify=True).content.decode("utf-8")
 
 
 def download_ligand(ligand_code, api_id, out_log=None, global_log=None):
@@ -96,12 +107,16 @@ def download_ligand(ligand_code, api_id, out_log=None, global_log=None):
         String: Content of the ligand file.
     """
 
-    if api_id == 'mmb':
+    if api_id == "mmb":
         url = "http://mmb.irbbarcelona.org/api/pdbMonomer/" + ligand_code.lower()
-        text = requests.get(url, verify=False).content.decode('utf-8')
-    elif api_id == 'pdbe':
-        url = "https://www.ebi.ac.uk/pdbe/static/files/pdbechem_v2/" + ligand_code.upper() + "_ideal.pdb"
-        text = urllib.request.urlopen(url).read().decode('utf-8')
+        text = requests.get(url, verify=True).content.decode("utf-8")
+    elif api_id == "pdbe":
+        url = (
+            "https://www.ebi.ac.uk/pdbe/static/files/pdbechem_v2/"
+            + ligand_code.upper()
+            + "_ideal.pdb"
+        )
+        text = urllib.request.urlopen(url).read().decode("utf-8")
 
     fu.log("Downloading %s from: %s" % (ligand_code, url), out_log, global_log)
 
@@ -117,37 +132,28 @@ def download_fasta(pdb_code, api_id, out_log=None, global_log=None):
         String: Content of the fasta file.
     """
 
-    if api_id == 'mmb':
+    if api_id == "mmb":
         url = "http://mmb.irbbarcelona.org/api/pdb/" + pdb_code + ".fasta"
-    elif api_id == 'pdb':
+    elif api_id == "pdb":
         url = "https://www.rcsb.org/fasta/entry/" + pdb_code
-    elif api_id == 'pdbe':
+    elif api_id == "pdbe":
         url = "https://www.ebi.ac.uk/pdbe/entry/pdb/" + pdb_code + "/fasta"
 
     fu.log("Downloading %s from: %s" % (pdb_code, url), out_log, global_log)
-    return requests.get(url, verify=False).content.decode('utf-8')
-
-
-def download_drugbank(drugbank_id, url="https://www.drugbank.ca/structures/small_molecule_drugs/%s.sdf?type=3d", out_log=None, global_log=None):
-    """
-    Returns:
-        String: Content of the component file.
-    """
-    url = (url % drugbank_id)
-
-    fu.log("Downloading %s from: %s" % (drugbank_id, url), out_log, global_log)
-
-    text = requests.get(url, verify=False).content.decode('utf-8')
-
-    return text
+    return requests.get(url, verify=True).content.decode("utf-8")
 
 
-def download_binding_site(pdb_code, url="https://www.ebi.ac.uk/pdbe/api/pdb/entry/binding_sites/%s", out_log=None, global_log=None):
+def download_binding_site(
+    pdb_code,
+    url="https://www.ebi.ac.uk/pdbe/api/pdb/entry/binding_sites/%s",
+    out_log=None,
+    global_log=None,
+):
     """
     Returns:
         String: Content of the component file.
     """
-    url = (url % pdb_code)
+    url = url % pdb_code
 
     fu.log("Getting binding sites from: %s" % (url), out_log, global_log)
 
@@ -165,24 +171,37 @@ def download_ideal_sdf(ligand_code, api_id, out_log=None, global_log=None):
         String: Content of the ideal sdf file.
     """
 
-    if api_id == 'pdb':
-        url = "https://files.rcsb.org/ligands/download/" + ligand_code.upper() + "_ideal.sdf"
-        text = requests.get(url, verify=False).content.decode('utf-8')
-    elif api_id == 'pdbe':
-        url = "https://www.ebi.ac.uk/pdbe/static/files/pdbechem_v2/" + ligand_code.upper() + "_ideal.sdf"
-        text = urllib.request.urlopen(url).read().decode('utf-8')
+    if api_id == "pdb":
+        url = (
+            "https://files.rcsb.org/ligands/download/"
+            + ligand_code.upper()
+            + "_ideal.sdf"
+        )
+        text = requests.get(url, verify=True).content.decode("utf-8")
+    elif api_id == "pdbe":
+        url = (
+            "https://www.ebi.ac.uk/pdbe/static/files/pdbechem_v2/"
+            + ligand_code.upper()
+            + "_ideal.sdf"
+        )
+        text = urllib.request.urlopen(url).read().decode("utf-8")
 
     fu.log("Downloading %s from: %s" % (ligand_code, url), out_log, global_log)
 
     return text
 
 
-def download_str_info(pdb_code, url="http://mmb.irbbarcelona.org/api/pdb/%s.json", out_log=None, global_log=None):
+def download_str_info(
+    pdb_code,
+    url="http://mmb.irbbarcelona.org/api/pdb/%s.json",
+    out_log=None,
+    global_log=None,
+):
     """
     Returns:
         String: Content of the JSON file.
     """
-    url = (url % pdb_code)
+    url = url % pdb_code
 
     fu.log("Getting structure info from: %s" % (url), out_log, global_log)
 
@@ -195,11 +214,15 @@ def download_str_info(pdb_code, url="http://mmb.irbbarcelona.org/api/pdb/%s.json
 
 
 def write_pdb(pdb_string, output_pdb_path, filt=None, out_log=None, global_log=None):
-    """ Writes and filters a PDB """
+    """Writes and filters a PDB"""
     fu.log("Writting pdb to: %s" % (output_pdb_path), out_log, global_log)
-    with open(output_pdb_path, 'w') as output_pdb_file:
+    with open(output_pdb_path, "w") as output_pdb_file:
         if filt:
-            fu.log("Filtering lines NOT starting with one of these words: %s" % str(filt), out_log, global_log)
+            fu.log(
+                "Filtering lines NOT starting with one of these words: %s" % str(filt),
+                out_log,
+                global_log,
+            )
             for line in pdb_string.splitlines(True):
                 if line.strip().split()[0][0:6] in filt:
                     output_pdb_file.write(line)
@@ -208,23 +231,23 @@ def write_pdb(pdb_string, output_pdb_path, filt=None, out_log=None, global_log=N
 
 
 def write_mmcif(mmcif_string, output_mmcif_path, out_log=None, global_log=None):
-    """ Writes a mmcif """
+    """Writes a mmcif"""
     fu.log("Writting mmcif to: %s" % (output_mmcif_path), out_log, global_log)
-    with open(output_mmcif_path, 'w') as output_mmcif_file:
+    with open(output_mmcif_path, "w") as output_mmcif_file:
         output_mmcif_file.write(mmcif_string)
 
 
 def write_fasta(fasta_string, output_fasta_path, out_log=None, global_log=None):
-    """ Writes a FASTA """
+    """Writes a FASTA"""
     fu.log("Writting FASTA to: %s" % (output_fasta_path), out_log, global_log)
-    with open(output_fasta_path, 'w') as output_fasta_file:
+    with open(output_fasta_path, "w") as output_fasta_file:
         output_fasta_file.write(fasta_string)
 
 
 def write_sdf(sdf_string, output_sdf_path, out_log=None, global_log=None):
-    """ Writes a SDF """
+    """Writes a SDF"""
     fu.log("Writting sdf to: %s" % (output_sdf_path), out_log, global_log)
-    with open(output_sdf_path, 'w') as output_sdf_file:
+    with open(output_sdf_path, "w") as output_sdf_file:
         output_sdf_file.write(sdf_string)
 
 
@@ -236,15 +259,32 @@ def get_cluster_pdb_codes(pdb_code, cluster, out_log=None, global_log=None):
     url = "http://mmb.irbbarcelona.org/api/pdb/"
     pdb_codes = set()
 
-    url = url+pdb_code.lower()+'/clusters/cl-'+str(cluster)+".json"
-    cluster_list = json.loads(requests.get(url, verify=False).content.decode('utf-8'))['clusterMembers']
+    url = url + pdb_code.lower() + "/clusters/cl-" + str(cluster) + ".json"
+    cluster_list = json.loads(requests.get(url, verify=True).content.decode("utf-8"))[
+        "clusterMembers"
+    ]
     for elem in cluster_list:
-        pdb_codes.add(elem['_id'].lower())
+        pdb_codes.add(elem["_id"].lower())
 
     if out_log:
-        out_log.info('Cluster: '+str(cluster)+' of pdb_code: '+pdb_code+'\n List: '+str(pdb_codes))
+        out_log.info(
+            "Cluster: "
+            + str(cluster)
+            + " of pdb_code: "
+            + pdb_code
+            + "\n List: "
+            + str(pdb_codes)
+        )
     if global_log:
-        global_log.info(fu.get_logs_prefix()+'Cluster: '+str(cluster)+' of pdb_code: '+pdb_code+'\n List: '+str(pdb_codes))
+        global_log.info(
+            fu.get_logs_prefix()
+            + "Cluster: "
+            + str(cluster)
+            + " of pdb_code: "
+            + pdb_code
+            + "\n List: "
+            + str(pdb_codes)
+        )
 
     return pdb_codes
 
@@ -255,67 +295,84 @@ def get_uniprot(pdb_code, url, out_log=None, global_log=None):
     Returns:
         str: UNIPROT code.
     """
-    url_uniprot_id = (url+"/pdb/"+pdb_code.lower()+"/entry/uniprotRefs/_id")
-    uniprot_id = requests.get(url_uniprot_id, verify=False).json()['uniprotRefs._id'][0]
+    url_uniprot_id = url + "/pdb/" + pdb_code.lower() + "/entry/uniprotRefs/_id"
+    uniprot_id = requests.get(url_uniprot_id, verify=True).json()["uniprotRefs._id"][0]
 
     if out_log:
-        out_log.info('PDB code: '+pdb_code+' correspond to uniprot id: '+uniprot_id)
+        out_log.info(
+            "PDB code: " + pdb_code + " correspond to uniprot id: " + uniprot_id
+        )
     if global_log:
-        global_log.info('PDB code: '+pdb_code+' correspond to uniprot id: '+uniprot_id)
+        global_log.info(
+            "PDB code: " + pdb_code + " correspond to uniprot id: " + uniprot_id
+        )
 
     return uniprot_id
 
 
-def get_variants(uniprot_id, url="http://mmb.irbbarcelona.org/api", out_log=None, global_log=None):
+def get_variants(
+    uniprot_id, url="http://mmb.irbbarcelona.org/api", out_log=None, global_log=None
+):
     """Returns the variants of the `uniprot_id` code.
 
     Returns:
         :obj:`list` of :obj:`str`: List of variants.
     """
-    url_uniprot_mut = (url+"/uniprot/"+uniprot_id+"/entry/variants/vardata/mut/?varorig=humsavar")
-    variants = requests.get(url_uniprot_mut, verify=False).json()['variants.vardata.mut']
+    url_uniprot_mut = (
+        url + "/uniprot/" + uniprot_id + "/entry/variants/vardata/mut/?varorig=humsavar"
+    )
+    variants = requests.get(url_uniprot_mut, verify=True).json()["variants.vardata.mut"]
     variants = variants if variants else []
 
-    fu.log('Found: %d variants for uniprot id: %s' % (len(variants), uniprot_id), out_log, global_log)
+    fu.log(
+        "Found: %d variants for uniprot id: %s" % (len(variants), uniprot_id),
+        out_log,
+        global_log,
+    )
     return variants if variants else []
 
 
 def write_json(json_string, output_json_path, out_log=None, global_log=None):
-    """ Writes a JSON """
+    """Writes a JSON"""
     fu.log("Writting json to: %s" % (output_json_path), out_log, global_log)
-    with open(output_json_path, 'w') as output_json_file:
+    with open(output_json_path, "w") as output_json_file:
         output_json_file.write(json_string)
 
 
 def get_memprotmd_sim_list(out_log=None, global_log=None):
-    """ Returns all available membrane-protein systems (simulations) from the MemProtMD DB using its REST API """
+    """Returns all available membrane-protein systems (simulations) from the MemProtMD DB using its REST API"""
 
-    fu.log('Getting all available membrane-protein systems (simulations) from the MemProtMD REST API', out_log, global_log)
+    fu.log(
+        "Getting all available membrane-protein systems (simulations) from the MemProtMD REST API",
+        out_log,
+        global_log,
+    )
 
     url = "http://memprotmd.bioch.ox.ac.uk/api/simulations/all"
     json_obj = requests.post(url).json()
     json_string = json.dumps(json_obj, indent=4)
 
-    fu.log('Total number of simulations: %d' % (len(json_obj)), out_log, global_log)
+    fu.log("Total number of simulations: %d" % (len(json_obj)), out_log, global_log)
 
     return json_string
 
 
 def get_memprotmd_sim_search(collection_name, keyword, out_log=None, global_log=None):
-    """ Performs advanced searches in the MemProtMD DB using its REST API and a given keyword """
+    """Performs advanced searches in the MemProtMD DB using its REST API and a given keyword"""
 
-    fu.log('Getting search results from the MemProtMD REST API. Collection name: %s, keyword: %s' % (collection_name, keyword), out_log, global_log)
+    fu.log(
+        "Getting search results from the MemProtMD REST API. Collection name: %s, keyword: %s"
+        % (collection_name, keyword),
+        out_log,
+        global_log,
+    )
 
     url = "http://memprotmd.bioch.ox.ac.uk/api/search/advanced"
     json_query = {
         "collectionName": collection_name,
-        "query": {
-            "keywords": keyword
-        },
-        "projection": {
-            "simulations": 1
-        },
-        "options": {}
+        "query": {"keywords": keyword},
+        "projection": {"simulations": 1},
+        "options": {},
     }
 
     json_obj = requests.post(url, json=json_query).json()
@@ -324,43 +381,49 @@ def get_memprotmd_sim_search(collection_name, keyword, out_log=None, global_log=
     # get total number of simulation
     list_kw = []
     for sim_list in json_obj:
-        for sim in sim_list['simulations']:
+        for sim in sim_list["simulations"]:
             list_kw.append(sim)
 
-    fu.log('Total number of simulations: %d' % (len(list_kw)), out_log, global_log)
+    fu.log("Total number of simulations: %d" % (len(list_kw)), out_log, global_log)
 
     return json_string
 
 
 def get_memprotmd_sim(pdb_code, output_file, out_log=None, global_log=None):
-    """ Gets a single simulation from MemProtMD DB """
+    """Gets a single simulation from MemProtMD DB"""
 
-    fu.log('Getting simulation file from pdb code %s' % (pdb_code), out_log, global_log)
+    fu.log("Getting simulation file from pdb code %s" % (pdb_code), out_log, global_log)
 
-    url = "http://memprotmd.bioch.ox.ac.uk/data/memprotmd/simulations/" + pdb_code + "_default_dppc/files/run/at.zip"
+    url = (
+        "http://memprotmd.bioch.ox.ac.uk/data/memprotmd/simulations/"
+        + pdb_code
+        + "_default_dppc/files/run/at.zip"
+    )
     response = requests.get(url)
 
-    open(output_file, 'wb').write(response.content)
+    open(output_file, "wb").write(response.content)
 
     fu.log("Saving output %s file" % (output_file), out_log, global_log)
 
 
 def check_mandatory_property(property, name, out_log, classname):
-    """ Checks mandatory properties """
+    """Checks mandatory properties"""
 
     if not property:
-        fu.log(classname + ': Unexisting %s property, exiting' % name, out_log)
-        raise SystemExit(classname + ': Unexisting %s property' % name)
+        fu.log(classname + ": Unexisting %s property, exiting" % name, out_log)
+        raise SystemExit(classname + ": Unexisting %s property" % name)
     return property
 
 
 def check_uniprot_code(code, out_log, classname):
-    """ Checks uniprot code """
+    """Checks uniprot code"""
 
-    pattern = re.compile((r"[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]([A-Z][A-Z0-9]{2}[0-9]){1,2}"))
+    pattern = re.compile(
+        (r"[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]([A-Z][A-Z0-9]{2}[0-9]){1,2}")
+    )
 
     if not pattern.match(code):
-        fu.log(classname + ': Incorrect uniprot code for %s' % code, out_log)
-        raise SystemExit(classname + ': Incorrect uniprot code for %s' % code)
+        fu.log(classname + ": Incorrect uniprot code for %s" % code, out_log)
+        raise SystemExit(classname + ": Incorrect uniprot code for %s" % code)
 
     return True

biobb_io/api/ideal_sdf.py

@@ -1,11 +1,20 @@
 #!/usr/bin/env python
 
 """Module containing the IdealSdf class and the command line interface."""
+
 import argparse
-from biobb_common.generic.biobb_object import BiobbObject
+from typing import Optional
+
 from biobb_common.configuration import settings
+from biobb_common.generic.biobb_object import BiobbObject
 from biobb_common.tools.file_utils import launchlogger
-from biobb_io.api.common import check_output_path, check_mandatory_property, download_ideal_sdf, write_sdf
+
+from biobb_io.api.common import (
+    check_mandatory_property,
+    check_output_path,
+    download_ideal_sdf,
+    write_sdf,
+)
 
 
 class IdealSdf(BiobbObject):
@@ -21,6 +30,7 @@ class IdealSdf(BiobbObject):
             * **api_id** (*str*) - ("pdbe") Identifier of the PDB REST API from which the SDF structure will be downloaded. Values: pdbe (`PDB in Europe REST API <https://www.ebi.ac.uk/pdbe/pdbe-rest-api>`_), pdb (`RCSB PDB REST API <https://data.rcsb.org/>`_).
             * **remove_tmp** (*bool*) - (True) [WF property] Remove temporal files.
             * **restart** (*bool*) - (False) [WF property] Do not execute if output files exist.
+            * **sandbox_path** (*str*) - ("./") [WF property] Parent path to the sandbox directory.
 
     Examples:
         This is a use example of how to use the building block from Python::
@@ -43,8 +53,7 @@ class IdealSdf(BiobbObject):
 
     """
 
-    def __init__(self, output_sdf_path,
-                 properties=None, **kwargs) -> None:
+    def __init__(self, output_sdf_path, properties=None, **kwargs) -> None:
         properties = properties or {}
 
         # Call parent class constructor
@@ -52,13 +61,11 @@ class IdealSdf(BiobbObject):
         self.locals_var_dict = locals().copy()
 
         # Input/Output files
-        self.io_dict = {
-            "out": {"output_sdf_path": output_sdf_path}
-        }
+        self.io_dict = {"out": {"output_sdf_path": output_sdf_path}}
 
         # Properties specific for BB
-        self.api_id = properties.get('api_id', 'pdbe')
-        self.ligand_code = properties.get('ligand_code', None)
+        self.api_id = properties.get("api_id", "pdbe")
+        self.ligand_code = properties.get("ligand_code", None)
         self.properties = properties
 
         # Check the properties
@@ -66,8 +73,14 @@ class IdealSdf(BiobbObject):
         self.check_arguments()
 
     def check_data_params(self, out_log, err_log):
-        """ Checks all the input/output paths and parameters """
-        self.output_sdf_path = check_output_path(self.io_dict["out"]["output_sdf_path"], "output_sdf_path", False, out_log, self.__class__.__name__)
+        """Checks all the input/output paths and parameters"""
+        self.output_sdf_path = check_output_path(
+            self.io_dict["out"]["output_sdf_path"],
+            "output_sdf_path",
+            False,
+            out_log,
+            self.__class__.__name__,
+        )
 
     @launchlogger
     def launch(self) -> int:
@@ -80,12 +93,16 @@ class IdealSdf(BiobbObject):
         if self.check_restart():
             return 0
 
-        check_mandatory_property(self.ligand_code, 'ligand_code', self.out_log, self.__class__.__name__)
+        check_mandatory_property(
+            self.ligand_code, "ligand_code", self.out_log, self.__class__.__name__
+        )
 
         self.ligand_code = self.ligand_code.strip()
 
         # Downloading PDB file
-        sdf_string = download_ideal_sdf(self.ligand_code, self.api_id, self.out_log, self.global_log)
+        sdf_string = download_ideal_sdf(
+            self.ligand_code, self.api_id, self.out_log, self.global_log
+        )
         write_sdf(sdf_string, self.output_sdf_path, self.out_log, self.global_log)
 
         self.check_arguments(output_files_created=True, raise_exception=False)
@@ -93,31 +110,44 @@ class IdealSdf(BiobbObject):
         return 0
 
 
-def ideal_sdf(output_sdf_path: str, properties: dict = None, **kwargs) -> int:
+def ideal_sdf(output_sdf_path: str, properties: Optional[dict] = None, **kwargs) -> int:
     """Execute the :class:`IdealSdf <api.ideal_sdf.IdealSdf>` class and
     execute the :meth:`launch() <api.ideal_sdf.IdealSdf.launch>` method."""
 
-    return IdealSdf(output_sdf_path=output_sdf_path,
-                    properties=properties, **kwargs).launch()
+    return IdealSdf(
+        output_sdf_path=output_sdf_path, properties=properties, **kwargs
+    ).launch()
 
 
 def main():
     """Command line execution of this building block. Please check the command line documentation."""
-    parser = argparse.ArgumentParser(description="This class is a wrapper for downloading an ideal SDF ligand from the Protein Data Bank.", formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, width=99999))
-    parser.add_argument('-c', '--config', required=False, help="This file can be a YAML file, JSON file or JSON string")
+    parser = argparse.ArgumentParser(
+        description="This class is a wrapper for downloading an ideal SDF ligand from the Protein Data Bank.",
+        formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, width=99999),
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        required=False,
+        help="This file can be a YAML file, JSON file or JSON string",
+    )
 
     # Specific args of each building block
-    required_args = parser.add_argument_group('required arguments')
-    required_args.add_argument('-o', '--output_sdf_path', required=True, help="Path to the output SDF file. Accepted formats: sdf.")
+    required_args = parser.add_argument_group("required arguments")
+    required_args.add_argument(
+        "-o",
+        "--output_sdf_path",
+        required=True,
+        help="Path to the output SDF file. Accepted formats: sdf.",
+    )
 
     args = parser.parse_args()
     config = args.config if args.config else None
     properties = settings.ConfReader(config=config).get_prop_dic()
 
     # Specific call of each building block
-    ideal_sdf(output_sdf_path=args.output_sdf_path,
-              properties=properties)
+    ideal_sdf(output_sdf_path=args.output_sdf_path, properties=properties)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()