application file

README.md

@@ -1,13 +1,45 @@
 ---
-title: CDK Web
-emoji: 🌖
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 4.37.1
+title: CDK_library
 app_file: app.py
-pinned: false
-license: apache-2.0
+sdk: gradio
+sdk_version: 4.36.1
 ---
+# Molecular Descriptor Analysis and Chemical Reaction Visualization
+
+This repository provides a web-based interface using Gradio for performing various molecular descriptor calculations, geometric analyses, substructure checks, similarity calculations, and chemical reaction visualizations. It integrates functionalities from RDKit and CDK libraries, enabling users to interactively analyze chemical data without needing extensive programming knowledge.
+
+## Features
+
+- **Calculate Descriptors:** Input SMILES strings and optionally include 3D coordinates to generate MolFile outputs and download descriptors as Excel.
+- **Geometric Values:** Compute molecular weight, centroid, mean distance to centroid, and max distance to centroid for a given molecule and display its structure.
+- **Check Substructure:** Check if a specified substructure is present within a molecule and visualize both structures.
+- **Calculate Similarity:** Compute Tanimoto similarity coefficient between two molecules based on their SMILES strings.
+- **Chemical Reaction:** Define chemical reactions using SMARTS notation, input reactant SMILES strings, and visualize the resulting reaction products interactively.
+
+## Usage
+
+1. **Setup Environment:**
+   - Ensure Python 3.7+ is installed.
+   - Install required packages using `pip install -r requirements.txt`.
+
+2. **Run the Application:**
+   - Execute `python app.py` to start the Gradio interface locally.
+   - Access the interface at `http://localhost:7860`.
+
+3. **Interface Navigation:**
+   - Use the tabs provided to input SMILES strings and parameters for the desired chemical analysis or reaction.
+   - Click buttons to perform calculations or reactions and view results interactively.
+
+4. **Contribute:**
+   - Fork the repository, make your changes, and submit a pull request.
+   - Report any issues or suggest improvements through GitHub issues.
+
+## Dependencies
+
+- RDKit: Open-source cheminformatics software.
+- CDK: Chemistry Development Kit for molecular descriptor calculation.
+- Gradio: User-friendly Python library for creating UIs around ML models.
+
+## License
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

app.py

