Refactor route handling to replace ReducedRouteCGR with SB-CGR across multiple modules, enhancing clarity and consistency in clustering and visualization processes.

app.py

@@ -26,6 +26,7 @@ from synplan.utils.visualisation import (
     generate_results_html,
     html_top_routes_cluster,
     get_route_svg,
+    get_route_svg_from_json
 )
 from synplan.utils.config import TreeConfig, PolicyNetworkConfig
 from synplan.utils.loading import load_reaction_rules, load_building_blocks
@@ -169,8 +170,10 @@ def initialize_app():
         st.session_state.num_clusters_setting = 10
     if "route_cgrs_dict" not in st.session_state:
         st.session_state.route_cgrs_dict = None
-    if "r_route_cgrs_dict" not in st.session_state:
-        st.session_state.r_route_cgrs_dict = None
+    if "sb_cgrs_dict" not in st.session_state:
+        st.session_state.sb_cgrs_dict = None
+    if "route_json" not in st.session_state:
+        st.session_state.route_json = None
 
     # Subclustering state
     if "subclustering_done" not in st.session_state:
@@ -439,7 +442,8 @@ def setup_planning_options():
         st.session_state.reactions_dict = None
         st.session_state.subclusters = None
         st.session_state.route_cgrs_dict = None
-        st.session_state.r_route_cgrs_dict = None
+        st.session_state.sb_cgrs_dict = None
+        st.session_state.route_json = None
         active_smile_code = st.session_state.get(
             "ketcher", DEFAULT_MOL
         )  # Get current SMILES
@@ -520,8 +524,6 @@ def setup_planning_options():
 
         if error is not None:
             st.error(f"An error occurred during planning: {error}")
-        # else:
-        #     st.rerun()
 
 
 def display_planning_results():
@@ -564,6 +566,7 @@ def display_planning_results():
                             num_steps = len(tree.synthesis_route(node_id))
                             route_score = round(tree.route_score(node_id), 3)
                             svg = get_route_svg(tree, node_id)
+                            # svg = get_route_svg_from_json(st.session_state.route_json, node_id)
                             if svg:
                                 st.image(
                                     svg,
@@ -622,15 +625,6 @@ def download_planning_results():
     ):
         res = st.session_state.res
         tree = st.session_state.tree
-        # This section is usually placed within a column in the original script
-        # We'll assume it's called after display_planning_results and can use a new column or area.
-        # For proper layout, this should be integrated with display_planning_results' columns.
-        # For now, creating a placeholder or separate section for downloads:
-        # st.subheader("Downloads") # This might be redundant if called within a layout context.
-
-        # The original code places downloads in the second column of planning results.
-        # To replicate, we'd need to pass the column object or call this within that context.
-        # Simulating this by just creating the download links:
         try:
             html_body = generate_results_html(tree, html_path=None, extended=True)
             dl_html = download_button(
@@ -675,7 +669,7 @@ def setup_clustering():
             st.session_state.reactions_dict = None
             st.session_state.subclusters = None
             st.session_state.route_cgrs_dict = None
-            st.session_state.r_route_cgrs_dict = None
+            st.session_state.sb_cgrs_dict = None
 
             with st.spinner("Performing clustering..."):
                 error = None
@@ -687,19 +681,22 @@ def setup_clustering():
 
                     st.write("Calculating RoutesCGRs...")
                     route_cgrs_dict = compose_all_route_cgrs(current_tree)
-                    st.write("Processing ReducedRoutesCGRs...")
-                    r_route_cgrs_dict = compose_all_reduced_route_cgrs(route_cgrs_dict)
+                    st.write("Processing SB-CGRs...")
+                    sb_cgrs_dict = compose_all_sb_cgrs(route_cgrs_dict)
+                    # route_json = make_json(extract_reactions(current_tree))
 
                     results = cluster_routes(
-                        r_route_cgrs_dict, use_strat=False
-                    )  # num_clusters was removed from args
+                        sb_cgrs_dict, use_strat=False
+                    )
                     results = dict(sorted(results.items(), key=lambda x: float(x[0])))
 
                     st.session_state.clusters = results
                     st.session_state.route_cgrs_dict = route_cgrs_dict
-                    st.session_state.r_route_cgrs_dict = r_route_cgrs_dict
+                    st.session_state.sb_cgrs_dict = sb_cgrs_dict
                     st.write("Extracting reactions...")
