rxkit 0.1.1__tar.gz → 0.1.2__tar.gz

{rxkit-0.1.1 → rxkit-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rxkit
-Version: 0.1.1
+Version: 0.1.2
 Summary: Chemical reaction and molecule SMILES canonicalization toolkit
 Author: Long
 License: MIT

{rxkit-0.1.1 → rxkit-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rxkit"
-version = "0.1.1"
+version = "0.1.2"
 description = "Chemical reaction and molecule SMILES canonicalization toolkit"
 readme = "README.md"
 license = {text = "MIT"}

{rxkit-0.1.1 → rxkit-0.1.2}/rxkit/canonicalize/__init__.py

@@ -31,5 +31,5 @@ from .rxn_utils import (
     UNKNOWN,
 )
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 

{rxkit-0.1.1 → rxkit-0.1.2}/rxkit/canonicalize/rxn_utils.py

@@ -538,7 +538,7 @@ def is_valid_reaction(rxn, rxn_type=None, allow_empty_products=False, is_strict=
         False
     """
     # Local import to avoid circular import at module load time
-    from canonicalize.mol_utils import is_valid_molecule
+    from .mol_utils import is_valid_molecule
 
     if not isinstance(rxn, str) or not rxn.strip():
         return False

{rxkit-0.1.1 → rxkit-0.1.2}/rxkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rxkit
-Version: 0.1.1
+Version: 0.1.2
 Summary: Chemical reaction and molecule SMILES canonicalization toolkit
 Author: Long
 License: MIT

{rxkit-0.1.1 → rxkit-0.1.2}/tests/test_mol_utils.py

@@ -127,16 +127,16 @@ class TestTildeStandardConversion:
     """Tests for tilde <-> standard reaction SMILES conversion."""
 
     def test_tilde_to_standard(self):
-        from canonicalize import tilde_to_standard
+        from rxkit.canonicalize import tilde_to_standard
         assert tilde_to_standard("CC.O.[Na+]~[Cl-]>>CCO") == "CC.O.[Na+].[Cl-]>>CCO"
 
     def test_standard_to_tilde_naive(self):
         """``standard_to_tilde`` is a string-level rewrite: ``.`` -> ``~`` everywhere on each side."""
-        from canonicalize import standard_to_tilde
+        from rxkit.canonicalize import standard_to_tilde
         assert standard_to_tilde("CC.O.[Na+].[Cl-]>>CCO") == "CC~O~[Na+]~[Cl-]>>CCO"
 
     def test_no_tilde_unchanged(self):
-        from canonicalize import tilde_to_standard
+        from rxkit.canonicalize import tilde_to_standard
         assert tilde_to_standard("CC.O>>CCO") == "CC.O>>CCO"
 
 
@@ -150,7 +150,7 @@ class TestExtendedTildeConversion:
     """
 
     def test_split_smiles_and_fragment_info(self):
-        from canonicalize import split_smiles_and_fragment_info
+        from rxkit.canonicalize import split_smiles_and_fragment_info
         pure, info = split_smiles_and_fragment_info(
             "CC.O.[Na+].[Cl-]>>CCO |f:2.3|"
         )
@@ -158,25 +158,25 @@ class TestExtendedTildeConversion:
         assert info == "|f:2.3|"
 
     def test_determine_fragment_groups(self):
-        from canonicalize import determine_fragment_groups
+        from rxkit.canonicalize import determine_fragment_groups
         assert determine_fragment_groups("|f:2.3|") == [[2, 3]]
         assert determine_fragment_groups("|f:0.2,5.6|") == [[0, 2], [5, 6]]
         assert determine_fragment_groups("") == []
 
     def test_user_requirement_extended_to_tilde(self):
         """The exact example from the user's request."""
-        from canonicalize import extended_to_tilde
+        from rxkit.canonicalize import extended_to_tilde
         src = "CC.O.[Na+].[Cl-]>>CCO |f:2.3|"
         expected = "CC.O.[Na+]~[Cl-]>>CCO"
         assert extended_to_tilde(src) == expected
 
     def test_roundtrip_tilde_to_extended(self):
-        from canonicalize import tilde_to_extended
+        from rxkit.canonicalize import tilde_to_extended
         result = tilde_to_extended("CC.O.[Na+]~[Cl-]>>CCO")
         assert result == "CC.O.[Na+].[Cl-]>>CCO |f:2.3|"
 
     def test_parse_extended(self):
-        from canonicalize import parse_extended_reaction_smiles
+        from rxkit.canonicalize import parse_extended_reaction_smiles
         r, a, p = parse_extended_reaction_smiles(
             "CC.O.[Na+].[Cl-]>>CCO |f:2.3|"
         )
@@ -186,7 +186,7 @@ class TestExtendedTildeConversion:
         assert p == ["CCO"]
 
     def test_parse_extended_groups_on_both_sides(self):
-        from canonicalize import parse_extended_reaction_smiles
+        from rxkit.canonicalize import parse_extended_reaction_smiles
         r, a, p = parse_extended_reaction_smiles(
             "CC.O.[Na+].[Cl-]>>CCO.[Na+].[Cl-] |f:2.3,5.6|"
         )
@@ -194,7 +194,7 @@ class TestExtendedTildeConversion:
         assert p == ["CCO", "[Na+].[Cl-]"]
 
     def test_to_extended_reaction_smiles(self):
-        from canonicalize import to_extended_reaction_smiles
+        from rxkit.canonicalize import to_extended_reaction_smiles
         result = to_extended_reaction_smiles(
             ["CC", "O", "[Na+].[Cl-]"], [], ["CCO"]
         )
@@ -202,19 +202,19 @@ class TestExtendedTildeConversion:
 
     def test_to_extended_no_groups_returns_standard(self):
         """If no compound has multiple fragments, the EXTENDED form is just STANDARD."""
-        from canonicalize import to_extended_reaction_smiles
+        from rxkit.canonicalize import to_extended_reaction_smiles
         result = to_extended_reaction_smiles(["CC", "O"], [], ["CCO"])
         assert result == "CC.O>>CCO"
 
     def test_parse_tilde_reaction_smiles(self):
-        from canonicalize import parse_tilde_reaction_smiles
+        from rxkit.canonicalize import parse_tilde_reaction_smiles
         r, a, p = parse_tilde_reaction_smiles("CC.O.[Na+]~[Cl-]>>CCO")
         assert r == ["CC", "O", "[Na+].[Cl-]"]
         assert a == []
         assert p == ["CCO"]
 
     def test_extended_to_standard_drops_fragment_info(self):
-        from canonicalize import extended_to_standard
+        from rxkit.canonicalize import extended_to_standard
         assert extended_to_standard(
             "CC.O.[Na+].[Cl-]>>CCO |f:2.3|"
         ) == "CC.O.[Na+].[Cl-]>>CCO"
@@ -224,54 +224,54 @@ class TestIsValidMolecule:
     """Tests for the is_valid_molecule helper."""
 
     def test_valid_simple(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule("CCO") is True
 
     def test_valid_aromatic(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule("c1ccccc1") is True
 
     def test_valid_ionic(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule("[Na+].[Cl-]") is True
 
     def test_invalid_garbage(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule("not_a_smiles") is False
 
     def test_invalid_unbalanced_bracket(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule("C[C") is False
 
     def test_empty_invalid_by_default(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule("") is False
 
     def test_empty_allowed_when_flag_set(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule("", allow_empty=True) is True
 
     def test_none_is_invalid(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule(None) is False  # type: ignore[arg-type]
 
     def test_non_string_is_invalid(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule(123) is False  # type: ignore[arg-type]
 
     def test_list_all_valid(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule(["CCO", "c1ccccc1", "[Na+]"]) is True
 
     def test_list_one_invalid(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule(["CCO", "not_a_smiles"]) is False
 
     def test_list_with_empty_invalid_by_default(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule(["CCO", ""]) is False
 
     def test_list_with_empty_allowed(self):
-        from canonicalize import is_valid_molecule
+        from rxkit.canonicalize import is_valid_molecule
         assert is_valid_molecule(["CCO", ""], allow_empty=True) is True
 

{rxkit-0.1.1 → rxkit-0.1.2}/tests/test_rxn_utils.py

@@ -159,52 +159,52 @@ class TestIsValidReaction:
     """Tests for the is_valid_reaction helper."""
 
     def test_valid_standard(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("CCO.CCO>>CCOCCO") is True
 
     def test_valid_standard_agent(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("C=C.CC(=O)O>O>CC(=O)OC") is True
 
     def test_valid_tilde(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("CC.O.[Na+]~[Cl-]>>CCO") is True
 
     def test_valid_extended(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("CC.O.[Na+].[Cl-]>>CCO |f:2.3|") is True
 
     def test_invalid_garbage(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("not_a_reaction") is False
 
     def test_invalid_garbage_fragments(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("CCO.garbage>>CCOCCO") is False
 
     def test_empty_is_invalid(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("") is False
         assert is_valid_reaction("   ") is False
         assert is_valid_reaction(None) is False  # type: ignore[arg-type]
 
     def test_empty_products_invalid_by_default(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("CCO>>") is False
 
     def test_empty_products_allowed_when_flag(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # Empty products are allowed when the flag is explicitly set
         assert is_valid_reaction("CCO>>", allow_empty_products=True) is True
         # Same for STANDARD_agent-style templates with empty products
         assert is_valid_reaction("CCO>O>", allow_empty_products=True) is True
 
     def test_empty_reactants_invalid(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction(">>CCO") is False
 
     def test_explicit_rxn_type(self):
-        from canonicalize import is_valid_reaction, STANDARD
+        from rxkit.canonicalize import is_valid_reaction, STANDARD
         # Pass an EXTENDED SMILES but tell the validator it is STANDARD.
         # The result should be False because the |f:...| marker is not a
         # valid molecule SMILES.
@@ -214,7 +214,7 @@ class TestIsValidReaction:
         assert is_valid_reaction(rxn) is True
 
     def test_too_many_sides(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # 4 '>' characters yields 5 sides
         assert is_valid_reaction("CCO>CCO>CCO>CCO>CCO") is False
 
@@ -223,18 +223,18 @@ class TestIsValidReactionStrict:
     """Tests for the ``is_strict`` mode of is_valid_reaction."""
 
     def test_duplicate_in_reactants_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # Lenient mode: passes.  Strict mode: rejects duplicate reactant.
         assert is_valid_reaction("CCO.CCO>>CCOCCO") is True
         assert is_valid_reaction("CCO.CCO>>CCOCCO", is_strict=True) is False
 
     def test_duplicate_in_products_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("CCOCCO>>CCO.CCO") is True
         assert is_valid_reaction("CCOCCO>>CCO.CCO", is_strict=True) is False
 
     def test_duplicate_in_reagents_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         assert is_valid_reaction("CCN>c1ccccc1.c1ccccc1>CCNC(=O)c1ccccc1") is True
         assert (
             is_valid_reaction(
@@ -245,20 +245,20 @@ class TestIsValidReactionStrict:
         )
 
     def test_same_reactant_and_product_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # No-op reaction: same molecule on both sides.
         assert is_valid_reaction("CCO>>CCO") is True
         assert is_valid_reaction("CCO>>CCO", is_strict=True) is False
 
     def test_reactant_in_products_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # ``CCO`` appears as both reactant and product.  Not a pure
         # solvent-only reaction, so strict mode rejects it.
         assert is_valid_reaction("CCO.CCN>>CCO.CCN") is True
         assert is_valid_reaction("CCO.CCN>>CCO.CCN", is_strict=True) is False
 
     def test_reagent_appears_in_reactants_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # Benzene appears as both reagent and reactant.
         assert is_valid_reaction("c1ccccc1.CC(=O)O>c1ccccc1>CC(=O)OC") is True
         assert (
@@ -270,7 +270,7 @@ class TestIsValidReactionStrict:
         )
 
     def test_solvent_all_three_sides_is_allowed(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # ``CCO`` is a solvent appearing on all three sides.  This is
         # the canonical "solvent-only" template and must be allowed
         # even in strict mode.
@@ -280,26 +280,26 @@ class TestIsValidReactionStrict:
         )
 
     def test_empty_fragment_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # Consecutive dots
         assert is_valid_reaction("CCO..CCN>>CCNCCO") is False
         assert is_valid_reaction("CCO..CCN>>CCNCCO", is_strict=True) is False
 
     def test_leading_dot_fragment_raises(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # Leading dot — also an empty fragment.
         assert is_valid_reaction(".CCO>>CCO") is False
         assert is_valid_reaction(".CCO>>CCO", is_strict=True) is False
 
     def test_tilde_reaction_with_duplicate(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # Tilde reaction where two fragment groups are actually the
         # same compound.
         assert is_valid_reaction("CCO~CCO>>CCOCCO") is True
         assert is_valid_reaction("CCO~CCO>>CCOCCO", is_strict=True) is False
 
     def test_extended_reaction_with_duplicate(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # Same molecule in two different groups — also a duplicate.
         assert is_valid_reaction("CCO.CCO>>CCOCCO |f:0.1|") is True
         assert (
@@ -307,7 +307,7 @@ class TestIsValidReactionStrict:
         )
 
     def test_strict_passes_for_clean_reaction(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # A clean, well-formed reaction should still pass in strict mode.
         assert is_valid_reaction("CCO.CCN>>CCNCCO", is_strict=True) is True
         assert (
@@ -315,7 +315,7 @@ class TestIsValidReactionStrict:
         )
 
     def test_strict_canonicalisation_isolates_different_writings(self):
-        from canonicalize import is_valid_reaction
+        from rxkit.canonicalize import is_valid_reaction
         # ``CCO`` and ``OCC`` are the same molecule written differently.
         assert is_valid_reaction("CCO.OCC>>CCOCCO") is True
         assert is_valid_reaction("CCO.OCC>>CCOCCO", is_strict=True) is False