@@ -0,0 +1,216 @@
+import gradio as gr
+from CDK_pywrapper import CDK
+from rdkit import Chem
+from rdkit.Chem import Descriptors, Draw, AllChem, rdMolDescriptors
+from rdkit.Chem.Fingerprints import FingerprintMols
+from rdkit.DataStructs import TanimotoSimilarity
+import pandas as pd
+import numpy as np
+import tempfile
+
+
+# Function to convert SMILES to MolFile
+def convert_smiles_to_mol(smiles_list, checkbox):
+
+    if checkbox == True:
+        cdk = CDK(ignore_3D=False)
+    else:
+        cdk = CDK()
+    smiles_list = list(smiles_list.split(','))
+    try:
+        mols = [Chem.AddHs(Chem.MolFromSmiles(smiles)) for smiles in smiles_list]
+
+        molfile = cdk.calculate(mols)
+
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx') as tmp:
+                file_path = tmp.name
+            molfile.to_excel(file_path, index=False)
+            return molfile,file_path
+        except Exception as e:
+            return molfile,str(e)
+
+    except Exception as e:
+        return str(e), str(e)
+
+
+# Function to calculate Molecular Weight
+def calculate_molecular_weight(smiles):
+    if smiles is None:
+        return "SMILES string is None"
+    try:
+        molecule = Chem.MolFromSmiles(smiles)
+        if molecule is None:
+            return "Invalid SMILES"
+        mol_weight = Descriptors.MolWt(molecule)
+        img = Draw.MolToImage(molecule)
+        return mol_weight, img
+    except Exception as e:
+        return str(e)
+    
+def get_geometric_descriptors(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            return "Invalid SMILES string"
+        
+        # Add hydrogens and compute 3D coordinates
+        mol = Chem.AddHs(mol)
+        AllChem.EmbedMolecule(mol, AllChem.ETKDG())
+        AllChem.UFFOptimizeMolecule(mol)
+
+        # Calculate geometric descriptors
+        conformer = mol.GetConformer()
+        coords = conformer.GetPositions()
+        
+        centroid = np.mean(coords, axis=0)
+        centroid = np.round(centroid, 12)
+        distances = np.linalg.norm(coords - centroid, axis=1)
+        mol_weight = Descriptors.MolWt(mol)
+
+        geometric_descriptors = {
+            'Molecular Weight': mol_weight,
+            'Centroid': centroid.tolist(),
+            'Mean Distance To Centroid': np.mean(distances),
+            'Max Distance To Centroid': np.max(distances)
+        }
+        img = Draw.MolToImage(mol)
+        df = pd.DataFrame([geometric_descriptors])
+        return df.T,img
+    except Exception as e:
+        return str(e), str(e)
+
+# Function to check if a substructure is present
+def check_substructure(smiles, substructure_smiles):
+    # Convert the SMILES strings to RDKit molecule objects
+    molecule = Chem.MolFromSmiles(smiles)
+    substructure = Chem.MolFromSmiles(substructure_smiles)
+    
+    # Check if the molecule is None (invalid SMILES)
+    if molecule is None or substructure is None:
+        return "Error","Error","Invalid SMILES string provided."
+    
+    # Use RDKit's HasSubstructMatch to check for the substructure
+    val = molecule.HasSubstructMatch(substructure)
+    img1 = Draw.MolToImage(molecule)
+
+    if val:
+        try:
+            molecule = Chem.MolFromSmiles(smiles)
+            sub_molecule = Chem.MolFromSmiles(substructure_smiles)
+            img1 = Draw.MolToImage(molecule)
+            img2 = Draw.MolToImage(sub_molecule)
+            return img1, img2, "Substructure is present."
+        except Exception as e:
+            return str(e), str(e), "Substructure is present."        
+    else:
+        return img1,"NO Image","Substructure is not present."
+
+def calculate_similarity(smiles1, smiles2):
+    try:
+        mol1 = Chem.MolFromSmiles(smiles1)
+        mol2 = Chem.MolFromSmiles(smiles2)
+        
+        if mol1 is None or mol2 is None:
+            return "Invalid SMILES string"
+        
+        fp1 = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol1, radius=2, nBits=2048)
+        fp2 = rdMolDescriptors.GetMorganFingerprintAsBitVect(mol2, radius=2, nBits=2048)
+        
+        similarity = TanimotoSimilarity(fp1, fp2)
+        return similarity
+    except Exception as e:
+        return str(e)
+    
+def perform_reaction(reactant1_smiles, reactant2_smiles, reaction_smarts):
+    try:
+        # Define the reaction using SMARTS provided by the user
+        reaction = AllChem.ReactionFromSmarts(reaction_smarts)
+        
+        # Convert SMILES to RDKit molecules
+        reactant1 = Chem.MolFromSmiles(reactant1_smiles)
+        reactant2 = Chem.MolFromSmiles(reactant2_smiles)
+        
+        if reactant1 is None or reactant2 is None:
+            return "Invalid SMILES string(s)", None
+        
+        # Run the reaction
+        products = reaction.RunReactants((reactant1, reactant2))
+        
+        # Create a grid image of reactants and products
+        all_mols = [reactant1, reactant2]
+        legends = ["Reactant 1", "Reactant 2"]
+        for i, product_set in enumerate(products):
+            for j, product in enumerate(product_set):
+                all_mols.append(product)
+                legends.append(f'Product {i+1}.{j+1}')
+        
+        img = Draw.MolsToGridImage(all_mols, molsPerRow=4, subImgSize=(300, 300), legends=legends)
+        return "Reaction Successful", img
+    
+    except Exception as e:
+        return str(e), None
+
+# Gradio Interface
+def generate_reaction_image(reaction_smarts,reactant1_smiles, reactant2_smiles):
+    result, img = perform_reaction(reactant1_smiles, reactant2_smiles, reaction_smarts)
+    return result, img
+
+
+
+
+# Gradio Interface
+with gr.Blocks(theme='earneleh/paris') as demo:
+     gr.Markdown("### CDK Functionality with Gradio Interface")
+    
+     with gr.Tab("Calculate Descriptors"):
+        smiles_input = gr.Textbox(label="SMILES", info="Enter SMILES separated by comma")
+        checkbox = gr.Checkbox(label="Include 3D Coordinates")
+        molfile_output = gr.Textbox(label="MolFile", lines=10)
+        convert_button = gr.Button("Calculate")
+        download_link = gr.File(label="Download Descriptors as Excel")
+        convert_button.click(fn=convert_smiles_to_mol, inputs=[smiles_input, checkbox], outputs=[molfile_output,download_link])
+
+     with gr.Tab("Geometric Values"):
+        with gr.Row():
+            with gr.Column(min_width=800):
+                smiles_input_mw = gr.Textbox(label="SMILE")
+                weight_output = gr.TextArea(label="Geometric Values", lines=8, show_copy_button=True)
+                calculate_button = gr.Button("Calculate")
+            with gr.Column():
+                image_output = gr.Image(label="Molecular Structure", height=400, width=500)
+                calculate_button.click(fn=get_geometric_descriptors, inputs=smiles_input_mw,outputs=[weight_output, image_output])
+            
+     with gr.Tab("Check Substructure"):
+        with gr.Row():
+            with gr.Column():
+                smiles_input_sub = gr.Textbox(label="SMILES")
+                substructure_input = gr.Textbox(label="Substructure SMILES")
+                substructure_output = gr.Label(label="Is Substructure Present?")
+                check_button = gr.Button("Check")
+            with gr.Column():
+                image_output1 = gr.Image(label="Molecular Structure", height=350, width=500)
+                image_output2 = gr.Image(label="Sub_Molecular Structure", height=350, width=500)
+                check_button.click(fn=check_substructure, inputs=[smiles_input_sub, substructure_input], outputs=[image_output1, image_output2, substructure_output])
+
+    
+     with gr.Tab("Calculate Similarity"):
+        smiles_input1 = gr.Textbox(label="SMILES 1")
+        smiles_input2 = gr.Textbox(label="SMILES 2")
+        similarity_output = gr.Number(label="Similarity (Tanimoto)")
+        calculate_button_sim = gr.Button("Calculate Similarity")
+        calculate_button_sim.click(fn=calculate_similarity, inputs=[smiles_input1, smiles_input2], outputs=similarity_output)
+
+     with gr.Tab("Chemical Reaction"):
+        reaction_smarts_input = gr.Textbox(label="Reaction SMARTS",value="[O:2]=[C:1][OH].[N:3]>>[O:2]=[C:1][N:3]")
+        smiles_input1 = gr.Textbox(label="Reactant 1 SMILES", value="OC=O")
+        smiles_input2 = gr.Textbox(label="Reactant 2 SMILES", value= "NCC")
+        calculate_button = gr.Button("Perform Reaction")
+
+        result_output = gr.Label(label="Result")
+        image_output = gr.Image(label="Reaction Image", interactive=True)
+        calculate_button.click(fn=generate_reaction_image, inputs=[reaction_smarts_input, smiles_input1, smiles_input2], outputs=[result_output, image_output])
+
+
+# Launch Gradio Interface
+demo.launch(share=True)

requirements.txt

@@ -0,0 +1,6 @@
+CDK-pywrapper
+gradio
+rdkit
+pandas
+numpy
+tempfile