Update fails_species_constraints

- returns only either False or a str, instead of a tuple
- user must check if fails_species_constraints != False (or lazily if
  just fails_species_constraints) as both will return the reason for
failing constraints; if no failure it will return False
- Fixes a bug with implementation

Author: jonwzheng

rmgpy/constraints.py

@@ -61,8 +61,8 @@ def pass_cutting_threshold(species):
 def fails_species_constraints(species):
     """
     Pass in either a `Species` or `Molecule` object and checks whether it passes 
-    the speciesConstraints set by the user.  If not, returns a tuple `(True, reason)` for failing speciesConstraints,
-    where `reason` is a string describing which constraint failed. If all constraints pass, returns `(False, None)`.
+    the speciesConstraints set by the user.  If the species fails constraints, returns 
+    a string `reason` describing which constraint failed. If all constraints pass, returns `False`.
     """
 
     from rmgpy.rmg.input import get_input
@@ -82,63 +82,63 @@ def fails_species_constraints(species):
     explicitly_allowed_molecules = species_constraints.get('explicitlyAllowedMolecules', [])
     for molecule in explicitly_allowed_molecules:
         if struct.is_isomorphic(molecule):
-            return (False, None)
+            return False
 
     max_carbon_atoms = species_constraints.get('maximumCarbonAtoms', -1)
     if max_carbon_atoms != -1:
         if struct.get_num_atoms('C') > max_carbon_atoms:
-            return (True, f"Exceeded maximumCarbonAtoms: {struct.get_num_atoms('C')} > {max_carbon_atoms}")
+            return f"Exceeded maximumCarbonAtoms: {struct.get_num_atoms('C')} > {max_carbon_atoms}"
 
     max_oxygen_atoms = species_constraints.get('maximumOxygenAtoms', -1)
     if max_oxygen_atoms != -1:
         if struct.get_num_atoms('O') > max_oxygen_atoms:
-            return (True, f"Exceeded maximumOxygenAtoms: {struct.get_num_atoms('O')} > {max_oxygen_atoms}")
+            return f"Exceeded maximumOxygenAtoms: {struct.get_num_atoms('O')} > {max_oxygen_atoms}"
 
     max_nitrogen_atoms = species_constraints.get('maximumNitrogenAtoms', -1)
     if max_nitrogen_atoms != -1:
         if struct.get_num_atoms('N') > max_nitrogen_atoms:
-            return (True, f"Exceeded maximumNitrogenAtoms: {struct.get_num_atoms('N')} > {max_nitrogen_atoms}")
+            return f"Exceeded maximumNitrogenAtoms: {struct.get_num_atoms('N')} > {max_nitrogen_atoms}"
 
     max_silicon_atoms = species_constraints.get('maximumSiliconAtoms', -1)
     if max_silicon_atoms != -1:
         if struct.get_num_atoms('Si') > max_silicon_atoms:
-            return (True, f"Exceeded maximumSiliconAtoms: {struct.get_num_atoms('Si')} > {max_silicon_atoms}")
+            return f"Exceeded maximumSiliconAtoms: {struct.get_num_atoms('Si')} > {max_silicon_atoms}"
 
     max_sulfur_atoms = species_constraints.get('maximumSulfurAtoms', -1)
     if max_sulfur_atoms != -1:
         if struct.get_num_atoms('S') > max_sulfur_atoms:
-            return (True, f"Exceeded maximumSulfurAtoms: {struct.get_num_atoms('S')} > {max_sulfur_atoms}")
+            return f"Exceeded maximumSulfurAtoms: {struct.get_num_atoms('S')} > {max_sulfur_atoms}"
 
     max_heavy_atoms = species_constraints.get('maximumHeavyAtoms', -1)
     if max_heavy_atoms != -1:
         heavy_atoms = struct.get_num_atoms() - struct.get_num_atoms('H')
         if heavy_atoms > max_heavy_atoms:
-            return (True, f"Exceeded maximumHeavyAtoms: {heavy_atoms} > {max_heavy_atoms}")
+            return f"Exceeded maximumHeavyAtoms: {heavy_atoms} > {max_heavy_atoms}"
 
     max_surface_sites = species_constraints.get('maximumSurfaceSites', -1)
     if max_surface_sites != -1:
         if struct.get_num_atoms('X') > max_surface_sites:
-            return (True, f"Exceeded maximumSurfaceSites: {struct.get_num_atoms('X')} > {max_surface_sites}")
+            return f"Exceeded maximumSurfaceSites: {struct.get_num_atoms('X')} > {max_surface_sites}"
 
     max_surface_bond_order = species_constraints.get('maximumSurfaceBondOrder', -1)
     if max_surface_bond_order != -1:
         for site in struct.get_surface_sites():
             if site.get_total_bond_order() > max_surface_bond_order:
-                return (True, f"Exceeded maximumSurfaceBondOrder at site: {site.get_total_bond_order()} > {max_surface_bond_order}")
+                return f"Exceeded maximumSurfaceBondOrder at site: {site.get_total_bond_order()} > {max_surface_bond_order}"
 
     max_radicals = species_constraints.get('maximumRadicalElectrons', -1)
     if max_radicals != -1:
         if struct.get_radical_count() > max_radicals:
-            return (True, f"Exceeded maximumRadicalElectrons: {struct.get_radical_count()} > {max_radicals}")
+            return f"Exceeded maximumRadicalElectrons: {struct.get_radical_count()} > {max_radicals}"
 
     max_carbenes = species_constraints.get('maximumSingletCarbenes', 1)
-    if max_radicals != -1:
+    if max_carbenes != -1:
         if struct.get_singlet_carbene_count() > max_carbenes:
-            return (True, f"Exceeded maximumSingletCarbenes: {struct.get_singlet_carbene_count()} > {max_carbenes}")
+            return f"Exceeded maximumSingletCarbenes: {struct.get_singlet_carbene_count()} > {max_carbenes}"
 
     max_carbene_radicals = species_constraints.get('maximumCarbeneRadicals', 0)
     if max_carbene_radicals != -1:
         if struct.get_singlet_carbene_count() > 0 and struct.get_radical_count() > max_carbene_radicals:
-            return (True, f"Exceeded maximumCarbeneRadicals: {struct.get_radical_count()} > {max_carbene_radicals}")
+            return f"Exceeded maximumCarbeneRadicals: {struct.get_radical_count()} > {max_carbene_radicals}"
 
-    return (False, None)
+    return False

rmgpy/data/kinetics/family.py

