Merge pull request #637 from Steinbeck-Lab/development

feat: Atom numbering & cis/trans detection

Author: Kohulan

CITATION.cff

@@ -17,7 +17,7 @@ authors:
   given-names: "Kohulan"
   orcid: "https://orcid.org/0000-0003-1066-7792"
 title: "cheminformatics-microservice"
-version: v3.3.0
-doi: 10.5281/zenodo.15575699
-date-released: 2025-06-02
+version: v3.5.0
+doi: 10.5281/zenodo.16890410
+date-released: 2025-08-17
 url: "https://github.com/Steinbeck-Lab/cheminformatics-microservice"

README.md

@@ -156,10 +156,11 @@ This project is licensed under the MIT License. See the [LICENSE](https://github
 ## 📰 Citation
 
 ### Paper
-Chandrasekhar, V., Sharma, N., Schaub, J. et al. Cheminformatics Microservice: unifying access to open cheminformatics toolkits. J Cheminform 15, 98 (2023). [https://doi.org/10.1186/s13321-023-00762-4](https://doi.org/10.1186/s13321-023-00762-4)
+1. Chandrasekhar, V., Sharma, N., Schaub, J. et al. Cheminformatics Microservice: unifying access to open cheminformatics toolkits. J Cheminform 15, 98 (2023). [https://doi.org/10.1186/s13321-023-00762-4](https://doi.org/10.1186/s13321-023-00762-4)
+2. Rajan, K., Chandrasekhar, V., Sharma, N. et al. Cheminformatics Microservice V3: a web portal for chemical structure manipulation and analysis. J Cheminform 17, 142 (2025). [https://doi.org/10.1186/s13321-025-01094-1](https://doi.org/10.1186/s13321-025-01094-1)
 
 ### Software
-Venkata, C., Sharma, N., & Rajan, K. (2023). Cheminformatics Microservice (Version v2.6.0) [Computer software]. [https://zenodo.org/records/13867839](https://zenodo.org/records/13867839)
+- Venkata, C., Sharma, N., Schaub, J., Steinbeck, C., & Rajan, K. (2025). cheminformatics-microservice (Version v3.5.0) [Computer software]. https://doi.org/10.5281/zenodo.16890410
 
 ## 🔧 Maintenance
 

app/modules/coconut/preprocess.py

@@ -250,6 +250,9 @@ def get_COCONUT_preprocessing(
                 },
                 "has_stereo": rdkitmodules.has_potential_stereochemistry(original_mol),
                 "has_stereo_defined": rdkitmodules.has_stereo_defined(original_mol),
+                "has_stereogenic_elements": rdkitmodules.has_cis_trans_stereochemistry(
+                    original_mol
+                ),
                 "descriptors": original_descriptors,
                 "errors": checker.check_molblock(original_mol_block),
             },
@@ -264,6 +267,9 @@ def get_COCONUT_preprocessing(
                     standardized_mol
                 ),
                 "has_stereo_defined": rdkitmodules.has_stereo_defined(standardized_mol),
+                "has_stereogenic_elements": rdkitmodules.has_cis_trans_stereochemistry(
+                    standardized_mol
+                ),
                 "descriptors": standardized_descriptors,
                 "errors": checker.check_molblock(standardized_mol_block),
             },

app/modules/depiction.py

@@ -20,19 +20,26 @@ def get_cdk_depiction(
     unicolor=False,
     highlight="",
     highlight_atoms=None,
+    showAtomNumbers=False,
 ):
     """This function takes the user input SMILES and Depicts it.
 
     using the CDK Depiction Generator.
 
     Args:
         molecule (any): CDK IAtomContainer parsed from SMILES string given by the user.
+        molSize (tuple, optional): Size of the output image. Defaults to (512, 512).
+        rotate (int, optional): Rotation angle in degrees. Defaults to 0.
+        kekulize (bool, optional): Whether to kekulize the molecule. Defaults to True.
+        CIP (bool, optional): Whether to annotate CIP stereochemistry. Defaults to True.
+        unicolor (bool, optional): Whether to use black and white colors. Defaults to False.
+        highlight (str, optional): SMARTS pattern to highlight. Defaults to empty.
+        highlight_atoms (list, optional): List of atom indices to highlight. Defaults to None.
+        showAtomNumbers (bool, optional): Whether to display atom numbers. Defaults to False.
 
     Returns:
         image (SVG): CDK Structure Depiction as an SVG image.
     """
-    print(unicolor)
-
     cdk_base = "org.openscience.cdk"
     StandardGenerator = JClass(
         cdk_base + ".renderer.generators.standard.StandardGenerator",
@@ -75,7 +82,7 @@ def get_cdk_depiction(
             try:
                 Kekulization.kekulize(SDGMol)
             except Exception as e:
-                print(e + "Can't Kekulize molecule")
+                print(str(e) + " Can't Kekulize molecule")
 
         point = JClass(
             cdk_base + ".geometry.GeometryTools",
@@ -86,22 +93,65 @@ def get_cdk_depiction(
             (rotate * JClass("java.lang.Math").PI / 180.0),
         )
 
+        # Add atom numbers if requested
+        if showAtomNumbers:
+            DepictionGenerator = DepictionGenerator.withAtomNumbers()
+
         # Handle highlighting: prioritize atom indices over SMARTS patterns
         if highlight_atoms and len(highlight_atoms) > 0:
-            # For CDK, we need to create substructures from atom indices
-            # This is more complex and would require additional CDK classes
-            # For now, fall back to SMARTS pattern if available
-            if highlight and highlight.strip():
-                tmpPattern = SmartsPattern.create(highlight, SCOB.getInstance())
-                SmartsPattern.prepare(SDGMol)
-                tmpMappings = tmpPattern.matchAll(SDGMol)
-                tmpSubstructures = tmpMappings.toSubstructures()
-                lightBlue = Color(173, 216, 230)
-                DepictionGenerator = DepictionGenerator.withHighlight(
-                    tmpSubstructures, lightBlue
-                ).withOuterGlowHighlight()
-            # Note: Direct atom index highlighting in CDK requires more complex implementation
-            # This would need creating IAtomContainerSet from specific atoms
+            # Create atom sets from indices for highlighting
+            AtomContainer = JClass(cdk_base + ".AtomContainer")
+            AtomContainerSet = JClass(cdk_base + ".AtomContainerSet")
+
+            # Create a set of substructures from atom indices
+            tmpSubstructures = AtomContainerSet()
+
+            # If highlight_atoms is a list of lists, each list is a separate substructure
+            if isinstance(highlight_atoms[0], list):
+                # Multiple substructures (e.g., multiple sugars)
+                for atom_indices in highlight_atoms:
+                    if len(atom_indices) > 0:
+                        subset = AtomContainer()
+                        for idx in atom_indices:
+                            if idx < SDGMol.getAtomCount():
+                                subset.addAtom(SDGMol.getAtom(idx))
+                        # Add bonds between highlighted atoms
+                        for i, idx1 in enumerate(atom_indices):
+                            for idx2 in atom_indices[i + 1:]:
+                                if (
+                                    idx1 < SDGMol.getAtomCount()
+                                    and idx2 < SDGMol.getAtomCount()
+                                ):
+                                    bond = SDGMol.getBond(
+                                        SDGMol.getAtom(idx1), SDGMol.getAtom(idx2)
+                                    )
+                                    if bond is not None:
+                                        subset.addBond(bond)
+                        tmpSubstructures.addAtomContainer(subset)
+            else:
+                # Single substructure
+                subset = AtomContainer()
+                for idx in highlight_atoms:
+                    if idx < SDGMol.getAtomCount():
+                        subset.addAtom(SDGMol.getAtom(idx))
+                # Add bonds between highlighted atoms
+                for i, idx1 in enumerate(highlight_atoms):
+                    for idx2 in highlight_atoms[i + 1:]:
+                        if (
+                            idx1 < SDGMol.getAtomCount()
+                            and idx2 < SDGMol.getAtomCount()
+                        ):
+                            bond = SDGMol.getBond(
+                                SDGMol.getAtom(idx1), SDGMol.getAtom(idx2)
+                            )
+                            if bond is not None:
+                                subset.addBond(bond)
+                tmpSubstructures.addAtomContainer(subset)
+
+            lightBlue = Color(173, 216, 230)
+            DepictionGenerator = DepictionGenerator.withHighlight(
+                tmpSubstructures, lightBlue
+            ).withOuterGlowHighlight()
         elif highlight and highlight.strip():
             tmpPattern = SmartsPattern.create(highlight, SCOB.getInstance())
             SmartsPattern.prepare(SDGMol)
@@ -138,6 +188,7 @@ def get_rdkit_depiction(
     unicolor=False,
     highlight: str = "",
     highlight_atoms=None,
+    showAtomNumbers=False,
 ) -> str:
     """
     Generate a 2D depiction of the input molecule using RDKit.
@@ -150,6 +201,8 @@ def get_rdkit_depiction(
         CIP (bool, optional): Whether to assign CIP stereochemistry. Defaults to False.
         unicolor (bool, optional): Whether to use a unicolor palette. Defaults to False.
         highlight (str, optional): SMARTS pattern to highlight atoms/bonds. Defaults to empty.
+        highlight_atoms (list, optional): List of atom indices to highlight. Defaults to None.
+        showAtomNumbers (bool, optional): Whether to display atom numbers. Defaults to False.
 
     Returns:
         str: RDKit Structure Depiction as an SVG image.
@@ -176,6 +229,12 @@ def get_rdkit_depiction(
     if unicolor:
         drawer.drawOptions().useBWAtomPalette()
 
+    # Add atom numbers if requested
+    if showAtomNumbers:
+        # Set atom numbers as notes on each atom
+        for atom in mc.GetAtoms():
+            atom.SetProp("atomNote", str(atom.GetIdx()))
+
     # Handle highlighting based on priority: anchor atoms + SMARTS pattern, then atom indices, then SMARTS pattern alone
     if highlight_atoms and len(highlight_atoms) > 0 and highlight:
         # Combined approach: Use SMARTS pattern but only highlight the match that contains the anchor atoms
@@ -222,12 +281,11 @@ def get_rdkit_depiction(
         hit_ats = tuple(highlight_atoms)
         # Find ALL bonds that connect atoms within the functional group
         hit_bonds = []
-        for i, atom1_idx in enumerate(hit_ats):
-            for j, atom2_idx in enumerate(hit_ats):
-                if i < j:  # Avoid duplicate bonds
-                    bond = mc.GetBondBetweenAtoms(atom1_idx, atom2_idx)
-                    if bond:
-                        hit_bonds.append(bond.GetIdx())
+        for i in range(len(hit_ats)):
+            for j in range(i + 1, len(hit_ats)):
+                bond = mc.GetBondBetweenAtoms(hit_ats[i], hit_ats[j])
+                if bond:
+                    hit_bonds.append(bond.GetIdx())
 
         rdMolDraw2D.PrepareAndDrawMolecule(
             drawer, mc, highlightAtoms=hit_ats, highlightBonds=hit_bonds

app/modules/toolkits/cdk_wrapper.py

@@ -28,18 +28,19 @@ def setup_jvm():
 
     if not isJVMStarted():
         paths = {
-            "cdk-2.10": "https://github.com/cdk/cdk/releases/download/cdk-2.10/cdk-2.10.jar",
-            "SugarRemovalUtility-jar-with-dependencies": "https://github.com/JonasSchaub/SugarRemoval/releases/download/v1.3.2/SugarRemovalUtility-jar-with-dependencies.jar",
+            "cdk-2.11": "https://github.com/cdk/cdk/releases/download/cdk-2.11/cdk-2.11.jar",
+            "SugarRemovalUtility-jar-with-dependencies": "https://github.com/JonasSchaub/SugarRemoval/releases/download/v1.6/SugarRemovalUtility-jar-with-dependencies.jar",
             "centres": "https://github.com/SiMolecule/centres/releases/download/1.0/centres.jar",
             "opsin-cli-2.8.0-jar-with-dependencies": "https://github.com/dan2097/opsin/releases/download/2.8.0/opsin-cli-2.8.0-jar-with-dependencies.jar",
         }
 
         jar_paths = {
-            key: str(pystow.join("STOUT-V2")) + f"/{key}.jar" for key in paths.keys()
+            key: str(pystow.join("JAVA_Packages")) + f"/{key}.jar"
+            for key in paths.keys()
         }
         for key, url in paths.items():
             if not os.path.exists(jar_paths[key]):
-                pystow.ensure("STOUT-V2", url=url)
+                pystow.ensure("JAVA_Packages", url=url)
 
         startJVM("-ea", "-Xmx4096M", classpath=[jar_paths[key] for key in jar_paths])
 
@@ -68,6 +69,23 @@ def get_CDK_IAtomContainer(smiles: str):
     return molecule
 
 
+def get_CDK_IAtomContainer_from_molblock(molblock: str):
+    """This function takes a MOL block and creates a CDK IAtomContainer.
+
+    Args:
+        molblock (str): MOL block string as input.
+
+    Returns:
+        mol (object): IAtomContainer with CDK.
+    """
+    SCOB = JClass(cdk_base + ".silent.SilentChemObjectBuilder")
+    StringReader = JClass("java.io.StringReader")(molblock)
+    MDLV2000Reader = JClass(cdk_base + ".io.MDLV2000Reader")(StringReader)
+    molecule = MDLV2000Reader.read(SCOB.getInstance().newAtomContainer())
+    MDLV2000Reader.close()
+    return molecule
+
+
 def get_CDK_SDG(molecule: any):
     """This function takes the input IAtomContainer and Creates a.
 

app/modules/toolkits/rdkit_wrapper.py

@@ -862,12 +862,14 @@ def get_ertl_functional_groups(molecule: any) -> list:
                 try:
                     # Extract information from IFG object
                     group_data = {
-                        "atomIds": list(fragment.atomIds)
-                        if hasattr(fragment, "atomIds")
-                        else [],
-                        "atoms": str(fragment.atoms)
-                        if hasattr(fragment, "atoms")
-                        else "",
+                        "atomIds": (
+                            list(fragment.atomIds)
+                            if hasattr(fragment, "atomIds")
+                            else []
+                        ),
+                        "atoms": (
+                            str(fragment.atoms) if hasattr(fragment, "atoms") else ""
+                        ),
                         "type": str(fragment.type) if hasattr(fragment, "type") else "",
                         "description": str(
                             fragment
@@ -896,7 +898,7 @@ def get_standardized_tautomer(
     """Generate the standardized tautomer SMILES for a given molecule.
 
     Args:
-        molecule (any): RDKit molecule object.
+        molecule (Chem.Mol): An RDKit molecule object representing the molecular structure.
         isomeric (bool, optional): Flag to generate isomeric SMILES. Defaults to True.
 
     Returns:
@@ -920,3 +922,36 @@ def get_standardized_tautomer(
             return new_smiles
     else:
         return "Error Check input SMILES"
+
+
+def has_cis_trans_stereochemistry(molecule: any) -> bool:
+    """
+    Detect whether a molecule has cis/trans (E/Z) stereochemistry assigned.
+
+    Parameters:
+    -----------
+    molecule (Chem.Mol): An RDKit molecule object representing the molecular structure.
+
+    Returns:
+    --------
+    bool
+        True if cis/trans stereochemistry is assigned, False otherwise
+    """
+    if molecule is None:
+        return False
+
+    # Check each bond for stereochemistry
+    for bond in molecule.GetBonds():
+        # Check if bond is a double bond
+        if bond.GetBondType() == Chem.BondType.DOUBLE:
+            # Check if stereochemistry is assigned
+            stereo = bond.GetStereo()
+            if stereo in [
+                Chem.BondStereo.STEREOE,
+                Chem.BondStereo.STEREOZ,
+                Chem.BondStereo.STEREOTRANS,
+                Chem.BondStereo.STEREOCIS,
+            ]:
+                return True
+
+    return False