MASSA-Algorithm 1.0.0__tar.gz → 2.0.1__tar.gz

{massa_algorithm-1.0.0 → massa_algorithm-2.0.1}/MASSA_Algorithm/MASSA.py

@@ -1,3 +1,4 @@
+import time
 from MASSA_Algorithm import MASSAlogos
 from MASSA_Algorithm import MASSAargs
 from MASSA_Algorithm import MASSAod
@@ -8,6 +9,8 @@ from MASSA_Algorithm import MASSApreparation
 from MASSA_Algorithm import MASSAcluster
 from MASSA_Algorithm import MASSAsplit
 from MASSA_Algorithm import MASSAmoloutput
+from joblib import parallel_backend
+
 
 
 def returns_zero(total, test, validation):
@@ -48,10 +51,11 @@ def main():
         Main subroutine, allows the program to run directly from
         the command line when installed via pip.
     """
+    parallel_backend('multiprocessing')
     # Initializing from the command line.
     # Print the program logo:
     MASSAlogos.initial_print()
-
+    start_time = time.time()
     # It captures command line arguments.
     (file_input,
      file_output,
@@ -67,18 +71,32 @@ def main():
      linkage_method,
      flag_dendrogram,
      splitting_strategy,
-     drop_errors) = MASSAargs.capture_args()
+     drop_errors,
+     large_library) = MASSAargs.capture_args()
     print('Initializing, wait...\n')
 
     # Create log.txt file in directory:
-    arqlog = directoryfile_output+'/log.txt'
-    writelog = open(arqlog, 'w')
+    log_path = directoryfile_output+'/log.txt'
+    write_log = open(log_path, 'w')
 
     # Initial file management:
-    # It creates the output directories.
-    MASSAod.output_directory(directoryfile_output)
     # Read molecules.
-    mols = MASSAopen_files.read_molecules(file_input, writelog, drop_errors)
+    mols = MASSAopen_files.read_molecules(file_input, write_log, drop_errors)
+
+    # If auto detection is enable to select the initial cluster algorithm.
+    if large_library == 'auto':
+        if int(len(mols)) > 9999:
+            large_library = True
+        else:
+            large_library = False
+
+    if large_library == True:
+        # Deactivates the HCA dendrogram.
+        flag_dendrogram = False
+
+    # It creates the output directories.
+    MASSAod.output_directory(directoryfile_output, flag_dendrogram)
+
     # Extracting the property names from the ".sdf" input file.
     sdf_property_names = MASSAopen_files.get_sdf_property_names(mols)
     # Structure 3D management - It adds hydrogens keeping 3D coordenates.
@@ -87,6 +105,7 @@ def main():
     # Extraction properties from ".sdf":
     # It extracts the names of the molecules and creates a name:molecule dictionary and a dataframe.
     names, dataframe = MASSAextraction.name_extraction(mols_h)
+
     # It defines a list of what biological activities are being extracted.
     biological_activity = MASSAextraction.the_biological_handler(
         sdf_property_names, number_bioact, bioactivities_as_args)
@@ -112,16 +131,28 @@ def main():
     # PCA for the structural domain.
     fp_pca = MASSApreparation.pca_maker(fp_matrix, npcs, svd_parameter)
 
-    # First clustering (HCA):
-    # It performs HCA clustering without generating the dendrogram for the biological domain.
-    leaves_cluster_bio, bio_hca, linkage_bio, cutoff_bio = MASSAcluster.hca_clusters(
-        bio_pca, names, 'bio', directoryfile_output, extension_type, linkage_method)
-    # It performs HCA clustering without generating the dendrogram for the physicochemical domain.
-    leaves_cluster_phch, phch_hca, linkage_phch, cutoff_phch = MASSAcluster.hca_clusters(
-        phch_pca, names, 'PhCh', directoryfile_output, extension_type, linkage_method)
-    # It performs HCA clustering without generating the dendrogram for the structural domain.
-    leaves_cluster_fp, fp_hca, linkage_fp, cutoff_fp = MASSAcluster.hca_clusters(
-        fp_pca, names, 'FP', directoryfile_output, extension_type, linkage_method)
+    if large_library == True:
+        # First clustering (MiniBatch-KMeans):
+        # It performs KMeans clustering for the biological domain.
+        bio_hca = MASSAcluster.kmeans_clusters(
+            bio_pca, names, 'bio', directoryfile_output, extension_type)
+        # It performs KMeans clustering for the physicochemical domain.
+        phch_hca = MASSAcluster.kmeans_clusters(
+            phch_pca, names, 'PhCh', directoryfile_output, extension_type)
+        # It performs KMeans clustering for the structural domain.
+        fp_hca = MASSAcluster.kmeans_clusters(
+            fp_pca, names, 'FP', directoryfile_output, extension_type)
+    else:
+        # First clustering (HCA):
+        # It performs HCA clustering without generating the dendrogram for the biological domain.
+        leaves_cluster_bio, bio_hca, linkage_bio, cutoff_bio = MASSAcluster.hca_clusters(
+            bio_pca, names, 'bio', directoryfile_output, extension_type, linkage_method)
+        # It performs HCA clustering without generating the dendrogram for the physicochemical domain.
+        leaves_cluster_phch, phch_hca, linkage_phch, cutoff_phch = MASSAcluster.hca_clusters(
+            phch_pca, names, 'PhCh', directoryfile_output, extension_type, linkage_method)
+        # It performs HCA clustering without generating the dendrogram for the structural domain.
+        leaves_cluster_fp, fp_hca, linkage_fp, cutoff_fp = MASSAcluster.hca_clusters(
+            fp_pca, names, 'FP', directoryfile_output, extension_type, linkage_method)
 
     # It adds the biological cluster identification to the spreadsheet.
     dataframe = MASSApreparation.organize_df_clusterization(
@@ -137,7 +168,8 @@ def main():
     # It creates a matrix with cluster identifications for each of the three domains for Kmodes.
     matrix_for_kmodes = MASSApreparation.organize_for_kmodes(dataframe)
     # It performs Kmodes clustering for the general domain.
-    all_hca = MASSAcluster.kmodes_clusters(matrix_for_kmodes, names)
+    all_hca = MASSAcluster.kmodes_clusters(matrix_for_kmodes, names,
+                                           directoryfile_output, extension_type)
     # It adds the general cluster identification to the spreadsheet.
     dataframe = MASSApreparation.organize_df_clusterization(
         dataframe, all_hca, 'all')
@@ -239,27 +271,30 @@ def main():
     MASSAsplit.log_of_distributions(
         bio_distr, bio_total, bio_training,
         bio_test, bio_val, splitting_strategy,
-        writelog
+        write_log
     )
     phch_distr = 'Physicochemical Distribution'
     MASSAsplit.log_of_distributions(
         phch_distr, phch_total, phch_training,
         phch_test, phch_val, splitting_strategy,
-        writelog
+        write_log
     )
     fp_distr = 'Structural (FP) Distribution'
     MASSAsplit.log_of_distributions(
         fp_distr, fp_total, fp_training,
         fp_test, fp_val, splitting_strategy,
-        writelog
+        write_log
     )
     all_distr = 'General Distribution'
     MASSAsplit.log_of_distributions(
         all_distr, all_total, all_training,
         all_test, all_val, splitting_strategy,
-        writelog
+        write_log
     )
-    writelog.close()
+
+    # Output management:
+    # It adds, for each molecule, the values of the calculated properties, the identifications of each cluster and which set the molecule belongs to.
+    MASSAmoloutput.output_file_mols(dataframe, file_output)
 
     # Plot HCAs:
     if flag_dendrogram == True:
@@ -280,7 +315,8 @@ def main():
             extension_type, dendrogram_xfont_size, test_or_val_molecules
         )  # fp_Plot: Plot the HCA dendrogram
 
-    # Output management:
-    # It adds, for each molecule, the values of the calculated properties, the identifications of each cluster and which set the molecule belongs to.
-    MASSAmoloutput.output_mols(dataframe, file_output)
-    print('Completed')
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    write_log.write(f'Completed! Elapsed time = {elapsed_time} s.')
+    write_log.close()
+    print(f'Completed! Elapsed time = {elapsed_time} s.')

{massa_algorithm-1.0.0 → massa_algorithm-2.0.1}/MASSA_Algorithm/MASSAargs.py

@@ -26,7 +26,7 @@ def capture_args():
             '[-n <number_of_principal_components>] [-v <svd_parameter>] [-l <linkage_method] '
             '[-t <extension_for_images>] [-d <dendrogram_font_size_on_Xaxis>] '
             '[-x <frequency_bar_plot_font_size_on_Xaxis>] [-f <toggle_dendrogram>] '
-            '[-e <drop_molecules_with_errors]'
+            '[-e <drop_molecules_with_errors] [-a <large_dataset>]'
         )
     )
     required = parser.add_argument_group('required arguments')
@@ -120,9 +120,17 @@ def capture_args():
                                 )
                           )
     optional.add_argument('-e', '--drop_errors', type=str, choices=['true', 'false'],
-                          metavar='DROP_MOLECULES_WITH_ERRORS', default='false', help=(
+                          metavar='DROP_MOLECULES_WITH_ERRORS', default='true', help=(
                           'Ignore chemistry errors, saving only molecules without any errors. '
-                          'Default = \'false\'.'
+                          'False will treat molecule errors as fatal and fail the execution. '
+                          'Default = \'true\'.'
+                          ))
+    optional.add_argument('-a', '--large_dataset', type=str, choices=['auto', 'true', 'false'],
+                          metavar='LARGE_DATASET', default='auto', help=(
+                          'Switch the MASSA algorithm from HCA to KMeans to handle large datasets. '
+                          'Options = auto (switches to KMeans if ≥ 10,000 molecules),  '
+                          'false = use HCA (for smaller datasets), '
+                          'true = use KMeans (for large datasets).'
                           ))
     args = parser.parse_args()
 
@@ -153,6 +161,12 @@ def capture_args():
     flag_strategy = str(args.splitting_strategy).lower()
     # It captures whether or not to ignore chemistry errors.
     drop = str(args.drop_errors).lower()
+    # It captures whether or not is handling with a large dataset.
+    large_dataset = str(args.large_dataset).lower()
+    if large_dataset == 'true':
+        large_dataset = True
+    elif large_dataset == 'false':
+        large_dataset = False
 
     if args.the_biological_activities != None:
         # It creates a list with the names of the biological activities to be searched for.
@@ -210,5 +224,6 @@ def capture_args():
         linkage_method,
         flag_dendrogram,
         flag_strategy,
-        drop
+        drop,
+        large_dataset
     )

{massa_algorithm-1.0.0 → massa_algorithm-2.0.1}/MASSA_Algorithm/MASSAcluster.py

@@ -3,6 +3,9 @@ from matplotlib import pyplot as plt
 from matplotlib import colors as colrs
 import scipy.cluster.hierarchy as sch
 from kmodes import kmodes
+from sklearn.cluster import MiniBatchKMeans as KMeans
+from multiprocessing import cpu_count as mpi_count
+from scipy.spatial.distance import cdist
 
 
 def numerical_number_of_clusters(distances_list):
@@ -26,12 +29,15 @@ def numerical_number_of_clusters(distances_list):
     return distances.index(max(distances)) + 1
 
 
-def categorical_number_of_clusters(file):
+def categorical_number_of_clusters(file, directory_fileoutput, extension_type):
     # Elbow method using the clustering cost:
     list_clus_costs = []
-    for n in range(2, 21):  # Calculate the cost for each n cluster.
+    maxcluster = 31
+    ran_curve = [x for x in range(2, maxcluster, 2)]
+    for n in range(2, maxcluster):  # Calculate the cost for each n cluster.
         km = kmodes.KModes(n_clusters=n, verbose=0,
-                           n_init=20, init='Cao', max_iter=300)
+                           n_init=20, init='Cao',
+                           n_jobs=-1, max_iter=300)
         km.fit(X=file)
         # Costs = Clustering cost, defined as the sum distance of all points
         # to their respective cluster centroids.
@@ -39,10 +45,10 @@ def categorical_number_of_clusters(file):
     # Define the x-axis coordinates of the first and last points on the line.
     x1, y1 = 2, list_clus_costs[0]
     # Define the y-axis coordinates of the first and last points on the line.
-    x2, y2 = 20, list_clus_costs[len(list_clus_costs)-1]
+    x2, y2 = 20, list_clus_costs[18]
 
     distances = []
-    for i in range(len(list_clus_costs)):
+    for i in range(19):
         # Coordinate on the x-axis of the point to calculate the distance to the line.
         x0 = i+2
         # Coordinate on the y-axis of the point to calculate the distance to the line.
@@ -51,7 +57,52 @@ def categorical_number_of_clusters(file):
         denominator = ((y2 - y1)**2 + (x2 - x1)**2)**(1/2)
         # Distance between a point and a line.
         distances.append(numerator/denominator)
-    return (distances.index(max(distances)) + 2)
+    number_of_clusters = (distances.index(max(distances)) + 2)
+    ident = "all"
+    plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve)
+    return number_of_clusters
+
+
+def kmeans_number_of_clusters(file, ident, directory_fileoutput, extension_type):
+    # Elbow method using the clustering cost:
+    list_clus_costs = []
+    maxcluster = 31
+    ran_curve = [x for x in range(2, maxcluster, 2)]
+    for n in range(2, maxcluster):  # Calculate the cost for each n cluster.
+        km = KMeans(n_clusters=n, verbose=0,
+                    init='k-means++', max_iter=300,
+                    batch_size=256*int(mpi_count()),
+                    compute_labels=True, random_state=2025)
+        km.fit(X=file)
+        # Costs = Clustering cost, defined as the sum distance of all points
+        # to their respective cluster centroids.
+        list_clus_costs.append(
+            np.sum(np.min(cdist(file, km.cluster_centers_, 'euclidean'), axis=1)**2) / file.shape[0])
+    # Define the x-axis coordinates of the first and last points on the line.
+    x1, y1 = 2, list_clus_costs[0]
+    # Define the y-axis coordinates of the first and last points on the line.
+    x2, y2 = 20, list_clus_costs[18]
+
+    distances = []
+    for i in range(19):
+        # Coordinate on the x-axis of the point to calculate the distance to the line.
+        x0 = i+2
+        # Coordinate on the y-axis of the point to calculate the distance to the line.
+        y0 = list_clus_costs[i]
+        numerator = abs((y2-y1)*x0 - (x2-x1)*y0 + x2*y1 - y2*x1)
+        denominator = ((y2 - y1)**2 + (x2 - x1)**2)**(1/2)
+        # Distance between a point and a line.
+        distances.append(numerator/denominator)
+
+    number_of_clusters = (distances.index(max(distances)) + 2)
+    plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve)
+    return number_of_clusters
 
 
 def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage):
@@ -69,7 +120,7 @@ def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage
     if ident == 'bio':
         # Define the name, directory and extension of the Euclidean distance graph.
         name_euc_dist_file = directory_fileoutput + \
-            '/Images/Distance_HCA_Images/Dist_HCA_biological.'+extension_type
+            'Images/Distance_Images/Dist_HCA_biological.'+extension_type
         title_distances = 'Plot of Euclidean Distances from Biological HCA'
         print('Number of clusters:')
         # Print the number of clusters for the biological domain.
@@ -80,7 +131,7 @@ def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage
     elif ident == 'PhCh':
         # Define the name, directory and extension of the Euclidean distance graph.
         name_euc_dist_file = directory_fileoutput + \
-            '/Images/Distance_HCA_Images/Dist_HCA_physicochemical.'+extension_type
+            'Images/Distance_Images/Dist_HCA_physicochemical.'+extension_type
         title_distances = 'Plot of Euclidean Distances from Physicochemical HCA'
         # Print the number of clusters for the physicochemical domain.
         print('Physicochemical:', number_of_clusters)
@@ -90,7 +141,7 @@ def optimal_threshold(file, ident, directory_fileoutput, extension_type, linkage
     else:
         # Define the name, directory and extension of the Euclidean distance graph.
         name_euc_dist_file = directory_fileoutput + \
-            '/Images/Distance_HCA_Images/Dist_HCA_structural.'+extension_type
+            'Images/Distance_Images/Dist_HCA_structural.'+extension_type
         title_distances = 'Plot of Euclidean Distances from Structural HCA'
         # Print the number of clusters for the structural domain.
         print('Structural:', number_of_clusters)
@@ -279,24 +330,24 @@ def hca_plot(
     if ident == 'bio':
         plt.title('HCA of biological activity')
         plt.savefig(directory_fileoutput +
-                    '/Images/Dendrogram_HCA_Images/HCA_biological.'+extension_type)
+                    'Images/Dendrogram_HCA_Images/HCA_biological.'+extension_type)
         plt.close()
     elif ident == 'PhCh':
         plt.title('HCA of physicochemical properties')
         plt.savefig(directory_fileoutput +
-                    '/Images/Dendrogram_HCA_Images/HCA_physicochemical.'+extension_type)
+                    'Images/Dendrogram_HCA_Images/HCA_physicochemical.'+extension_type)
         plt.close()
     else:
         plt.title('HCA of AtomPairs fingerprint')
         plt.savefig(directory_fileoutput +
-                    '/Images/Dendrogram_HCA_Images/HCA_structural.'+extension_type)
+                    'Images/Dendrogram_HCA_Images/HCA_structural.'+extension_type)
         plt.close()
 
 
-def kmodes_clusters(file, names):
+def kmodes_clusters(file, names, directory_fileoutput, extension_type):
     # Calculate the number of clusters for the Kmodes:
-    n_clusters = categorical_number_of_clusters(file)
-    print('General:', n_clusters)  # Print the number of clusters.
+    n_clusters = categorical_number_of_clusters(
+        file, directory_fileoutput, extension_type)
 
     # Run Kmodes with the calculated number of clusters:
     # Parameter setting.
@@ -311,3 +362,114 @@ def kmodes_clusters(file, names):
     for i, a in zip(names, clusters_list):
         HCA_General_dict[i] = int(a+1)
     return HCA_General_dict
+
+
+def plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve):
+    plt.plot(
+        list(range(2, len(list_clus_costs)+2)),
+        list_clus_costs, '-o',
+        color='black',
+        markersize=4, linewidth=1,
+        markeredgewidth=1
+    )  # Initial setting of graph values and parameters.
+    if ident == 'bio':
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Distortion_biological.'+extension_type
+        title_distances = 'Plot of Distortion from Biological Space'
+        print('Number of clusters:')
+        # Print the number of clusters for the biological domain.
+        print('Biological:', number_of_clusters)
+        plt.ylabel('KMeans Distortion')  # Set the y-axis label.
+    elif ident == 'PhCh':
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Distortion_physicochemical.'+extension_type
+        title_distances = 'Plot of Distortion from Physicochemical Space'
+        # Print the number of clusters for the physicochemical domain.
+        print('Physicochemical:', number_of_clusters)
+        plt.ylabel('KMeans Distortion')  # Set the y-axis label.
+    elif ident == 'FP':
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Distortion_structural.'+extension_type
+        title_distances = 'Plot of Distortion from Structural Space'
+        # Print the number of clusters for the structural domain.
+        print('Structural:', number_of_clusters)
+        plt.ylabel('KMeans Distortion')  # Set the y-axis label.
+    else:
+        # Define the name, directory and extension of the Distortion graph.
+        name_euc_dist_file = directory_fileoutput + \
+            'Images/Distance_Images/Cost_general.'+extension_type
+        title_distances = 'Cost Plot from General (KModes)'
+        # Print the number of clusters for the structural domain.
+        print('General:', number_of_clusters)
+        plt.ylabel('KModes Cost')  # Set the y-axis label.
+    plt.title(title_distances)  # Define the graph title.
+    plt.xticks(ran_curve)  # Define the x-axis ticks.
+    plt.savefig(name_euc_dist_file)  # Save figure.
+    plt.close()  # Close plot.
+
+
+def kmeans_number_of_clusters(file, ident, directory_fileoutput, extension_type):
+    # Elbow method using the clustering cost:
+    list_clus_costs = []
+    maxcluster = 31
+    ran_curve = [x for x in range(2, maxcluster, 2)]
+    for n in range(2, maxcluster):  # Calculate the cost for each n cluster.
+        km = KMeans(n_clusters=n, verbose=0,
+                    init='k-means++', max_iter=300,
+                    batch_size=256*int(mpi_count()),
+                    compute_labels=True, random_state=2025)
+        km.fit(X=file)
+        # Costs = Clustering cost, defined as the sum distance of all points
+        # to their respective cluster centroids.
+        list_clus_costs.append(
+            np.sum(np.min(cdist(file, km.cluster_centers_, 'euclidean'), axis=1)**2) / file.shape[0])
+    # Define the x-axis coordinates of the first and last points on the line.
+    x1, y1 = 2, list_clus_costs[0]
+    # Define the y-axis coordinates of the first and last points on the line.
+    x2, y2 = 20, list_clus_costs[18]
+
+    distances = []
+    for i in range(19):
+        # Coordinate on the x-axis of the point to calculate the distance to the line.
+        x0 = i+2
+        # Coordinate on the y-axis of the point to calculate the distance to the line.
+        y0 = list_clus_costs[i]
+        numerator = abs((y2-y1)*x0 - (x2-x1)*y0 + x2*y1 - y2*x1)
+        denominator = ((y2 - y1)**2 + (x2 - x1)**2)**(1/2)
+        # Distance between a point and a line.
+        distances.append(numerator/denominator)
+
+    number_of_clusters = (distances.index(max(distances)) + 2)
+    plot_distortion(
+        list_clus_costs, directory_fileoutput,
+        ident, extension_type, number_of_clusters,
+        ran_curve)
+    return number_of_clusters
+
+
+def kmeans_clusters(file, names, ident, directory_fileoutput, extension_type):
+    # Calculate the number of clusters for the Kmodes:
+    n_clusters = kmeans_number_of_clusters(
+        file, ident, directory_fileoutput, extension_type)
+
+    # Run Kmodes with the calculated number of clusters:
+    # Parameter setting.
+    km = KMeans(n_clusters=n_clusters, verbose=0,
+                init='k-means++', max_iter=300,
+                batch_size=256*int(mpi_count()),
+                compute_labels=True, random_state=2025)
+    # Run Kmodes for the dataset and return an array with cluster labels for each molecule.
+    clusters = km.fit_predict(file)
+    clusters_list = list(clusters)  # Transform np.array into a list.
+
+    # Create a dictionary with the pair "molecule name": "General cluster ID":
+    kmeans_cluster_dict = {}
+    for i, a in zip(names, clusters_list):
+        kmeans_cluster_dict[i] = int(a+1)
+    return kmeans_cluster_dict

{massa_algorithm-1.0.0 → massa_algorithm-2.0.1}/MASSA_Algorithm/MASSAextraction.py

@@ -5,11 +5,11 @@ from rdkit.Chem import AllChem
 def name_extraction(file):
     names = []
     dict_names = {}
-    for i in file:
+    for idx, f in enumerate(file):
         try:
-            names.append(i.GetProp('_Name'))  # Get name of molecules to a list
+            names.append(f.GetProp('_Name'))  # Get name of molecules to a list
             # Get name of molecules to a dict
-            dict_names[i.GetProp('_Name')] = i
+            dict_names[idx] = [f.GetProp('_Name'), f]
         except:
             names.append(None)
     if None in names:  # If any molecule is unnamed it returns an error.
@@ -17,8 +17,39 @@ def name_extraction(file):
         print('Closing...')
         exit()
     else:
-        dataframe = pd.DataFrame({'molecules': pd.Series(dict_names)})
-    return names, dataframe
+        # Dealing with duplicates:
+        duplicates = {}
+        for idx, value in dict_names.items():
+            name = value[0]
+            mol = value[1]
+            if name in duplicates.keys():
+                duplicates[name].append([idx, mol])
+            else:
+                duplicates[name] = [[idx, mol]]
+
+        final_names = []
+        final_names_dict = {}
+        for k, v in duplicates.items():
+            name = k
+            replicates = v
+            if len(replicates) > 1:
+                for r in replicates:
+                    index = r[0]
+                    molecule = r[1]
+                    final_key = f"{name}_idx-_{index}"
+                    molecule.SetProp("_Name", final_key)
+                    final_names_dict[final_key] = molecule
+                    final_names.append(final_key)
+            else:
+                for r in replicates:
+                    index = r[0]
+                    molecule = r[1]
+                    final_key = name
+                    molecule.SetProp("_Name", final_key)
+                    final_names_dict[final_key] = molecule
+                    final_names.append(final_key)
+        dataframe = pd.DataFrame({'molecules': pd.Series(final_names_dict)})
+    return final_names, dataframe
 
 
 def the_biological_handler(sdf_property_names, numberBioAct, BioActAsArgs):

{massa_algorithm-1.0.0 → massa_algorithm-2.0.1}/MASSA_Algorithm/MASSAlogos.py

@@ -20,7 +20,7 @@ def initial_print():
        ██░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░█
      ██░░░░▓▓▓▓▓▓░░░░░▓▓▓▓▓▓░░░░░▓▓▓▓▓▓░░░░█                                 MASSA Algorithm:
    ████░░░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░░░░▓▓▓▓░░░░░█████          Molecular data set sampling  —  Training-Test Separation
-  █▓▓▓███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███▓▓▓█                            Version: v. 1.0.0
+  █▓▓▓███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███▓▓▓█                            Version: v. 2.0.1
  █▒▓▓▒▒▒████░░░░░░░░░░░░░░░░░░░░░░░░░░░░████▒▒▓▓▒█
  ██▓▒▒▒▓▓▓▓██████████████████████████████▓▓▓▒▒▒▒▓█                Developed by: Gabriel Corrêa Veríssimo
  ██▒▒▒▓▓▒▒▒▒▓▓▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▓▓▒▒▒▓▓▒▒██                           LICENSE: AGPL-3.0
@@ -28,3 +28,7 @@ def initial_print():
      ███▓▓▓▓▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▓▓████
         ███████████████████████████████████
         ''')
+
+
+def python_logo():
+    print("🍕 MASSA Algorithm v. 2.0.1: Molecular data set sampling")

{massa_algorithm-1.0.0 → massa_algorithm-2.0.1}/MASSA_Algorithm/MASSAmoloutput.py

@@ -1,7 +1,7 @@
 from rdkit.Chem import AllChem
 
 
-def output_mols(dataframe, file_output):
+def output_mols(dataframe):
     """
     For each molecule, adds the values of the calculated properties,
     the identifications of each cluster and which set the molecule belongs to.
