Adding features for 4.4.0 release

Author: kpzn768

CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## Version 4.4.0 2025-06-30
+
+## Features
+
+- Add scorers that are wrappers around rxnutils scorers
+- Add filter policy for keeping substructures frozen
+- Add stock option based on molecular weight
+
+## Miscellaneous 
+
+- Add rxnutils as dependency
+- Remove routines in rxnutils to reduce code duplication
+
 ## Version 4.3.2 2025-04-07
 
 ### Trivial changes

aizynthfinder/analysis/routes.py

@@ -1,20 +1,24 @@
 """ Module containing classes to store and manipulate collections of synthetic routes.
 """
+
 from __future__ import annotations
 
 import copy
 from typing import TYPE_CHECKING
 
 import numpy as np
+from rxnutils.routes.comparison import simple_route_similarity
+from rxnutils.routes.readers import read_aizynthfinder_dict
 
 try:
     from route_distances.clustering import ClusteringHelper
-    from route_distances.route_distances import route_distances_calculator
 except ImportError:
-    pass
+    SUPPORT_CLUSTERING = False
+else:
+    SUPPORT_CLUSTERING = True
 
 from aizynthfinder.analysis.utils import CombinedReactionTrees, RouteSelectionArguments
-from aizynthfinder.reactiontree import SUPPORT_DISTANCES, ReactionTree
+from aizynthfinder.reactiontree import ReactionTree
 from aizynthfinder.search.mcts import MctsNode, MctsSearchTree
 
 if TYPE_CHECKING:
@@ -27,7 +31,6 @@
         PilImage,
         Sequence,
         StrDict,
-        Union,
     )
 
 
@@ -77,7 +80,7 @@ def __init__(self, reaction_trees: Sequence[ReactionTree], **kwargs) -> None:
         self.clusters: Optional[Sequence[RouteCollection]] = self._unpack_kwarg(
             "clusters", **kwargs
         )
-        self._distance_matrix: Dict[str, np.ndarray] = {}
+        self._distance_matrix: Optional[np.ndarray] = None
         self._combined_reaction_trees: Optional[CombinedReactionTrees] = None
 
     @classmethod
@@ -142,41 +145,30 @@ def cluster(
         self,
         n_clusters: int,
         max_clusters: int = 5,
-        distances_model: str = "ted",
         **kwargs: Any,
     ) -> np.ndarray:
         """
         Cluster the route collection into a number of clusters.
 
-        Additional arguments to the distance or clustering algorithm
-        can be passed in as key-word arguments.
-
-        When `distances_model` is "lstm", a key-word argument `model_path` needs to be given
-        when `distances_model` is "ted", two optional key-word arguments `timeout` and `content`
-        can be given.
+        Additional arguments to the clustering algorithm can be passed in as key-word arguments.
 
         If the number of reaction trees are less than 3, no clustering will be performed
 
         :param n_clusters: the desired number of clusters, if less than 2 triggers optimization
         :param max_clusters: the maximum number of clusters to consider
-        :param distances_model: can be ted or lstm and determines how the route distances are computed
         :return: the cluster labels
+        :raises ValueError: if the route_distance package is not installed
         """
-        if not SUPPORT_DISTANCES:
+        if not SUPPORT_CLUSTERING:
             raise ValueError(
                 "Clustering is not supported by this installation."
                 " Please install aizynthfinder with extras dependencies."
             )
 
         if len(self.reaction_trees) < 3:
             return np.asarray([])
-        dist_kwargs = {
-            "content": kwargs.pop("content", "both"),
-            "timeout": kwargs.pop("timeout", None),
-            "model_path": kwargs.pop("model_path", None),
-        }
         try:
-            distances = self.distance_matrix(model=distances_model, **dist_kwargs)
+            distances = self.distance_matrix()
         except ValueError:
             return np.asarray([])
 
@@ -213,7 +205,7 @@ def compute_scores(self, *scorers: Scorer) -> None:
         for scorer in scorers:
             for idx, score in enumerate(scorer(list_)):  # type: ignore
                 self.all_scores[idx][repr(scorer)] = score
