synkit 0.0.14__tar.gz → 0.0.15__tar.gz

{synkit-0.0.14 → synkit-0.0.15}/.gitignore

@@ -6,14 +6,10 @@
 *.json
 *.pkl.gz
 *.pdf
-out
-summary
 *.log
 .coverage
 dev/*
 *.rdf
-Data/Testcase/hydro/aam.json.gz
-synkit/Chem/FG/*
 test_syn_reactor.py
 Data/Benchmark/*
 # *.png
@@ -24,3 +20,4 @@ run_rdcanon.py
 Data/Fragment/*
 test_partial.py
 Data/Benchmark/synthesis/*
+Data/USPTO/*

{synkit-0.0.14 → synkit-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synkit
-Version: 0.0.14
+Version: 0.0.15
 Summary: Utility for reaction modeling using graph grammar
 Project-URL: homepage, https://github.com/TieuLongPhan/SynKit
 Project-URL: source, https://github.com/TieuLongPhan/SynKit

{synkit-0.0.14 → synkit-0.0.15}/Test/Graph/ITS/test_its_construction.py

@@ -31,20 +31,20 @@ class TestITSConstruction(unittest.TestCase):
         attributes = ITSConstruction().get_node_attributes_with_defaults(self.G, 1)
         self.assertEqual(attributes, ("C", False, 2, 0, ["", ""]))
 
-    def test_add_edges_to_ITS(self):
-        ITS = nx.Graph()
-        ITS.add_node(1, element="C", aromatic=False, hcount=3, charge=0)
-        ITS.add_node(2, element="C", aromatic=False, hcount=3, charge=0)
-        new_ITS = ITSConstruction().add_edges_to_ITS(ITS, self.G, self.H)
-        self.assertTrue(isinstance(new_ITS, nx.Graph))
-        self.assertEqual(len(new_ITS.edges()), 1)
-        self.assertEqual(new_ITS[1][2]["order"], (2, 1))
-
-    def test_add_standard_order_attribute(self):
-        graph = nx.Graph()
-        graph.add_edge(1, 2, order=(1, 2))
-        updated_graph = ITSConstruction().add_standard_order_attribute(graph)
-        self.assertEqual(updated_graph[1][2]["standard_order"], -1)
+    # def test_add_edges_to_ITS(self):
+    #     ITS = nx.Graph()
+    #     ITS.add_node(1, element="C", aromatic=False, hcount=3, charge=0)
+    #     ITS.add_node(2, element="C", aromatic=False, hcount=3, charge=0)
+    #     new_ITS = ITSConstruction().add_edges_to_ITS(ITS, self.G, self.H)
+    #     self.assertTrue(isinstance(new_ITS, nx.Graph))
+    #     self.assertEqual(len(new_ITS.edges()), 1)
+    #     self.assertEqual(new_ITS[1][2]["order"], (2, 1))
+
+    # def test_add_standard_order_attribute(self):
+    #     graph = nx.Graph()
+    #     graph.add_edge(1, 2, order=(1, 2))
+    #     updated_graph = ITSConstruction().add_standard_order_attribute(graph)
+    #     self.assertEqual(updated_graph[1][2]["standard_order"], -1)
 
 
 if __name__ == "__main__":

{synkit-0.0.14 → synkit-0.0.15}/doc/graph.rst

@@ -22,7 +22,7 @@ The class :py:class:`~synkit.Graph.canon_graph.GraphCanonicaliser` canonicalises
 
    from synkit.IO import rsmi_to_its
    from synkit.Graph.canon_graph import GraphCanonicaliser
-   from synkit.Graph.matcher.graph_matcher import GraphMatcherEngine
+   from synkit.Graph.Matcher.graph_matcher import GraphMatcherEngine
 
    canon = GraphCanonicaliser(backend='wl', wl_iterations=3)
    rsmi = (

{synkit-0.0.14 → synkit-0.0.15}/lint.sh

@@ -20,7 +20,8 @@ sing.py:C901,\
 turbo_iso.py:C901,\
 rule_vis.py:C901,
 gml_to_graph.py:C901,
-wildcard.py:C901" \
+wildcard.py:C901,
+its_destruction.py:C901" \
   --exclude=venv,\
 core_engine.py,\
 rule_apply.py,\
@@ -28,5 +29,6 @@ reactor_engine.py,\
 groupoid.py,\
 syn_rule.py,\
 __init__.py,\
+dev/*,\
 Data \
   --statistics

{synkit-0.0.14 → synkit-0.0.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "synkit"
-version = "0.0.14"
+version = "0.0.15"
 license = { text = "MIT" }
 license-files = ["LICENSE"]
 authors = [

{synkit-0.0.14 → synkit-0.0.15}/recipe/meta.yaml

@@ -1,6 +1,6 @@
 package:
   name: synkit
-  version: 0.0.14
+  version: 0.0.15
 
 source:
   path: ..

{synkit-0.0.14 → synkit-0.0.15}/synkit/Chem/utils.py

@@ -5,6 +5,45 @@ import re
 from typing import List, Optional, Tuple, Union
 
 
+def clean_radical_rsmi(rsmi: str) -> str:
+    """
+    Load each side of a reaction SMILES (rSMI) into RDKit, split into disconnected fragments,
+    remove any fragment that contains an atom with nonzero radical electrons,
+    then reassemble back into a cleaned reaction SMILES.
+
+    :param rsmi: Reaction SMILES string, e.g.
+                 'A>>B.C'
+    :type rsmi: str
+    :returns: Cleaned reaction SMILES with radical-containing fragments removed.
+    :rtype: str
+
+    Example:
+    >>> clean_radical_rsmi(
+    ...   'COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(=O)Nc1cc(OC)cc(C(C)(C)C)c1O'
+    ...   '>>COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(N)=O.COc1c[c]c(O)c(C(C)(C)C)c1'
+    ... )
+    'COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(=O)Nc1cc(OC)cc(C(C)(C)C)c1O'
+    '>>COC(=O)C(CCCCNC(=O)OCc1ccccc1)NC(N)=O'
+    """
+    if ">>" not in rsmi:
+        return rsmi
+
+    def _clean_side(side: str) -> str:
+        mol = Chem.MolFromSmiles(side)
+        if mol is None:
+            return ""
+        frags = Chem.GetMolFrags(mol, asMols=True)
+        kept = []
+        for frag in frags:
+            if any(atom.GetNumRadicalElectrons() > 0 for atom in frag.GetAtoms()):
+                continue
+            kept.append(Chem.MolToSmiles(frag, isomericSmiles=True))
+        return ".".join(kept)
+
+    reac, prod = rsmi.split(">>", 1)
+    return f"{_clean_side(reac)}>>{_clean_side(prod)}"
+
+
 def enumerate_tautomers(reaction_smiles: str) -> Optional[List[str]]:
     """Enumerate possible tautomers of reactants while canonicalizing products.
 

{synkit-0.0.14 → synkit-0.0.15}/synkit/Graph/Hyrogen/_misc.py

@@ -1,7 +1,7 @@
 from copy import copy
 import networkx as nx
 from operator import eq
-from typing import List, Set, Any, Tuple
+from typing import List, Set, Any, Tuple, Iterable, Optional
 from networkx.algorithms.isomorphism import generic_node_match, generic_edge_match
 
 from synkit.Graph.Feature.graph_descriptors import GraphDescriptor
@@ -233,95 +233,56 @@ def implicit_hydrogen(
     return new_graph
 
 
-# def explicit_hydrogen(graph: nx.Graph) -> nx.Graph:
-#     """
-#     Adds explicit hydrogens to the molecular graph based on hydrogen counts ('hcount') for non-hydrogen
-#     atoms and increases the 'atom_map' attribute for each hydrogen added. This function assumes that
-#     'hcount' is present for each atom (representing how many hydrogens should be added) and that the
-#     'atom_map' for existing atoms is valid.
-
-#     Parameters:
-#     - graph (nx.Graph): A NetworkX graph representing the molecule, where each node has an 'element'
-#       attribute for the element type (e.g., 'C', 'H'), 'hcount' for the number of hydrogens to add,
-#       and 'atom_map' for atom mapping.
-
-#     Returns:
-#     - nx.Graph: A new NetworkX graph with explicit hydrogen atoms added and 'atom_map' updated.
-#     """
-#     warnings.warn(
-#         "This function can only work with single graph and cannot guarantee the mapping between G and H"
-#     )
-#     # Create a deep copy of the graph to avoid in-place modifications
-#     new_graph = copy(graph)
-
-#     # Find the maximum atom_map currently in the graph
-#     max_atom_map = max(
-#         [
-#             data["atom_map"]
-#             for node, data in new_graph.nodes(data=True)
-#             if "atom_map" in data
-#         ],
-#         default=0,
-#     )
-
-#     # Prepare a list of nodes that will need explicit hydrogens
-#     hydrogen_id = max_atom_map + 1  # Start adding hydrogens from max atom_map + 1
-#     hydrogen_additions = []  # To keep track of hydrogens to add
-
-#     # First, collect all nodes that need hydrogens
-#     for node, data in new_graph.nodes(data=True):
-#         if data["element"] != "H":  # Skip hydrogens
-#             hcount = data.get("hcount", 0)  # Number of hydrogens to add
-#             for _ in range(hcount):
-#                 hydrogen_additions.append((node, hydrogen_id))
-#                 hydrogen_id += 1  # Increment for next hydrogen
-
-#     # Now, add the hydrogens and update the graph
-#     for parent, hydrogen_atom_map in hydrogen_additions:
-#         hydrogen_node = f"H_{hydrogen_atom_map}"
-#         new_graph.add_node(hydrogen_node, element="H", atom_map=hydrogen_atom_map)
-#         new_graph.add_edge(
-#             parent, hydrogen_node
-#         )  # Connect the hydrogen to its parent atom
-
-#     return new_graph
-
-
-# def expand_hydrogens(graph: nx.Graph) -> nx.Graph:
-#     """
-#     For each node in the graph that has an 'hcount' attribute greater than zero,
-#     adds the specified number of hydrogen nodes and connects them with edges that
-#     have specific attributes.
-
-#     Parameters
-#     - graph (nx.Graph): A graph representing a molecule with nodes that can
-#     include 'element', 'hcount', 'charge', and 'atom_map' attributes.
-
-#     Returns:
-#     - nx.Graph: A new graph with hydrogen atoms expanded.
-#     """
-#     new_graph = graph.copy()  # Create a copy to modify and return
-#     atom_map = (
-#         max(data["atom_map"] for _, data in graph.nodes(data=True))
-#         if graph.nodes
-#         else 0
-#     )
-
-#     # Iterate through each node to process potential hydrogens
-#     for node, data in graph.nodes(data=True):
-#         hcount = data.get("hcount", 0)
-#         if hcount > 0:
-#             for _ in range(hcount):
-#                 atom_map += 1
-#                 hydrogen_node = {
-#                     "element": "H",
-#                     "charge": 0,
-#                     "atom_map": atom_map,
-#                 }
-#                 new_graph.add_node(atom_map, **hydrogen_node)
-#                 new_graph.add_edge(node, atom_map, order=(1.0, 1.0), standard_order=0.0)
-
-#     return new_graph
+def _normalize_sequence_at_index(
+    seqs: Iterable[Any], index: int = 2, target_min: int = 0
+) -> Optional[Tuple[Any, ...]]:
+    """
+    If possible, shift the integer at `index` in each sequence so that the minimum becomes
+    `target_min`. Returns a new tuple of sequences if any change is needed, else None.
+    """
+    # collect valid ints at the index
+    valid_vals = [
+        t[index]
+        for t in seqs
+        if isinstance(t, (list, tuple)) and len(t) > index and isinstance(t[index], int)
+    ]
+    if not valid_vals:
+        return None
+
+    offset = min(valid_vals) - target_min
+    if offset == 0:
+        return None  # already normalized
+
+    def normalize(t):
+        if (
+            isinstance(t, (list, tuple))
+            and len(t) > index
+            and isinstance(t[index], int)
+        ):
+            t_list = list(t)
+            t_list[index] = t_list[index] - offset
+            return tuple(t_list)
+        return t  # leave untouched
+
+    return tuple(normalize(t) for t in seqs)
+
+
+def standardize_hydrogen(G: nx.Graph, in_place: bool = False) -> nx.Graph:
+    """
+    For each node, shift the third element (index 2) of each tuple in 'typesGH' so that the
+    minimum among those values becomes zero. Nonconforming entries are preserved.
+    """
+    target = G if in_place else G.copy()
+
+    for node, data in target.nodes(data=True):
+        typesGH = data.get("typesGH")
+        if not typesGH:
+            continue
+        normalized = _normalize_sequence_at_index(typesGH, index=2, target_min=0)
+        if normalized is not None:
+            target.nodes[node]["typesGH"] = normalized
+
+    return target
 
 
 def check_equivariant_graph(

synkit-0.0.15/synkit/Graph/ITS/its_construction.py

@@ -0,0 +1,316 @@
+import networkx as nx
+from typing import Tuple, Dict, Any, Optional, List, Hashable
+from copy import deepcopy
+
+
+class ITSConstruction:
+    # Core defaults; mutable ones (like neighbors) are factories to avoid shared state.
+    CORE_NODE_DEFAULTS: Dict[str, Any] = {
+        "element": "*",
+        "charge": 0,
+        "atom_map": 0,
+        "hcount": 0,
+        "aromatic": False,
+        "neighbors": lambda: ["", ""],
+    }
+
+    CORE_EDGE_DEFAULTS: Dict[str, Any] = {
+        "order": 0.0,
+        "ez_isomer": "",
+        "bond_type": "",
+        "conjugated": False,
+        "in_ring": False,
+    }
+
+    @staticmethod
+    def _resolve_defaults(
+        user_defaults: Optional[Dict[str, Any]], core_defaults: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Merge user-specified defaults with core defaults, producing fresh copies for mutables.
+
+        :param user_defaults: Overrides provided by the caller.
+        :type user_defaults: dict[str, Any] or None
+        :param core_defaults: The built-in default mapping; values may be factories.
+        :type core_defaults: dict[str, Any]
+        :returns: Fully resolved defaults with user values taking precedence and fresh instances for factories.
+        :rtype: dict[str, Any]
+        """
+        resolved: Dict[str, Any] = {}
+        user_defaults = user_defaults or {}
+        for key, core_val in core_defaults.items():
+            if key in user_defaults:
+                resolved[key] = deepcopy(user_defaults[key])
+            else:
+                if callable(core_val):
+                    resolved[key] = core_val()
+                else:
+                    resolved[key] = deepcopy(core_val)
+        return resolved
+
+    @staticmethod
+    def _compute_standard_order(
+        its: nx.Graph, ignore_aromaticity: bool = False
+    ) -> None:
+        """
+        In-place compute and assign 'standard_order' on each edge of the ITS graph.
+
+        :param its: ITS graph whose edges have an 'order' tuple.
+        :type its: nx.Graph
+        :param ignore_aromaticity: If True, absolute differences < 1 are zeroed.
+        :type ignore_aromaticity: bool
+        """
+        for u, v, data in its.edges(data=True):
+            order_tuple = data.get("order", (0.0, 0.0))
+            try:
+                o_g, o_h = order_tuple
+            except Exception:
+                o_g, o_h = 0.0, 0.0
+            standard_order = o_g - o_h
+            if ignore_aromaticity and abs(standard_order) < 1:
+                standard_order = 0
+            its[u][v]["standard_order"] = standard_order
+
+    @staticmethod
+    def construct(
+        G: nx.Graph,
+        H: nx.Graph,
+        *,
+        ignore_aromaticity: bool = False,
+        balance_its: bool = True,
+        store: bool = True,
+        node_attrs: Optional[List[str]] = None,
+        edge_attrs: Optional[List[str]] = None,
+        attributes_defaults: Optional[Dict[str, Any]] = None,
+    ) -> nx.Graph:
+        """
+        Construct an ITS graph by merging nodes and edges from G and H, preserving nodes
+        present only in one graph and filling missing-side attributes with defaults.
+
+        Node-level attributes are always reflected in `typesGH` as ((G_tuple), (H_tuple))
+        over `node_attrs`. If `store=True`, the individual attributes are stored as
+        (G_value, H_value) tuples under their own keys; if `store=False`, only the G-side
+        value is stored under each attribute key.
+
+        :param G: The first input graph (reactant-like).
+        :type G: nx.Graph
+        :param H: The second input graph (product-like).
+        :type H: nx.Graph
+        :param ignore_aromaticity: If True, small differences in bond order (<1)
+            are treated as zero.
+        :type ignore_aromaticity: bool
+        :param balance_its: If True, choose the smaller graph (by node count)
+            as the base; otherwise the larger.
+        :type balance_its: bool
+        :param store: If True, keep per-attribute (G,H) tuples; if False, keep only the G-side value per attribute.
+        :type store: bool
+        :param node_attrs: Ordered list of node attribute names to include in the node-level `typesGH` tuples.
+                           Defaults to ["element", "aromatic", "hcount", "charge", "neighbors"].
+        :type node_attrs: list[str] or None
+        :param edge_attrs: (Legacy) ordered list of edge attribute names; not used for core behavior.
+        :type edge_attrs: list[str] or None
+        :param attributes_defaults: Optional overrides for default node attribute values.
+        :type attributes_defaults: dict[str, Any] or None
+        :returns: ITS graph with merged node and edge annotations, including `typesGH`, `order`, and `standard_order`.
+        :rtype: nx.Graph
+        """
+        # typesGH attribute order
+        if node_attrs is None:
+            node_attrs = ["element", "aromatic", "hcount", "charge", "neighbors"]
+        if edge_attrs is None:
+            edge_attrs = ["order"]
+
+        node_defaults = ITSConstruction._resolve_defaults(
+            attributes_defaults, ITSConstruction.CORE_NODE_DEFAULTS
+        )
+
+        # Select base graph depending on balancing policy
+        if (balance_its and len(G.nodes) <= len(H.nodes)) or (
+            not balance_its and len(G.nodes) >= len(H.nodes)
+        ):
+            base = G
+        else:
+            base = H
+
+        ITS = deepcopy(base)
+        ITS.remove_edges_from(list(ITS.edges()))
+
+        # Ensure union of nodes exists
+        all_nodes = set(G.nodes()) | set(H.nodes())
+        for n in all_nodes:
+            if n not in ITS:
+                source_attrs = {}
+                if n in G:
+                    source_attrs = deepcopy(G.nodes[n])
+                elif n in H:
+                    source_attrs = deepcopy(H.nodes[n])
+                ITS.add_node(n, **source_attrs)
+
+        # Populate node-level per-attribute tuples and typesGH
+        for n in ITS.nodes():
+            g_tuple = tuple(
+                (
+                    G.nodes[n].get(attr, node_defaults.get(attr))
+                    if n in G
+                    else node_defaults.get(attr)
+                )
+                for attr in node_attrs
+            )
+            h_tuple = tuple(
+                (
+                    H.nodes[n].get(attr, node_defaults.get(attr))
+                    if n in H
+                    else node_defaults.get(attr)
+                )
+                for attr in node_attrs
+            )
+            ITS.nodes[n]["typesGH"] = (g_tuple, h_tuple)
+
+            for i, attr in enumerate(node_attrs):
+                if store:
+                    ITS.nodes[n][attr] = (g_tuple[i], h_tuple[i])
+                else:
+                    ITS.nodes[n][attr] = g_tuple[i]
+
+        # Union of edges: build order only (no edge typesGH)
+        edge_keys = {frozenset((u, v)) for u, v in G.edges()} | {
+            frozenset((u, v)) for u, v in H.edges()
+        }
+        for fs in edge_keys:
+            u, v = tuple(fs)
+            order_G = G[u][v].get("order", 0.0) if G.has_edge(u, v) else 0.0
+            order_H = H[u][v].get("order", 0.0) if H.has_edge(u, v) else 0.0
+            ITS.add_edge(u, v, order=(order_G, order_H))
+            # intentionally do NOT add edge-level typesGH per request
+
+        # Compute derived standard_order
+        ITSConstruction._compute_standard_order(
+            ITS, ignore_aromaticity=ignore_aromaticity
+        )
+
+        return ITS
+
+    @staticmethod
+    def ITSGraph(
+        G: nx.Graph,
+        H: nx.Graph,
+        ignore_aromaticity: bool = False,
+        attributes_defaults: Optional[Dict[str, Any]] = None,
+        balance_its: bool = False,
+        store: bool = False,
+    ) -> nx.Graph:
+        """
+        Backward-compatible wrapper that replicates the original ITSGraph signature while delegating
+        to the improved `construct` implementation.
+
+        :param G: The first input graph (reactant).
+        :type G: nx.Graph
+        :param H: The second input graph (product).
+        :type H: nx.Graph
+        :param ignore_aromaticity: If True, small order differences are treated as zero.
+        :type ignore_aromaticity: bool
+        :param attributes_defaults: Defaults to use when a node attribute is missing.
+        :type attributes_defaults: dict[str, Any] or None
+        :param balance_its: If True, base selection is balanced toward the smaller graph.
+        :type balance_its: bool
+        :param store: If True, keep full per-attribute tuples; if False, keep only G-side values.
+        :type store: bool
+        :returns: Constructed ITS graph with legacy node attribute ordering.
+        :rtype: nx.Graph
+        """
+        node_attrs = ["element", "aromatic", "hcount", "charge", "neighbors"]
+        edge_attrs = ["order"]
+        return ITSConstruction.construct(
+            G,
+            H,
+            ignore_aromaticity=ignore_aromaticity,
+            balance_its=balance_its,
+            store=store,
+            node_attrs=node_attrs,
+            edge_attrs=edge_attrs,
+            attributes_defaults=attributes_defaults,
+        )
+
+    @staticmethod
+    def typesGH_info(
+        node_attrs: Optional[List[str]] = None, edge_attrs: Optional[List[str]] = None
+    ) -> Dict[str, Dict[str, Tuple[type, Any]]]:
+        """
+        Provide expected types and default values for interpreting `typesGH` tuples.
+
+        :param node_attrs: List of node attributes used in the node-level typesGH.
+        :type node_attrs: list[str] or None
+        :param edge_attrs: List of edge attributes used in the edge-level typesGH.
+        :type edge_attrs: list[str] or None
+        :returns: Nested dict describing (type, default) for each selected attribute.
+        :rtype: dict[str, dict[str, tuple[type, Any]]]
+        """
+        if node_attrs is None:
+            node_attrs = ["element", "aromatic", "hcount", "charge", "neighbors"]
+        if edge_attrs is None:
+            edge_attrs = ["order"]
+
+        node_prop_types: Dict[str, type] = {
+            "element": str,
+            "aromatic": bool,
+            "hcount": int,
+            "charge": int,
+            "neighbors": list,
+        }
+        edge_prop_types: Dict[str, type] = {
+            "order": float,
+            "ez_isomer": str,
+            "bond_type": str,
+            "conjugated": bool,
+            "in_ring": bool,
+        }
+
+        node_defaults = {
+            attr: (
+                node_prop_types.get(attr, object),
+                (
+                    ITSConstruction.CORE_NODE_DEFAULTS.get(attr)()
+                    if callable(ITSConstruction.CORE_NODE_DEFAULTS.get(attr))
+                    else ITSConstruction.CORE_NODE_DEFAULTS.get(attr)
+                ),
+            )
+            for attr in node_attrs
+        }
+        edge_defaults = {
+            attr: (
+                edge_prop_types.get(attr, object),
+                ITSConstruction.CORE_EDGE_DEFAULTS.get(attr),
+            )
+            for attr in edge_attrs
+        }
+
+        return {"node": node_defaults, "edge": edge_defaults}
+
+    # Legacy helpers kept for compatibility:
+    @staticmethod
+    def get_node_attribute(
+        graph: nx.Graph, node: Hashable, attribute: str, default: Any
+    ) -> Any:
+        """Retrieve a node attribute or return a default if missing."""
+        try:
+            return graph.nodes[node][attribute]
+        except KeyError:
+            return default
+
+    @staticmethod
+    def get_node_attributes_with_defaults(
+        graph: nx.Graph, node: Hashable, attributes_defaults: Dict[str, Any] = None
+    ) -> Tuple:
+        """Retrieve multiple node attributes applying provided simple defaults."""
+        if attributes_defaults is None:
+            attributes_defaults = {
+                "element": "*",
+                "aromatic": False,
+                "hcount": 0,
+                "charge": 0,
+                "neighbors": ["", ""],
+            }
+        return tuple(
+            ITSConstruction.get_node_attribute(graph, node, attr, default)
+            for attr, default in attributes_defaults.items()
+        )

{synkit-0.0.14 → synkit-0.0.15}/synkit/Graph/ITS/its_decompose.py

@@ -404,7 +404,7 @@ def its_decompose(its_graph: nx.Graph, nodes_share="typesGH", edges_share="order
                 aromatic=node_attr_g[1],
                 hcount=node_attr_g[2],
                 charge=node_attr_g[3],
-                neighbors=node_attr_g[4],
+                # neighbors=node_attr_g[4],
                 atom_map=node,
             )
             if len(node_attr_h) > 0:
@@ -415,7 +415,7 @@ def its_decompose(its_graph: nx.Graph, nodes_share="typesGH", edges_share="order
                     aromatic=node_attr_h[1],
                     hcount=node_attr_h[2],
                     charge=node_attr_h[3],
-                    neighbors=node_attr_h[4],
+                    # neighbors=node_attr_h[4],
                     atom_map=node,
                 )