@@ -9,7 +9,6 @@ def output_mols(dataframe, file_output):
 
     Args:
         dataframe (pd.DataFrame): The dataframe of molecules.
-        file_output (str): The path to the output file.
     """
     # Creation of dictionaries with the name of the molecule:
     dict_molecules = dict(
@@ -41,6 +40,8 @@ def output_mols(dataframe, file_output):
 
     # Add the properties to molecules from the name:molecule dictionary:
     for i in dict_molecules.keys():
+        name = dict_molecules[i].GetProp('_Name')
+        dict_molecules[i].SetProp("_Name", name)
         dict_molecules[i].SetProp('Set', str(dict_set[i]))
         dict_molecules[i].SetProp('HBA count', str(dic_hba[i]))
         dict_molecules[i].SetProp('HBD count', str(dic_hbd[i]))
@@ -62,9 +63,27 @@ def output_mols(dataframe, file_output):
 
     # Create a dict_values with just the molecules
     # (the name of the molecule is already part of molecule object):
-    output_mols = dict_molecules.values()
+    out_mols = list(dict_molecules.values())
+    return out_mols
+
+
+def output_file_mols(dataframe, file_output):
+    """
+    For each molecule, adds the values of the calculated properties,
+    the identifications of each cluster and which set the molecule belongs to.
+    Also, it creates the final output .sdf file.
+
+    Args:
+        dataframe (pd.DataFrame): The dataframe of molecules.
+        file_output (str): The path to the output file.
+    """
+
+    # Recovers a list with just the molecules
+    # (the name of the molecule is already part of molecule object):
+    out_mols = output_mols(dataframe)
 
     # Create output ".sdf" file:
     with AllChem.SDWriter(file_output) as w:
-        for m in output_mols:
+        for m in out_mols:
             w.write(m)
+    return out_mols

{massa_algorithm-1.0.0 → massa_algorithm-2.0.1}/MASSA_Algorithm/MASSAod.py

@@ -1,7 +1,7 @@
 import os
 
 
-def output_directory(directory_file_output):
+def output_directory(directory_file_output, flag_dendrogram):
     """
     Creates the output directories.
     """
@@ -10,13 +10,14 @@ def output_directory(directory_file_output):
     except FileExistsError:
         pass
     try:
-        os.makedirs(directory_file_output+'Images/Distance_HCA_Images')
-    except FileExistsError:
-        pass
-    try:
-        os.makedirs(directory_file_output+'Images/Dendrogram_HCA_Images')
+        os.makedirs(directory_file_output+'Images/Distance_Images')
     except FileExistsError:
         pass
+    if flag_dendrogram == True:
+        try:
+            os.makedirs(directory_file_output+'Images/Dendrogram_HCA_Images')
+        except FileExistsError:
+            pass
     try:
         os.makedirs(directory_file_output+'Images/Distribution')
     except FileExistsError: