synkit 0.0.16__tar.gz → 1.0.1__tar.gz

{synkit-0.0.16 → synkit-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.16
+Version: 1.0.1
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 
 **Toolkit for Synthesis Planning**
 
-SynKit is a collection of tools designed to support the planning and execution of chemical synthesis. 
+SynKit is a collection of tools designed to support the planning and execution of chemical synthesis. Check out the [documentation](https://tieulongphan.github.io/SynKit/) for a comprehensive description of its features.
 
 ![SynKit](https://raw.githubusercontent.com/TieuLongPhan/SynKit/main/Data/Figure/synkit.png)
 
@@ -96,7 +96,7 @@ For more details on each utility within the repository, please refer to the docu
    ```bash
    docker pull tieulongphan/synkit:latest
    # or a specific version:
-   docker pull tieulongphan/synkit:0.1.0
+   docker pull tieulongphan/synkit:1.0.0
    ```
    Run a container (sanity check):
    ```

{synkit-0.0.16 → synkit-1.0.1}/README.md

@@ -13,7 +13,7 @@
 
 **Toolkit for Synthesis Planning**
 
-SynKit is a collection of tools designed to support the planning and execution of chemical synthesis. 
+SynKit is a collection of tools designed to support the planning and execution of chemical synthesis. Check out the [documentation](https://tieulongphan.github.io/SynKit/) for a comprehensive description of its features.
 
 ![SynKit](https://raw.githubusercontent.com/TieuLongPhan/SynKit/main/Data/Figure/synkit.png)
 
@@ -65,7 +65,7 @@ For more details on each utility within the repository, please refer to the docu
    ```bash
    docker pull tieulongphan/synkit:latest
    # or a specific version:
-   docker pull tieulongphan/synkit:0.1.0
+   docker pull tieulongphan/synkit:1.0.0
    ```
    Run a container (sanity check):
    ```

{synkit-0.0.16 → synkit-1.0.1}/pyproject.toml

@@ -4,17 +4,17 @@ build-backend = "hatchling.build"
 
 [project]
 name = "synkit"
-version = "0.0.16"
-license = { text = "MIT" }
-license-files = ["LICENSE"]
-authors = [
-  { name = "Tieu Long Phan", email = "tieu@bioinf.uni-leipzig.de" }
-]
+version = "1.0.1"
 description = "Utility for reaction modeling using graph grammar"
 readme = "README.md"
 long-description = { file = "CHANGELOG.md" }
 long-description-content-type = "text/markdown"
 requires-python = ">=3.11"
+license = { text = "MIT" }
+license-files = ["LICENSE"]
+authors = [
+  { name = "Tieu Long Phan", email = "tieu@bioinf.uni-leipzig.de" }
+]
 classifiers = [
   "Programming Language :: Python :: 3",
   "License :: OSI Approved :: MIT License",
@@ -39,28 +39,16 @@ docs = [
 ]
 
 [project.urls]
-homepage = "https://github.com/TieuLongPhan/SynKit"
-source   = "https://github.com/TieuLongPhan/SynKit"
-issues   = "https://github.com/TieuLongPhan/SynKit/issues"
+homepage      = "https://github.com/TieuLongPhan/SynKit"
+source        = "https://github.com/TieuLongPhan/SynKit"
+issues        = "https://github.com/TieuLongPhan/SynKit/issues"
 documentation = "https://tieulongphan.github.io/SynKit/"
 
 [tool.hatch.build]
-# include non-Python data files in all build targets
-include = [
-  { path = "synkit/Data/*.json" },
-  { path = "synkit/Data/*.json.gz" }
-]
+packages = ["synkit"]
 
 [tool.hatch.build.targets.wheel]
-# wheel also gets the same data files
-include = [
-  "synkit/Data/*.json",
-  "synkit/Data/*.json.gz"
-]
+include = ["synkit/Data/**"]
 
 [tool.hatch.build.targets.sdist]
-# source sdist likewise
-include = [
-  "synkit/Data/*.json",
-  "synkit/Data/*.json.gz"
-]
+include = ["synkit/Data/**"]

synkit-1.0.1/synkit/Chem/Cluster/butina.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+from typing import List, Optional
+
+import numpy as np
+from rdkit.DataStructs import cDataStructs, CreateFromBitString, BulkTanimotoSimilarity
+from rdkit.ML.Cluster import Butina
+from sklearn.manifold import TSNE
+import matplotlib.pyplot as plt
+
+
+class ButinaCluster:
+    """Cluster chemical fingerprint vectors using the Butina algorithm from
+    RDKit, with integrated t-SNE visualization of clusters.
+
+    Key features
+    ------------
+    * **Butina clustering** – fast hierarchical clustering with a similarity cutoff.
+    * **t-SNE visualization** – 2D embedding of fingerprints, highlighting top‑k clusters.
+    * **NumPy support** – accepts 2D arrays of 0/1 fingerprint data.
+    * **Configurable** – user‑defined cutoff, perplexity, and top‑k highlight.
+
+    Quick start
+    -----------
+    >>> from synkit.Chem.Fingerprint.fingerprint_clusterer import ButinaCluster
+    >>> clusters = ButinaCluster.cluster(arr, cutoff=0.3)
+    >>> ButinaCluster.visualize(arr, clusters, k=5)
+    """
+
+    @staticmethod
+    def cluster(arr: np.ndarray, cutoff: float = 0.2) -> List[List[int]]:
+        """Perform Butina clustering on fingerprint bit-vectors.
+
+        :param arr: 2D array of shape (n_samples, n_bits) with 0/1
+            dtype.
+        :type arr: np.ndarray
+        :param cutoff: Distance cutoff (1 – similarity) to form
+            clusters. Defaults to 0.2.
+        :type cutoff: float
+        :returns: List of clusters, each a list of sample indices.
+        :rtype: list of list of int
+        """
+        # Convert rows to RDKit ExplicitBitVect
+        fps: List[cDataStructs.ExplicitBitVect] = []
+        for row in arr:
+            bitstr = "".join(str(int(b)) for b in row.tolist())
+            fps.append(CreateFromBitString(bitstr))
+
+        n = len(fps)
+        # Build flattened upper‐triangular distance list
+        distances: List[float] = []
+        for i in range(n):
+            # fmt: off
+            sims = BulkTanimotoSimilarity(fps[i], fps[i + 1:])
+            # fmt: on
+            distances.extend((1.0 - np.array(sims, dtype=float)).tolist())
+
+        # Cluster: ClusterData(distanceList, nPts, cutoff, isDistData)
+        clusters = Butina.ClusterData(distances, n, cutoff, True)
+        return clusters
+
+    @staticmethod
+    def visualize(
+        arr: np.ndarray,
+        clusters: List[List[int]],
+        k: Optional[int] = None,
+        perplexity: float = 30.0,
+        random_state: int = 42,
+    ) -> None:
+        """Visualize clusters in 2D via t-SNE embedding.
+
+        :param arr: 2D array of shape (n_samples, n_features) with fingerprint data.
+        :type arr: np.ndarray
+        :param clusters: Clusters as returned by `cluster()`.
+        :type clusters: list of list of int
+        :param k: If provided, highlight only the top‑k largest clusters; others shown as 'Other'.
+        :type k: int or None
+        :param perplexity: t-SNE perplexity parameter. Defaults to 30.0.
+        :type perplexity: float
+        :param random_state: Random seed for reproducibility. Defaults to 42.
+        :type random_state: int
+        :returns: None
+        :rtype: NoneType
+
+        :example:
+        >>> clusters = ButinaCluster.cluster(arr, cutoff=0.3)
+        >>> ButinaCluster.visualize(arr, clusters, k=5)
+        """
+        n = arr.shape[0]
+        # assign labels: cluster idx or -1 for 'Other'
+        labels = np.full(n, -1, dtype=int)
+        # sort clusters by size
+        sorted_idx = sorted(
+            range(len(clusters)), key=lambda i: len(clusters[i]), reverse=True
+        )
+        top = set(sorted_idx[:k]) if k is not None else set(sorted_idx)
+        for idx, cluster in enumerate(clusters):
+            for i in cluster:
+                labels[i] = idx if idx in top else -1
+
+        # compute t-SNE embedding
+        tsne = TSNE(n_components=2, perplexity=perplexity, random_state=random_state)
+        emb = tsne.fit_transform(arr)
+
+        # plot
+        plt.figure(figsize=(8, 6))
+        unique = sorted(set(labels))
+        for lab in unique:
+            mask = labels == lab
+            if lab == -1:
+                plt.scatter(
+                    emb[mask, 0], emb[mask, 1], color="gray", alpha=0.3, label="Other"
+                )
+            else:
+                plt.scatter(
+                    emb[mask, 0], emb[mask, 1], alpha=0.7, label=f"Cluster {lab}"
+                )
+        plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left")
+        plt.title("t-SNE visualization of Butina clusters")
+        plt.xlabel("t-SNE dim 1")
+        plt.ylabel("t-SNE dim 2")
+        plt.tight_layout()
+        plt.show()
+
+    def __str__(self) -> str:
+        """Short description of the clusterer.
+
+        :returns: Class name.
+        :rtype: str
+        """
+        return "<ButinaCluster>"
+
+    def help(self) -> None:
+        """Print usage summary for clustering and visualization.
+
+        :returns: None
+        :rtype: NoneType
+        """
+        print("ButinaCluster.cluster(arr, cutoff=0.2)")
+        print("ButinaCluster.visualize(arr, clusters, k=None, perplexity=30.0)")

synkit-1.0.1/synkit/Chem/Fingerprint/fp_calculator.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+from typing import Any, Dict, List
+from joblib import Parallel, delayed
+
+from synkit.IO.debug import configure_warnings_and_logs
+from synkit.Chem.Fingerprint.transformation_fp import TransformationFP
+
+configure_warnings_and_logs(True, True)
+
+
+class FPCalculator:
+    """Calculate fingerprint vectors for chemical reactions represented by
+    SMILES strings.
+
+    :cvar fps: Shared fingerprint engine instance.
+    :vartype fps: TransformationFP
+    :cvar VALID_FP_TYPES: Supported fingerprint type identifiers.
+    :vartype VALID_FP_TYPES: List[str]
+    :param n_jobs: Number of parallel jobs to use for batch processing.
+    :type n_jobs: int
+    :param verbose: Verbosity level for parallel execution.
+    :type verbose: int
+    """
+
+    fps: TransformationFP = TransformationFP()
+    VALID_FP_TYPES: List[str] = [
+        "drfp",
+        "avalon",
+        "maccs",
+        "torsion",
+        "pharm2D",
+        "ecfp2",
+        "ecfp4",
+        "ecfp6",
+        "fcfp2",
+        "fcfp4",
+        "fcfp6",
+        "rdk5",
+        "rdk6",
+        "rdk7",
+        "ap",
+    ]
+
+    def __init__(self, n_jobs: int = 1, verbose: int = 0) -> None:
+        """Initialize the FPCalculator.
+
+        :param n_jobs: Number of parallel jobs to use for fingerprint
+            computation.
+        :type n_jobs: int
+        :param verbose: Verbosity level for the parallel processing.
+        :type verbose: int
+        """
+        self.n_jobs = n_jobs
+        self.verbose = verbose
+
+    def _validate_fp_type(self, fp_type: str) -> None:
+        """Ensure the requested fingerprint type is supported.
+
+        :param fp_type: Fingerprint type identifier to validate.
+        :type fp_type: str
+        :raises ValueError: If `fp_type` is not in VALID_FP_TYPES.
+        """
+        if fp_type not in self.VALID_FP_TYPES:
+            valid = ", ".join(self.VALID_FP_TYPES)
+            raise ValueError(
+                f"Unsupported fingerprint type '{fp_type}'. Supported types: {valid}."
+            )
+
+    @staticmethod
+    def dict_process(
+        data_dict: Dict[str, Any],
+        rsmi_key: str,
+        symbol: str = ">>",
+        fp_type: str = "ecfp4",
+        absolute: bool = True,
+    ) -> Dict[str, Any]:
+        """Compute a fingerprint for a single reaction SMILES entry and add it
+        to the dict.
+
+        :param data_dict: Dictionary containing reaction data.
+        :type data_dict: dict
+        :param rsmi_key: Key in `data_dict` for the reaction SMILES string.
+        :type rsmi_key: str
+        :param symbol: Delimiter between reactant and product in the SMILES.
+        :type symbol: str
+        :param fp_type: Fingerprint type to compute.
+        :type fp_type: str
+        :param absolute: Whether to take absolute values of the fingerprint difference.
+        :type absolute: bool
+        :returns: The input dictionary with a new key `fp_{fp_type}` holding the fingerprint vector.
+        :rtype: dict
+        :raises ValueError: If `rsmi_key` is missing in `data_dict`.
+        """
+        if rsmi_key not in data_dict:
+            raise ValueError(f"Key '{rsmi_key}' not found in data dictionary.")
+        # compute and insert fingerprint
+        vec = FPCalculator.fps.fit(
+            data_dict[rsmi_key], symbols=symbol, fp_type=fp_type, abs=absolute
+        )
+        data_dict[f"{fp_type}"] = vec
+        return data_dict
+
+    def parallel_process(
+        self,
+        data_dicts: List[Dict[str, Any]],
+        rsmi_key: str,
+        symbol: str = ">>",
+        fp_type: str = "ecfp4",
+        absolute: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """Compute fingerprints for a batch of reaction dictionaries in
+        parallel.
+
+        :param data_dicts: List of dictionaries, each containing a reaction SMILES.
+        :type data_dicts: list of dict
+        :param rsmi_key: Key in each dict for the reaction SMILES string.
+        :type rsmi_key: str
+        :param symbol: Delimiter between reactant and product in the SMILES.
+        :type symbol: str
+        :param fp_type: Fingerprint type to compute.
+        :type fp_type: str
+        :param absolute: Whether to take absolute values of the fingerprint difference.
+        :type absolute: bool
+        :returns: A list of dictionaries augmented with `fp_{fp_type}` entries.
+        :rtype: list of dict
+        :raises ValueError: If `fp_type` is unsupported or any dict is missing `rsmi_key`.
+        """
+        # Validate fingerprint type once
+        self._validate_fp_type(fp_type)
+
+        # Process in parallel
+        results = Parallel(n_jobs=self.n_jobs, verbose=self.verbose)(
+            delayed(self.dict_process)(dd, rsmi_key, symbol, fp_type, absolute)
+            for dd in data_dicts
+        )
+        return results
+
+    def __str__(self) -> str:
+        """Short string summarizing the calculator configuration.
+
+        :returns: A summary of n_jobs and verbosity.
+        :rtype: str
+        """
+        return f"<FPCalculator n_jobs={self.n_jobs} verbose={self.verbose}>"
+
+    def help(self) -> None:
+        """Print details about supported fingerprint types and usage.
+
+        :returns: None
+        :rtype: NoneType
+        """
+        print("FPCalculator supports the following fingerprint types:")
+        for t in self.VALID_FP_TYPES:
+            print("  -", t)
+        print(f"Configured for {self.n_jobs} parallel jobs, verbose={self.verbose}")

synkit-1.0.1/synkit/Chem/Fingerprint/smiles_featurizer.py

@@ -0,0 +1,258 @@
+"""smiles_featurizer.py
+=======================
+Utility for converting SMILES strings into various cheminformatics fingerprints,
+with optional NumPy‐array conversion.
+
+Key features
+------------
+* **Multi‐fingerprint support** – MACCS, Avalon, ECFP/FCFP, RDKit, AtomPair, Torsion, Pharm2D
+* **SMILES validation** – raises on invalid input
+* **Array conversion** – output as NumPy arrays for ML pipelines
+* **Extensible** – add new methods or override via subclassing
+
+Quick start
+-----------
+>>> from synkit.Chem.Fingerprint.smiles_featurizer import SmilesFeaturizer
+>>> arr = SmilesFeaturizer.featurize_smiles("CCO", "ecfp4", convert_to_array=True)
+"""
+
+from __future__ import annotations
+from typing import Any
+
+import numpy as np
+from rdkit import Chem, DataStructs
+from rdkit.Chem import AllChem, MACCSkeys
+from rdkit.Chem.AtomPairs import Pairs, Torsions
+from rdkit.Avalon import pyAvalonTools as fpAvalon
+from rdkit.Chem.Pharm2D import Gobbi_Pharm2D, Generate
+
+
+class SmilesFeaturizer:
+    """Convert SMILES strings into chemical fingerprint vectors.
+
+    :cvar None: This class only provides static/​class methods and holds no state.
+
+    Supported fingerprint methods:
+      - MACCS keys
+      - Avalon
+      - ECFP/FCFP (Morgan)
+      - RDKit topological
+      - AtomPair
+      - Torsion
+      - 2D Pharmacophore
+
+    Use `featurize_smiles` for one‑line access.
+    """
+
+    def __init__(self) -> None:
+        """Initialize SmilesFeaturizer.
+
+        This class has no instance state; all methods are static or
+        class‑level.
+        """
+        pass
+
+    @staticmethod
+    def smiles_to_mol(smiles: str) -> Chem.Mol:
+        """Convert a SMILES string to an RDKit Mol object.
+
+        :param smiles: The SMILES string to convert.
+        :type smiles: str
+        :returns: RDKit Mol object corresponding to the SMILES.
+        :rtype: Chem.Mol
+        :raises ValueError: If the SMILES string is invalid.
+        """
+        mol = Chem.MolFromSmiles(smiles)
+        if mol is None:
+            raise ValueError(f"Invalid SMILES string: {smiles!r}")
+        return mol
+
+    @staticmethod
+    def get_maccs_keys(mol: Chem.Mol) -> Any:
+        """Generate the MACCS keys fingerprint for a molecule.
+
+        :param mol: RDKit Mol object.
+        :type mol: Chem.Mol
+        :returns: MACCS keys fingerprint bit vector.
+        :rtype: ExplicitBitVect
+        """
+        return MACCSkeys.GenMACCSKeys(mol)
+
+    @staticmethod
+    def get_avalon_fp(mol: Chem.Mol, nBits: int = 1024) -> Any:
+        """Generate the Avalon fingerprint for a molecule.
+
+        :param mol: RDKit Mol object.
+        :type mol: Chem.Mol
+        :param nBits: Length of the fingerprint vector.
+        :type nBits: int
+        :returns: Avalon fingerprint bit vector.
+        :rtype: ExplicitBitVect
+        """
+        return fpAvalon.GetAvalonFP(mol, nBits)
+
+    @staticmethod
+    def get_ecfp(
+        mol: Chem.Mol, radius: int, nBits: int = 2048, useFeatures: bool = False
+    ) -> Any:
+        """Generate a Morgan fingerprint (ECFP or FCFP) for a molecule.
+
+        :param mol: RDKit Mol object.
+        :type mol: Chem.Mol
+        :param radius: Radius for the Morgan algorithm.
+        :type radius: int
+        :param nBits: Length of the fingerprint vector.
+        :type nBits: int
+        :param useFeatures: If True, generate a Feature‑Class
+            fingerprint (FCFP).
+        :type useFeatures: bool
+        :returns: Morgan fingerprint bit vector.
+        :rtype: ExplicitBitVect
+        """
+        return AllChem.GetMorganFingerprintAsBitVect(
+            mol, radius, nBits=nBits, useFeatures=useFeatures
+        )
+
+    @staticmethod
+    def get_rdk_fp(
+        mol: Chem.Mol, maxPath: int, fpSize: int = 2048, nBitsPerHash: int = 2
+    ) -> Any:
+        """Generate an RDKit topological fingerprint for a molecule.
+
+        :param mol: RDKit Mol object.
+        :type mol: Chem.Mol
+        :param maxPath: Maximum path length (bonds) to include.
+        :type maxPath: int
+        :param fpSize: Length of the fingerprint vector.
+        :type fpSize: int
+        :param nBitsPerHash: Bits per hash for path hashing.
+        :type nBitsPerHash: int
+        :returns: RDKit topological fingerprint bit vector.
+        :rtype: ExplicitBitVect
+        """
+        return Chem.RDKFingerprint(
+            mol, maxPath=maxPath, fpSize=fpSize, nBitsPerHash=nBitsPerHash
+        )
+
+    @staticmethod
+    def mol_to_ap(mol: Chem.Mol) -> Any:
+        """Generate an Atom Pair fingerprint for a molecule.
+
+        :param mol: RDKit Mol object.
+        :type mol: Chem.Mol
+        :returns: Atom Pair fingerprint as an integer vector.
+        :rtype: ExplicitBitVect
+        """
+        return Pairs.GetAtomPairFingerprint(mol)
+
+    @staticmethod
+    def mol_to_torsion(mol: Chem.Mol) -> Any:
+        """Generate a Topological Torsion fingerprint for a molecule.
+
+        :param mol: RDKit Mol object.
+        :type mol: Chem.Mol
+        :returns: Torsion fingerprint as an integer vector.
+        :rtype: ExplicitBitVect
+        """
+        return Torsions.GetTopologicalTorsionFingerprintAsIntVect(mol)
+
+    @staticmethod
+    def mol_to_pharm2d(mol: Chem.Mol) -> Any:
+        """Generate a 2D Pharmacophore fingerprint for a molecule.
+
+        :param mol: RDKit Mol object.
+        :type mol: Chem.Mol
+        :returns: 2D pharmacophore fingerprint bit vector.
+        :rtype: ExplicitBitVect
+        """
+        return Generate.Gen2DFingerprint(mol, Gobbi_Pharm2D.factory)
+
+    @classmethod
+    def featurize_smiles(
+        cls,
+        smiles: str,
+        fingerprint_type: str,
+        convert_to_array: bool = True,
+        **kwargs: Any,
+    ) -> Any:
+        """Featurize a SMILES string into a chosen fingerprint, optionally
+        converting to a NumPy array.
+
+        :param smiles: The SMILES string to featurize.
+        :type smiles: str
+        :param fingerprint_type: One of 'maccs', 'avalon', 'ecfp#', 'fcfp#',
+                                 'rdk#', 'ap', 'torsion', 'pharm2d'.
+        :type fingerprint_type: str
+        :param convert_to_array: If True, convert the result to a NumPy array.
+        :type convert_to_array: bool
+        :param kwargs: Additional parameters passed to the chosen method:
+                       - `nBits` for Avalon/ECFP/FCFP
+                       - `radius` for ECFP/FCFP
+                       - `maxPath`, `fpSize`, `nBitsPerHash` for RDKit FP
+        :type kwargs: dict
+        :returns: Fingerprint as a NumPy array (if `convert_to_array`) or RDKit bit vector.
+        :rtype: np.ndarray or ExplicitBitVect
+        :raises ValueError: If `fingerprint_type` is unsupported.
+        """
+        mol = cls.smiles_to_mol(smiles)
+
+        ft = fingerprint_type.lower()
+        if ft == "maccs":
+            fp = cls.get_maccs_keys(mol)
+        elif ft == "avalon":
+            fp = cls.get_avalon_fp(mol, nBits=kwargs.get("nBits", 1024))
+        elif ft.startswith("ecfp") or ft.startswith("fcfp"):
+            radius = int(ft[4])
+            use_features = ft.startswith("fcfp")
+            fp = cls.get_ecfp(
+                mol,
+                radius,
+                nBits=kwargs.get("nBits", 2048),
+                useFeatures=use_features,
+            )
+        elif ft.startswith("rdk"):
+            max_path = int(ft[3])
+            fp = cls.get_rdk_fp(
+                mol,
+                maxPath=max_path,
+                fpSize=kwargs.get("fpSize", 2048),
+                nBitsPerHash=kwargs.get("nBitsPerHash", 2),
+            )
+        elif ft == "ap":
+            fp = cls.mol_to_ap(mol)
+        elif ft == "torsion":
+            fp = cls.mol_to_torsion(mol)
+        elif ft == "pharm2d":
+            fp = cls.mol_to_pharm2d(mol)
+        else:
+            raise ValueError(f"Unsupported fingerprint type: {fingerprint_type!r}")
+
+        if convert_to_array:
+            if ft == "pharm2d":
+                bitstr = fp.ToBitString()
+                return np.array([int(b) for b in bitstr], dtype=np.int8)
+            arr = np.zeros((fp.GetNumBits(),), dtype=np.int8)
+            DataStructs.ConvertToNumpyArray(fp, arr)
+            return arr
+
+        return fp
+
+    def __str__(self) -> str:
+        """Short description of the featurizer.
+
+        :returns: Class name.
+        :rtype: str
+        """
+        return "<SmilesFeaturizer>"
+
+    def help(self) -> None:
+        """Print supported fingerprint types and usage summary.
+
+        :returns: None
+        :rtype: NoneType
+        """
+        print("SmilesFeaturizer supports the following fingerprint types:")
+        print("  - maccs, avalon, ecfp#, fcfp#, rdk#, ap, torsion, pharm2d")
+        print(
+            "Usage: SmilesFeaturizer.featurize_smiles(smiles, fingerprint_type, **kwargs)"
+        )