-        self._update_route_dict(self.all_scores, "all_score")
+        self._update_route_dict(self.all_scores, "all_scores")
 
     def dict_with_extra(
         self, include_scores=False, include_metadata=False
@@ -244,41 +236,19 @@ def dict_with_scores(self) -> Sequence[StrDict]:
         """
         return self.dict_with_extra(include_scores=True)
 
-    def distance_matrix(
-        self, recreate: bool = False, model: str = "ted", **kwargs: Any
-    ) -> np.ndarray:
+    def distance_matrix(self, recreate: bool = False) -> np.ndarray:
         """
         Compute the distance matrix between each pair of reaction trees
 
-        All key-word arguments are passed along to the `route_distance_calculator`
-        function from the `route_distances` package.
-
-        When `model` is "lstm", a key-word argument `model_path` needs to be given
-        when `model` is "ted", two optional key-word arguments `timeout` and `content`
-        can be given.
-
         :param recreate: if False, use a cached one if available
-        :param model: the type of model to use "ted" or "lstm"
         :return: the square distance matrix
         """
-        if not SUPPORT_DISTANCES:
-            raise ValueError(
-                "Distance calculations are not supported by this installation."
-                " Please install aizynthfinder with extras dependencies."
-            )
-
-        if model == "lstm" and not kwargs.get("model_path"):
-            raise KeyError(
-                "Need to provide 'model_path' argument when using LSTM model for computing distances"
-            )
-        content = kwargs.get("content", "both")
-        cache_key = kwargs.get("model_path", "") if model == "lstm" else content
-        if self._distance_matrix.get(cache_key) is not None and not recreate:
-            return self._distance_matrix[cache_key]
-        calculator = route_distances_calculator(model, **kwargs)
-        distances = calculator(self.dicts)
-        self._distance_matrix[cache_key] = distances
-        return distances
+        if self._distance_matrix is not None and not recreate:
+            return self._distance_matrix
+        routes = [read_aizynthfinder_dict(dict_) for dict_ in self.dicts]
+        self._distance_matrix = 1.0 - simple_route_similarity(routes)
+        assert self._distance_matrix is not None
+        return self._distance_matrix
 
     def make_dicts(self) -> Sequence[StrDict]:
         """Convert all reaction trees to dictionaries"""

aizynthfinder/context/policy/__init__.py

@@ -10,6 +10,7 @@
 from aizynthfinder.context.policy.filter_strategies import (
     BondFilter,
     FilterStrategy,
+    FrozenSubstructureFilter,
     QuickKerasFilter,
     ReactantsCountFilter,
 )

aizynthfinder/context/policy/filter_strategies.py

@@ -1,19 +1,18 @@
 """ Module containing classes that implements different filter policy strategies
 """
+
 from __future__ import annotations
 
 import abc
 from typing import TYPE_CHECKING
 
 import numpy as np
+from rdkit import Chem
 
 from aizynthfinder.chem import TemplatedRetroReaction
 from aizynthfinder.context.policy.utils import _make_fingerprint
 from aizynthfinder.utils.bonds import BrokenBonds
-from aizynthfinder.utils.exceptions import (
-    PolicyException,
-    RejectionException,
-)
+from aizynthfinder.utils.exceptions import PolicyException, RejectionException
 from aizynthfinder.utils.logging import logger
 from aizynthfinder.utils.models import load_model
 
@@ -182,8 +181,46 @@ def apply(self, reaction: RetroReaction) -> None:
             )
 
 
+class FrozenSubstructureFilter(FilterStrategy):
+    """
+    Filter for rejecting reactions that break up substructures
+
+    :param key: the key or label
+    :param config: the configuration of the tree search
+    :param smarts_list: the SMARTS patterns of the sub-structures
+    """
+
+    _required_kwargs: List[str] = ["smarts_list"]
+
+    def __init__(self, key: str, config: Configuration, **kwargs: Any) -> None:
+        super().__init__(key, config, **kwargs)
+        self._smarts_list = kwargs.get("smarts_list", [])
+        self._mol_lists = [Chem.MolFromSmarts(smarts) for smarts in self._smarts_list]
+        self._logger.info(
+            f"Loading frozen substructure filter to {key} with {len(self._mol_lists)} substructures"
+        )
+
+    def apply(self, reaction: RetroReaction) -> None:
+        for mol in self._mol_lists:
+            # If it did not exists in the product, we cannot expect it to be present in the reactants
+            if not reaction.mol.rd_mol.HasSubstructMatch(mol):
+                continue
+
+            found = False
+            for reactant in reaction.reactants[reaction.index]:
+                if reactant.rd_mol.HasSubstructMatch(mol):
+                    found = True
+                    break
+
+            if not found:
+                raise RejectionException(
+                    f"{reaction} was filtered out because of broken substructure: {Chem.MolToSmarts(mol)}"
+                )
+
+
 FILTER_STRATEGY_ALIAS = {
     "feasibility": "QuickKerasFilter",
     "quick_keras_filter": "QuickKerasFilter",
     "reactants_count": "ReactantsCountFilter",
+    "frozen_substructure": "FrozenSubstructureFilter",
 }

aizynthfinder/context/scoring/__init__.py

@@ -3,22 +3,30 @@
 
 from aizynthfinder.context.scoring.collection import ScorerCollection
 from aizynthfinder.context.scoring.scorers import (
-    AverageTemplateOccurrenceScorer,
+    SUPPORT_DISTANCES,
     BrokenBondsScorer,
     CombinedScorer,
+    DeepSetScorer,
+    RouteCostScorer,
+    RouteSimilarityScorer,
+    StateScorer,
+)
+from aizynthfinder.context.scoring.scorers_base import Scorer
+from aizynthfinder.context.scoring.scorers_mols import (
     DeltaSyntheticComplexityScorer,
+    FractionInSourceStockScorer,
     FractionInStockScorer,
-    MaxTransformScorerer,
+    FractionOfIntermediatesInStockScorer,
     NumberOfPrecursorsInStockScorer,
     NumberOfPrecursorsScorer,
-    NumberOfReactionsScorer,
     PriceSumScorer,
-    ReactionClassMembershipScorer,
-    RouteCostScorer,
-    RouteSimilarityScorer,
-    Scorer,
-    StateScorer,
     StockAvailabilityScorer,
-    SUPPORT_DISTANCES,
+)
+from aizynthfinder.context.scoring.scorers_reactions import (
+    AverageTemplateOccurrenceScorer,
+    MaxTransformScorer,
+    NumberOfReactionsScorer,
+    ReactionClassMembershipScorer,
+    ReactionClassRankScorer,
 )
 from aizynthfinder.utils.exceptions import ScorerException

aizynthfinder/context/scoring/collection.py

@@ -1,19 +1,21 @@
 """ Module containing classes used to score the reaction routes.
 """
+
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
 from aizynthfinder.context.collection import ContextCollection
-from aizynthfinder.context.scoring.scorers import (
-    AverageTemplateOccurrenceScorer,
+from aizynthfinder.context.scoring.scorers import StateScorer
+from aizynthfinder.context.scoring.scorers import __name__ as scorers_module
+from aizynthfinder.context.scoring.scorers_mols import (
     NumberOfPrecursorsInStockScorer,
     NumberOfPrecursorsScorer,
+)
+from aizynthfinder.context.scoring.scorers_reactions import (
     NumberOfReactionsScorer,
     Scorer,
-    StateScorer,
 )
-from aizynthfinder.context.scoring.scorers import __name__ as scorers_module
 from aizynthfinder.reactiontree import ReactionTree
 from aizynthfinder.search.mcts import MctsNode
 from aizynthfinder.utils.exceptions import ScorerException
@@ -33,7 +35,6 @@
     NumberOfReactionsScorer,
     NumberOfPrecursorsScorer,
     NumberOfPrecursorsInStockScorer,
-    AverageTemplateOccurrenceScorer,
 ]