@@ -1654,8 +1654,8 @@ def _generate_product_structures(self, reactant_structures, maps, forward, relab
         for struct in product_structures:
             if self.is_molecule_forbidden(struct):
                 raise ForbiddenStructureException()
-            failed, reason = fails_species_constraints(struct)
-            if failed:
+            if fails_species_constraints(struct):
+                reason = fails_species_constraints(struct)
                 raise ForbiddenStructureException(
                     "Species constraints forbids product species {0}. Please "
                     "reformulate constraints, or explicitly "

rmgpy/rmg/main.py

@@ -689,11 +689,11 @@ def initialize(self, **kwargs):
                         "Input species {0} is globally forbidden. You may explicitly "
                         "allow it by adding 'input species' to the `generatedSpeciesConstraints` `allowed` list.".format(spec.label)
                     )
-            failed, reason = fails_species_constraints(spec)
-            if failed:
+            if fails_species_constraints(spec):
                 if "allowed" in self.species_constraints and "input species" in self.species_constraints["allowed"]:
                     self.species_constraints["explicitlyAllowedMolecules"].append(spec.molecule[0])
                 else:
+                    reason = fails_species_constraints(spec)
                     raise ForbiddenStructureException(
                         "Species constraints forbids input species {0}. Please "
                         "reformulate constraints, remove the species, or explicitly "

rmgpy/rmg/model.py

@@ -1673,11 +1673,11 @@ def add_seed_mechanism_to_core(self, seed_mechanism, react=False, requires_rms=F
                         "found in a seed mechanism or reaction "
                         "library.".format(spec.label, seed_mechanism.label)
                     )
-            failed, reason = fails_species_constraints(spec)
-            if failed:
+            if fails_species_constraints(spec):
                 if "allowed" in rmg.species_constraints and "seed mechanisms" in rmg.species_constraints["allowed"]:
                     rmg.species_constraints["explicitlyAllowedMolecules"].extend(spec.molecule)
                 else:
+                    reason = fails_species_constraints(spec)
                     raise ForbiddenStructureException(
                         "Species constraints forbids species {0} from seed mechanism {1}."
                         " Please reformulate constraints, remove the species, or"
@@ -1801,11 +1801,11 @@ def add_reaction_library_to_edge(self, reaction_library, requires_rms=False):
                             "inert unless found in a seed mechanism or reaction "
                             "library.".format(spec.label, reaction_library.label)
                         )
-            failed, reason = fails_species_constraints(spec)
-            if failed:
+            if fails_species_constraints(spec):
                 if "allowed" in rmg.species_constraints and "reaction libraries" in rmg.species_constraints["allowed"]:
                     rmg.species_constraints["explicitlyAllowedMolecules"].extend(spec.molecule)
                 else:
+                    reason = fails_species_constraints(spec)
                     raise ForbiddenStructureException(
                         "Species constraints forbids species {0} from reaction library "
                         "{1}. Please reformulate constraints, remove the species, or "

test/rmgpy/constraintsTest.py

@@ -83,8 +83,7 @@ def test_constraints_not_loaded(self, mock_logging):
         rmgpy.rmg.input.rmg = None
 
         mol = Molecule(smiles="C")
-        failed, _ = fails_species_constraints(mol)
-        assert not failed
+        assert not fails_species_constraints(mol)
 
         mock_logging.debug.assert_called_with("Species constraints could not be found.")
 
@@ -97,80 +96,67 @@ def test_species_input(self):
         """
         spc = Species().from_smiles("C")
 
-        failed, _ = fails_species_constraints(spc)
-        assert not failed
+        assert not fails_species_constraints(spc)
 
     def test_explicitly_allowed_molecules(self):
         """
         Test that we can explicitly allow molecules in species constraints.
         """
         mol = Molecule(smiles="CCCC")
-        failed, _ = fails_species_constraints(mol)
-        assert failed
+        assert fails_species_constraints(mol)
 
         self.rmg.species_constraints["explicitlyAllowedMolecules"] = [Molecule(smiles="CCCC")]
-        failed, _ = fails_species_constraints(mol)
-        assert not failed
+        assert not fails_species_constraints(mol)
 
     def test_carbon_constraint(self):
         """
         Test that we can constrain the max number of carbon atoms.
         """
         mol1 = Molecule(smiles="CC")
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule(smiles="CCC")
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_oxygen_constraint(self):
         """
         Test that we can constrain the max number of oxygen atoms.
         """
         mol1 = Molecule(smiles="C=O")
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule(smiles="OC=O")
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_nitrogen_constraint(self):
         """
         Test that we can constrain the max number of nitrogen atoms.
         """
         mol1 = Molecule(smiles="CN")
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule(smiles="NCN")
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_silicon_constraint(self):
         """
         Test that we can constrain the max number of silicon atoms.
         """
         mol1 = Molecule(smiles="[SiH4]")
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule(smiles="[SiH3][SiH3]")
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_sulfur_constraint(self):
         """
         Test that we can constrain the max number of sulfur atoms.
         """
         mol1 = Molecule(smiles="CS")
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule(smiles="SCS")
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_surface_site_constraint(self):
         """
@@ -222,17 +208,13 @@ def test_surface_site_constraint(self):
         self.rmg.species_constraints["maximumCarbonAtoms"] = 3
         self.rmg.species_constraints["maximumHeavyAtoms"] = 6
 
-        failed, _ = fails_species_constraints(mol_1site)
-        assert not failed
+        assert not fails_species_constraints(mol_1site)
 
-        failed, _ = fails_species_constraints(mol_2site)
-        assert not failed
+        assert not fails_species_constraints(mol_2site)
 
-        failed, _ = fails_species_constraints(mol_3site_vdW)
-        assert failed
+        assert fails_species_constraints(mol_3site_vdW)
 
-        failed, _ = fails_species_constraints(mol_3site)
-        assert failed
+        assert fails_species_constraints(mol_3site)
 
         self.rmg.species_constraints["maximumCarbonAtoms"] = max_carbon
         self.rmg.species_constraints["maximumHeavyAtoms"] = max_heavy_atoms
@@ -247,32 +229,27 @@ def test_surface_bond_order_constraint(self):
 2 X u0 p0 c0 {1,Q}
 """
         )
-        failed, _ = fails_species_constraints(mol_1site)
-        assert failed
+        assert fails_species_constraints(mol_1site)
 
     def test_heavy_constraint(self):
         """
         Test that we can constrain the max number of heavy atoms.
         """
         mol1 = Molecule(smiles="CCO")
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule(smiles="CCN=O")
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_radical_constraint(self):
         """
         Test that we can constrain the max number of radical electrons.
         """
         mol1 = Molecule(smiles="[CH2][CH2]")
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule(smiles="[CH2][CH][CH2]")
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_carbene_constraint(self):
         """
@@ -285,8 +262,7 @@ def test_carbene_constraint(self):
 3 H u0 p0 c0 {1,S}
 """
         )
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule().from_adjacency_list(
             """
@@ -296,8 +272,7 @@ def test_carbene_constraint(self):
 4 H u0 p0 c0 {3,S}
 """
         )
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)
 
     def test_carbene_radical_constraint(self):
         """
@@ -310,8 +285,7 @@ def test_carbene_radical_constraint(self):
 3 H u0 p0 c0 {1,S}
 """
         )
-        failed, _ = fails_species_constraints(mol1)
-        assert not failed
+        assert not fails_species_constraints(mol1)
 
         mol2 = Molecule().from_adjacency_list(
             """
@@ -322,5 +296,4 @@ def test_carbene_radical_constraint(self):
 5 H u0 p0 c0 {3,S}
 """
         )
-        failed, _ = fails_species_constraints(mol2)
-        assert failed
+        assert fails_species_constraints(mol2)