-                    st.session_state.reactions_dict = extract_reactions(current_tree)
+                    reactions_dict = extract_reactions(current_tree)
+                    st.session_state.reactions_dict = reactions_dict
+                    # st.session_state.route_json = make_json(reactions_dict)
 
                     if (
                         st.session_state.clusters is not None
@@ -713,9 +710,8 @@ def setup_clustering():
                         st.error("Clustering failed or returned empty results.")
                         st.session_state.clustering_done = False
 
-                    del results  # route_cgrs_dict, r_route_cgrs_dict are stored
+                    del results  # sb_cgrs_dict are stored
                     gc.collect()
-                    # st.rerun()
                 except Exception as e:
                     error = e
                     st.error(f"An error occurred during clustering: {e}")
@@ -723,8 +719,6 @@ def setup_clustering():
                 
                 if error is not None:
                     st.error(f"An error occurred during planning: {error}")
-                # else:
-                #     st.rerun()
 
 
 def display_clustering_results():
@@ -765,16 +759,17 @@ def display_clustering_results():
                 num_steps = len(tree.synthesis_route(node_id))
                 route_score = round(tree.route_score(node_id), 3)
                 svg = get_route_svg(tree, node_id)
-                r_route_cgr = group_data.get("r_route_cgr")  # Safely get r_route_cgr
-                r_route_cgr_svg = None
-                if r_route_cgr:
-                    r_route_cgr.clean2d()
-                    r_route_cgr_svg = cgr_display(r_route_cgr)
-
-                if svg and r_route_cgr_svg:
+                # svg = get_route_svg_from_json(st.session_state.route_json, node_id)
+                sb_cgr = group_data.get("sb_cgr")  # Safely get sb_cgr
+                sb_cgr_svg = None
+                if sb_cgr:
+                    sb_cgr.clean2d()
+                    sb_cgr_svg = cgr_display(sb_cgr)
+
+                if svg and sb_cgr_svg:
                     col1, col2 = st.columns([0.2, 0.8])
                     with col1:
-                        st.image(r_route_cgr_svg, caption="ReducedRouteCGR")
+                        st.image(sb_cgr_svg, caption="SB-CGR")
                     with col2:
                         st.image(
                             svg,
@@ -786,11 +781,11 @@ def display_clustering_results():
                         caption=f"Route {node_id}; {num_steps} steps; Route score: {route_score}",
                     )
                     st.warning(
-                        f"ReducedRouteCGR could not be displayed for cluster {cluster_num}."
+                        f"SB-CGR could not be displayed for cluster {cluster_num}."
                     )
                 else:
                     st.warning(
-                        f"Could not generate SVG for route {node_id} or its ReducedRouteCGR."
+                        f"Could not generate SVG for route {node_id} or its SB-CGR."
                     )
             except Exception as e:
                 st.error(
@@ -816,17 +811,18 @@ def display_clustering_results():
                     try:
                         num_steps = len(tree.synthesis_route(node_id))
                         route_score = round(tree.route_score(node_id), 3)
-                        svg = get_route_svg(tree, node_id)
-                        r_route_cgr = group_data.get("r_route_cgr")
-                        r_route_cgr_svg = None
-                        if r_route_cgr:
-                            r_route_cgr.clean2d()
-                            r_route_cgr_svg = cgr_display(r_route_cgr)
-
-                        if svg and r_route_cgr_svg:
+                        # svg = get_route_svg(tree, node_id)
+                        svg = get_route_svg_from_json(st.session_state.route_json, node_id)
+                        sb_cgr = group_data.get("sb_cgr")
+                        sb_cgr_svg = None
+                        if sb_cgr:
+                            sb_cgr.clean2d()
+                            sb_cgr_svg = cgr_display(sb_cgr)
+
+                        if svg and sb_cgr_svg:
                             col1, col2 = st.columns([0.2, 0.8])
                             with col1:
-                                st.image(r_route_cgr_svg, caption="ReducedRouteCGR")
+                                st.image(sb_cgr_svg, caption="SB-CGR")
                             with col2:
                                 st.image(
                                     svg,
@@ -838,11 +834,11 @@ def display_clustering_results():
                                 caption=f"Route {node_id}; {num_steps} steps; Route score: {route_score}",
                             )
                             st.warning(
-                                f"ReducedRouteCGR could not be displayed for cluster {cluster_num}."
+                                f"SB-CGR could not be displayed for cluster {cluster_num}."
                             )
                         else:
                             st.warning(
-                                f"Could not generate SVG for route {node_id} or its ReducedRouteCGR."
+                                f"Could not generate SVG for route {node_id} or its SB-CGR."
                             )
                     except Exception as e:
                         st.error(
@@ -855,8 +851,8 @@ def download_clustering_results():
     if st.session_state.get("clustering_done", False):
         tree_for_html = st.session_state.get("tree")
         clusters_for_html = st.session_state.get("clusters")
-        r_route_cgrs_for_html = st.session_state.get(
-            "r_route_cgrs_dict"
+        sb_cgrs_for_html = st.session_state.get(
+            "sb_cgrs_dict"
         )  # This was used instead of reactions_dict in the original for report
 
         if not tree_for_html:
@@ -865,7 +861,7 @@ def download_clustering_results():
         if not clusters_for_html:
             st.warning("Cluster data not found. Cannot generate cluster reports.")
             return
-        # r_route_cgrs_for_html is optional for routes_clustering_report if not essential
+        # sb_cgrs_for_html is optional for routes_clustering_report if not essential
 
         st.subheader("Cluster Reports")  # Changed subheader in original
         st.write("Generate downloadable HTML reports for each cluster:")
@@ -884,7 +880,7 @@ def download_clustering_results():
                     tree_for_html,
                     clusters_for_html,  # Pass the whole dict
                     str(cluster_idx),  # Pass the key of the cluster
-                    r_route_cgrs_for_html,  # Pass the r_route_cgrs dict
+                    sb_cgrs_for_html,  # Pass the sb_cgrs dict
                     aam=False,
                 )
                 st.download_button(
@@ -911,7 +907,7 @@ def download_clustering_results():
                             tree_for_html,
                             clusters_for_html,
                             str(group_index),
-                            r_route_cgrs_for_html,
+                            sb_cgrs_for_html,
                             aam=False,
                         )
                         st.download_button(
@@ -936,7 +932,7 @@ def download_clustering_results():
                         tree_for_html,
                         clusters_for_html,
                         str(idx),
-                        r_route_cgrs_for_html,
+                        sb_cgrs_for_html,
                         aam=False,
                     )
                     filename = f"cluster_{idx}_{st.session_state.target_smiles}.html"
@@ -969,19 +965,19 @@ def setup_subclustering():
                 error = None
                 try:
                     clusters_for_sub = st.session_state.get("clusters")
-                    r_route_cgrs_dict_for_sub = st.session_state.get(
-                        "r_route_cgrs_dict"
+                    sb_cgrs_dict_for_sub = st.session_state.get(
+                        "sb_cgrs_dict"
                     )
                     route_cgrs_dict_for_sub = st.session_state.get("route_cgrs_dict")
 
                     if (
                         clusters_for_sub
-                        and r_route_cgrs_dict_for_sub
+                        and sb_cgrs_dict_for_sub
                         and route_cgrs_dict_for_sub
                     ):  # Ensure all are present
                         all_subgroups = subcluster_all_clusters(
                             clusters_for_sub,
-                            r_route_cgrs_dict_for_sub,
+                            sb_cgrs_dict_for_sub,
                             route_cgrs_dict_for_sub,
                         )
                         st.session_state.subclusters = all_subgroups
@@ -993,8 +989,8 @@ def setup_subclustering():
                         missing = []
                         if not clusters_for_sub:
                             missing.append("clusters")
-                        if not r_route_cgrs_dict_for_sub:
-                            missing.append("ReducedRouteCGRs dictionary")
+                        if not sb_cgrs_dict_for_sub:
+                            missing.append("SB-CGRs dictionary")
                         if not route_cgrs_dict_for_sub:
                             missing.append("RouteCGRs dictionary")
                         st.error(
@@ -1061,17 +1057,17 @@ def display_subclustering_results():
                         current_subcluster_data = sub[user_input_cluster_num_display][
                             selected_subcluster_idx
                         ]
-                        if "r_route_cgr" in current_subcluster_data:
-                            cluster_r_route_cgr_display = current_subcluster_data[
-                                "r_route_cgr"
+                        if "sb_cgr" in current_subcluster_data:
+                            cluster_sb_cgr_display = current_subcluster_data[
+                                "sb_cgr"
                             ]
-                            cluster_r_route_cgr_display.clean2d()
+                            cluster_sb_cgr_display.clean2d()
                             st.image(
-                                cluster_r_route_cgr_display.depict(),
-                                caption=f"ReducedRouteCGR of parent Cluster {user_input_cluster_num_display}",
+                                cluster_sb_cgr_display.depict(),
+                                caption=f"SB-CGR of parent Cluster {user_input_cluster_num_display}",
                             )
                         else:
-                            st.warning("ReducedRouteCGR for this subcluster not found.")
+                            st.warning("SB-CGR for this subcluster not found.")
             else:
                 st.warning(
                     f"Selected cluster {user_input_cluster_num_display} not found in subclustering results."
@@ -1126,48 +1122,50 @@ def display_subclustering_results():
                             st.warning(f"Could not depict synthon reaction: {e_depict}")
                     else:
                         st.info("No synthon reaction data for this subcluster.")
-
-                    for route_id in routes_to_display_direct:
-                        try:
-                            route_score_sub = round(tree.route_score(route_id), 3)
-                            svg_sub = get_route_svg(tree, route_id)
-                            if svg_sub:
-                                st.image(
-                                    svg_sub,
-                                    caption=f"Route {route_id}; Score: {route_score_sub}",
-                                )
-                            else:
-                                st.warning(
-                                    f"Could not generate SVG for route {route_id}."
+                    with st.container(height=300):
+                        for route_id in routes_to_display_direct:
+                            try:
+                                route_score_sub = round(tree.route_score(route_id), 3)
+                                # svg_sub = get_route_svg(tree, route_id)
+                                svg = get_route_svg_from_json(st.session_state.route_json, route_id)
+                                if svg_sub:
+                                    st.image(
+                                        svg_sub,
+                                        caption=f"Route {route_id}; Score: {route_score_sub}",
+                                    )
+                                else:
+                                    st.warning(
+                                        f"Could not generate SVG for route {route_id}."
+                                    )
+                            except Exception as e:
+                                st.error(
+                                    f"Error displaying route {route_id} in subcluster: {e}"
                                 )
-                        except Exception as e:
-                            st.error(
-                                f"Error displaying route {route_id} in subcluster: {e}"
-                            )
 
-                    if remaining_routes_sub:
-                        with st.expander(
-                            f"... and {len(remaining_routes_sub)} more routes in this subcluster"
-                        ):
-                            for route_id in remaining_routes_sub:
-                                try:
-                                    route_score_sub = round(
-                                        tree.route_score(route_id), 3
-                                    )
-                                    svg_sub = get_route_svg(tree, route_id)
-                                    if svg_sub:
-                                        st.image(
-                                            svg_sub,
-                                            caption=f"Route {route_id}; Score: {route_score_sub}",
+                        if remaining_routes_sub:
+                            with st.expander(
+                                f"... and {len(remaining_routes_sub)} more routes in this subcluster"
+                            ):
+                                for route_id in remaining_routes_sub:
+                                    try:
+                                        route_score_sub = round(
+                                            tree.route_score(route_id), 3
                                         )
-                                    else:
-                                        st.warning(
-                                            f"Could not generate SVG for route {route_id}."
+                                        # svg_sub = get_route_svg(tree, route_id)
+                                        svg_sub = get_route_svg_from_json(st.session_state.route_json, route_id)
+                                        if svg_sub:
+                                            st.image(
+                                                svg_sub,
+                                                caption=f"Route {route_id}; Score: {route_score_sub}",
+                                            )
+                                        else:
+                                            st.warning(
+                                                f"Could not generate SVG for route {route_id}."
+                                            )
+                                    except Exception as e:
+                                        st.error(
+                                            f"Error displaying route {route_id} in subcluster (expanded): {e}"
                                         )
-                                except Exception as e:
-                                    st.error(
-                                        f"Error displaying route {route_id} in subcluster (expanded): {e}"
-                                    )
             else:
                 st.info("Select a valid cluster and subcluster index to see details.")
 
@@ -1182,16 +1180,16 @@ def download_subclustering_results():
 
         sub = st.session_state.get("subclusters")
         tree = st.session_state.get("tree")
-        r_route_cgrs_for_report = st.session_state.get(
-            "r_route_cgrs_dict"
+        sb_cgrs_for_report = st.session_state.get(
+            "sb_cgrs_dict"
         )  # Used by routes_subclustering_report
 
         user_input_cluster_num_display = st.session_state.subcluster_num_select_key
         selected_subcluster_idx = st.session_state.subcluster_index_select_key
 
-        if not tree or not sub or not r_route_cgrs_for_report:
+        if not tree or not sub or not sb_cgrs_for_report:
             st.warning(
-                "Missing data for subclustering report generation (tree, subclusters, or ReducedRouteCGRs)."
+                "Missing data for subclustering report generation (tree, subclusters, or SB-CGRs)."
             )
             return
 
@@ -1226,7 +1224,7 @@ def download_subclustering_results():
                     processed_subcluster_data,  # Pass the specific post-processed subcluster data
                     user_input_cluster_num_display,
                     selected_subcluster_idx,
-                    r_route_cgrs_for_report,  # Pass the whole r_route_cgrs dict
+                    sb_cgrs_for_report,  # Pass the whole sb_cgrs dict
                     if_lg_group=True,  # This parameter was in the original call
                 )
                 st.download_button(
@@ -1259,7 +1257,7 @@ def implement_restart():
             "reactions_dict",
             "num_clusters_setting",
             "route_cgrs_dict",
-            "r_route_cgrs_dict",
+            "sb_cgrs_dict",
             "subclustering_done",
             "subclusters",  # "sub" was renamed
             "clusters_downloaded",

synplan/chem/reaction_routes/clustering.py

@@ -57,7 +57,7 @@ def run_cluster_cli(
     # Compose condensed graph representations
     route_cgrs = compose_all_route_cgrs(routes_dict)
     click.echo(f"Generating RouteCGR")
-    reduced_cgrs = compose_all_reduced_route_cgrs(route_cgrs)
+    reduced_cgrs = compose_all_sb_cgrs(route_cgrs)
     click.echo(f"Generating ReducedRouteCGR")
 
     # Perform clustering
@@ -129,7 +129,7 @@ def cluster_route_from_csv(routes_file: str):
     """
     routes_dict = read_routes_csv(routes_file)
     route_cgrs_dict = compose_all_route_cgrs(routes_dict)
-    reduced_route_cgrs_dict = compose_all_reduced_route_cgrs(route_cgrs_dict)
+    reduced_route_cgrs_dict = compose_all_sb_cgrs(route_cgrs_dict)
     clusters = cluster_routes(reduced_route_cgrs_dict, use_strat=False)
     return clusters
 
@@ -157,7 +157,7 @@ def cluster_route_from_json(routes_file: str):
     routes_json = read_routes_json(routes_file)
     routes_dict = make_dict(routes_json)
     route_cgrs_dict = compose_all_route_cgrs(routes_dict)
-    reduced_route_cgrs_dict = compose_all_reduced_route_cgrs(route_cgrs_dict)
+    reduced_route_cgrs_dict = compose_all_sb_cgrs(route_cgrs_dict)
     clusters = cluster_routes(reduced_route_cgrs_dict, use_strat=False)
     return clusters
 
@@ -196,34 +196,34 @@ def extract_strat_bonds(target_cgr: CGRContainer):
     return sorted(result)
 
 
-def cluster_routes(r_route_cgrs: dict, use_strat=False):
+def cluster_routes(sb_cgrs: dict, use_strat=False):
     """
     Cluster routes objects based on their strategic bonds
       or CGRContainer object signature (not avoid mapping)
 
     Args:
-        r_route_cgrs: Dictionary mapping node_id to r_route_cgr objects.
+        sb_cgrs: Dictionary mapping node_id to sb_cgr objects.
 
     Returns:
         Dictionary with groups keyed by '{length}.{index}' containing
-        'r_route_cgr', 'node_ids', and 'strat_bonds'.
+        'sb_cgr', 'node_ids', and 'strat_bonds'.
     """
     temp_groups = defaultdict(
-        lambda: {"node_ids": [], "r_route_cgr": None, "strat_bonds": None}
+        lambda: {"node_ids": [], "sb_cgr": None, "strat_bonds": None}
     )
 
     # 1. Initial grouping based on the content of strategic bonds
-    for node_id, r_route_cgr in r_route_cgrs.items():
-        strat_bonds_list = extract_strat_bonds(r_route_cgr)
+    for node_id, sb_cgr in sb_cgrs.items():
+        strat_bonds_list = extract_strat_bonds(sb_cgr)
         if use_strat == True:
             group_key = tuple(strat_bonds_list)
         else:
-            group_key = str(r_route_cgr)
+            group_key = str(sb_cgr)
 
         if not temp_groups[group_key]["node_ids"]:  # First time seeing this group
             temp_groups[group_key][
-                "r_route_cgr"
-            ] = r_route_cgr  # Store the first CGR as representative
+                "sb_cgr"
+            ] = sb_cgr  # Store the first CGR as representative
             temp_groups[group_key][
                 "strat_bonds"
             ] = strat_bonds_list  # Store the actual list
@@ -437,7 +437,7 @@ class SubclusterError(Exception):
     """Raised when subcluster_one_cluster cannot complete successfully."""
 
 
-def subcluster_one_cluster(group, r_route_cgrs_dict, route_cgrs_dict):
+def subcluster_one_cluster(group, sb_cgrs_dict, route_cgrs_dict):
     """
     Generate synthon data for each route in a single cluster.
 
@@ -449,7 +449,7 @@ def subcluster_one_cluster(group, r_route_cgrs_dict, route_cgrs_dict):
     ----------
     group : dict
         Must include `'node_ids'`, a list of node identifiers.
-    r_route_cgrs_dict : dict
+    sb_cgrs_dict : dict
         Maps node IDs to their ReducedRouteCGR.
     route_cgrs_dict : dict
         Maps node IDs to their RouteCGR.
@@ -458,7 +458,7 @@ def subcluster_one_cluster(group, r_route_cgrs_dict, route_cgrs_dict):
     -------
     dict or None
         If successful, returns a dict mapping each `node_id` to a tuple:
-        `(r_route_cgr, original_reaction, synthon_cgr, new_reaction, lg_groups)`.
+        `(sb_cgr, original_reaction, synthon_cgr, new_reaction, lg_groups)`.
         Or raises SubclusterError on any failure: if any step (X replacement or reaction
         parsing) fails for a node.
 
@@ -472,7 +472,7 @@ def subcluster_one_cluster(group, r_route_cgrs_dict, route_cgrs_dict):
 
     result = {}
     for node_id in node_ids:
-        r_route_cgr = r_route_cgrs_dict[node_id]
+        sb_cgr = sb_cgrs_dict[node_id]
         route_cgr = route_cgrs_dict[node_id]
 
         # 1) Replace leaving groups in RouteCGR
@@ -502,7 +502,7 @@ def subcluster_one_cluster(group, r_route_cgrs_dict, route_cgrs_dict):
             ) from e
 
         result[node_id] = (
-            r_route_cgr,
+            sb_cgr,
             ReactionContainer(reactants=old_reactants, products=[target_mol]),
             synthon_cgr,
             new_rxn,
@@ -521,7 +521,7 @@ def group_nodes_by_synthon_detail(data_dict: dict):
         data_dict: Dictionary {node_id: [synthon_cgr, synthon_reaction, node_data, ...]}.
 
     Returns:
-        Dictionary {group_index: {'r_route_cgr': ... ,'synthon_cgr': ..., 'synthon_reaction': ...,
+        Dictionary {group_index: {'sb_cgr': ... ,'synthon_cgr': ..., 'synthon_reaction': ...,
                                   'nodes_data': {node_id1: node_data1, ...}}}.
     """
     temp_groups = defaultdict(list)
@@ -553,7 +553,7 @@ def group_nodes_by_synthon_detail(data_dict: dict):
     sorted_temp_groups = sorted(temp_groups.items(), key=lambda item: item[1])
     for group_key, node_ids in sorted_temp_groups:
 
-        r_route_cgr, unlabeled_reaction, synthon_cgr, synthon_reaction = group_key
+        sb_cgr, unlabeled_reaction, synthon_cgr, synthon_reaction = group_key
         nodes_data_dict = {}
 
         # Iterate through the node IDs belonging to this group
@@ -568,7 +568,7 @@ def group_nodes_by_synthon_detail(data_dict: dict):
             nodes_data_dict[node_id] = node_specific_data  # Add to the sub-dictionary
 
         final_grouped_results[group_index] = {
-            "r_route_cgr": r_route_cgr,
+            "sb_cgr": sb_cgr,
             "unlabeled_reaction": unlabeled_reaction,
             "synthon_cgr": synthon_cgr,
             "synthon_reaction": synthon_reaction,
@@ -580,7 +580,7 @@ def group_nodes_by_synthon_detail(data_dict: dict):
     return final_grouped_results
 
 
-def subcluster_all_clusters(groups, r_route_cgrs_dict, route_cgrs_dict):
+def subcluster_all_clusters(groups, sb_cgrs_dict, route_cgrs_dict):
     """
     Subdivide each reaction cluster into detailed synthon-based subgroups.
 
@@ -591,7 +591,7 @@ def subcluster_all_clusters(groups, r_route_cgrs_dict, route_cgrs_dict):
     ----------
     groups : dict
         Mapping of cluster indices to cluster data.
-    r_route_cgrs_dict : dict
+    sb_cgrs_dict : dict
         Dictionary of ReducedRoteCGRs
     route_cgrs_dict : dict
         Dictionary of RoteCGRs
@@ -605,7 +605,7 @@ def subcluster_all_clusters(groups, r_route_cgrs_dict, route_cgrs_dict):
     all_subgroups = {}
     for group_index, group in groups.items():
         group_synthons = subcluster_one_cluster(
-            group, r_route_cgrs_dict, route_cgrs_dict
+            group, sb_cgrs_dict, route_cgrs_dict
         )
         if group_synthons is None:
             return None

synplan/chem/reaction_routes/route_cgr.py

@@ -487,7 +487,7 @@ def extract_reactions(tree: Tree, node_id=None):
     return dict(sorted(react_dict.items()))
 
 
-def compose_reduced_route_cgr(route_cgr: CGRContainer):
+def compose_sb_cgr(route_cgr: CGRContainer):
     """
     Reduces a Routes Condensed Graph of reaction (RouteCGR) by performing the following steps:
 
@@ -550,7 +550,7 @@ def compose_reduced_route_cgr(route_cgr: CGRContainer):
     return reduced_route_cgr
 
 
-def compose_all_reduced_route_cgrs(route_cgrs_dict: dict):
+def compose_all_sb_cgrs(route_cgrs_dict: dict):
     """
     Processes a collection (dictionary) of RouteCGRs to generate their reduced forms (ReducedRouteCGRs).
 
@@ -566,5 +566,5 @@ def compose_all_reduced_route_cgrs(route_cgrs_dict: dict):
     """
     all_reduced_route_cgrs = dict()
     for num, cgr in route_cgrs_dict.items():
-        all_reduced_route_cgrs[num] = compose_reduced_route_cgr(cgr)
+        all_reduced_route_cgrs[num] = compose_sb_cgr(cgr)
     return all_reduced_route_cgrs

synplan/utils/visualisation.py

@@ -536,7 +536,7 @@ def html_top_routes_cluster(clusters: dict, tree: Tree, target_smiles: str) -> s
         node_id = node_ids[0]
         # Get SVGs
         svg = get_route_svg(tree, node_id)
-        r_cgr = group_data.get("r_route_cgr")
+        r_cgr = group_data.get("sb_cgr")
         r_cgr_svg = None
         if r_cgr:
             r_cgr.clean2d()
@@ -573,7 +573,7 @@ def routes_clustering_report(
     source: Union[Tree, dict],
     clusters: dict,
     group_index: str,
-    r_route_cgrs_dict: dict,
+    sb_cgrs_dict: dict,
     aam: bool = False,
     html_path: str = None,
 ) -> str:
@@ -597,7 +597,7 @@ def routes_clustering_report(
         group_index (str): The key identifying the specific cluster within the
                            `clusters` dictionary for which the report should be
                            generated.
-        r_route_cgrs_dict (dict): A dictionary mapping route IDs (integers) to
+        sb_cgrs_dict (dict): A dictionary mapping route IDs (integers) to
                              ReducedRouteCGR (Retrosynthetic Graph-based Chemical
                              Reaction) objects. Used to display a representative
                              ReducedRouteCGR for the cluster.
@@ -749,18 +749,18 @@ def routes_clustering_report(
     # --- Add ReducedRouteCGR Image ---
     first_route_id = valid_routes[0] if valid_routes else None
 
-    if first_route_id and r_route_cgrs_dict:
+    if first_route_id and sb_cgrs_dict:
         try:
-            r_route_cgr = r_route_cgrs_dict[first_route_id]
-            r_route_cgr.clean2d()
-            r_route_cgr_svg = cgr_display(r_route_cgr)
+            sb_cgr = sb_cgrs_dict[first_route_id]
+            sb_cgr.clean2d()
+            sb_cgr_svg = cgr_display(sb_cgr)
 
-            if r_route_cgr_svg.strip().startswith("<svg"):
-                table += f"<tr>{td}{font_normal}Identified Strategic Bonds{font_close}<br>{r_route_cgr_svg}</td></tr>"
+            if sb_cgr_svg.strip().startswith("<svg"):
+                table += f"<tr>{td}{font_normal}Identified Strategic Bonds{font_close}<br>{sb_cgr_svg}</td></tr>"
             else:
                 table += f"<tr>{td}{font_normal}Cluster Representative ReducedRouteCGR (from Route {first_route_id}):{font_close}<br><i>Invalid SVG format retrieved.</i></td></tr>"
                 print(
-                    f"Warning: Expected SVG for ReducedRouteCGR of node {first_route_id}, but got: {r_route_cgr_svg[:100]}..."
+                    f"Warning: Expected SVG for ReducedRouteCGR of node {first_route_id}, but got: {sb_cgr_svg[:100]}..."
                 )
         except Exception as e:
             table += f"<tr>{td}{font_normal}Cluster Representative ReducedRouteCGR (from Route {first_route_id}):{font_close}<br><i>Error retrieving/displaying ReducedRouteCGR: {e}</i></td></tr>"
@@ -993,7 +993,7 @@ def routes_subclustering_report(
     subcluster: dict,
     group_index: str,
     cluster_num: int,
-    r_route_cgrs_dict: dict,
+    sb_cgrs_dict: dict,
     if_lg_group: bool = False,
     aam: bool = False,
     html_path: str = None,
@@ -1022,7 +1022,7 @@ def routes_subclustering_report(
                            subcluster belongs. Used for report titling.
         cluster_num (int): The number or identifier of the subcluster within
                            its main group. Used for report titling.
-        r_route_cgrs_dict (dict): A dictionary mapping route IDs (integers) to
+        sb_cgrs_dict (dict): A dictionary mapping route IDs (integers) to
                              ReducedRouteCGR objects. Used to display a representative
                              ReducedRouteCGR for the cluster.
         if_lg_group (bool, optional): If True, the leaving groups table will
@@ -1179,18 +1179,18 @@ def routes_subclustering_report(
     # --- Add ReducedRouteCGR Image ---
     first_route_id = valid_routes[0] if valid_routes else None
 
-    if first_route_id and r_route_cgrs_dict:
+    if first_route_id and sb_cgrs_dict:
         try:
-            r_route_cgr = r_route_cgrs_dict[first_route_id]
-            r_route_cgr.clean2d()
-            r_route_cgr_svg = cgr_display(r_route_cgr)
+            sb_cgr = sb_cgrs_dict[first_route_id]
+            sb_cgr.clean2d()
+            sb_cgr_svg = cgr_display(sb_cgr)
 
-            if r_route_cgr_svg.strip().startswith("<svg"):
-                table += f"<tr>{td}{font_normal}Identified Strategic Bonds{font_close}<br>{r_route_cgr_svg}</td></tr>"
+            if sb_cgr_svg.strip().startswith("<svg"):
+                table += f"<tr>{td}{font_normal}Identified Strategic Bonds{font_close}<br>{sb_cgr_svg}</td></tr>"
             else:
                 table += f"<tr>{td}{font_normal}Cluster Representative ReducedRouteCGR (from Route {first_route_id}):{font_close}<br><i>Invalid SVG format retrieved.</i></td></tr>"
                 print(
-                    f"Warning: Expected SVG for ReducedRouteCGR of node {first_route_id}, but got: {r_route_cgr_svg[:100]}..."
+                    f"Warning: Expected SVG for ReducedRouteCGR of node {first_route_id}, but got: {sb_cgr_svg[:100]}..."
                 )
         except Exception as e:
             table += f"<tr>{td}{font_normal}Cluster Representative ReducedRouteCGR (from Route {first_route_id}):{font_close}<br><i>Error retrieving/displaying ReducedRouteCGR: {e}</i></td></tr>"