chython 2.4__cp312-cp312-win_amd64.whl

chython/files/daylight/test/test_daylight_smarts.py

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@gmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+import pytest
+from chython.exceptions import IncorrectSmiles
+from chython.files.daylight.smarts import smarts
+from chython import smiles
+
+
+def test_daylight_smarts_basic():
+    # Test basic atomic symbols
+    pattern = smarts('[C]')  # aliphatic carbon
+    assert len(pattern) == 1
+    
+    pattern = smarts('[N]')  # nitrogen
+    assert len(pattern) == 1
+    
+    pattern = smarts('[O]')  # oxygen
+    assert len(pattern) == 1
+
+
+def test_daylight_smarts_empty():
+    # Test empty SMARTS
+    with pytest.raises(ValueError):  # smarts() splits input and expects at least 1 value
+        smarts('')
+
+
+def test_daylight_smarts_invalid():
+    # Test invalid SMARTS
+    with pytest.raises(IncorrectSmiles):
+        smarts('[')  # unclosed bracket
+
+
+def test_daylight_smarts_bonds():
+    # Test bond primitives
+    pattern = smarts('CC')  # single bond
+    assert len(pattern) == 2
+    
+    pattern = smarts('C=C')  # double bond
+    assert len(pattern) == 2
+    
+    pattern = smarts('C#C')  # triple bond
+    assert len(pattern) == 2
+
+
+def test_daylight_smarts_aromatic():
+    # Test aromatic specifications
+    pattern = smarts('CC=CC=C')  # conjugated system
+    assert len(pattern) == 5
+
+
+def test_daylight_smarts_complex():
+    # Test complex patterns
+    pattern = smarts('CC(=O)O')  # carboxylic acid
+    assert len(pattern) == 4
+    
+    pattern = smarts('CN(C)C')  # tertiary amine
+    assert len(pattern) == 4
+
+
+def test_daylight_smarts_functional_groups():
+    # Test common functional group patterns
+    # Create test molecules
+    ethanol = smiles('CCO')
+    benzene = smiles('c1ccccc1')
+    acetic_acid = smiles('CC(=O)O')
+    dimethylamine = smiles('CNC')
+    phenol = smiles('c1ccccc1O')
+
+    # Test alcohol pattern
+    alcohol_pattern = smarts('CO')
+    assert alcohol_pattern.is_substructure(ethanol)  # should match ethanol
+    assert not alcohol_pattern.is_substructure(benzene)  # should not match benzene
+
+    # Test carboxylic acid pattern
+    acid_pattern = smarts('CC(=O)O')
+    assert acid_pattern.is_substructure(acetic_acid)
+    assert not acid_pattern.is_substructure(ethanol)
+
+
+def test_daylight_smarts_multiple_matches():
+    # Test patterns that can have multiple matches in a molecule
+    # Create test molecules
+    propanediol = smiles('OCCO')  # 1,2-propanediol
+    diethylether = smiles('CCOCC')  # diethyl ether
+
+    # Test alcohol pattern (should find two matches in propanediol)
+    alcohol_pattern = smarts('CO')
+    matches = list(alcohol_pattern.get_mapping(propanediol))
+    assert len(matches) == 2  # should find two alcohol groups
+
+    # Test ether pattern (should find one match in diethylether)
+    ether_pattern = smarts('COC')
+    matches = list(ether_pattern.get_mapping(diethylether))
+    assert len(matches) == 1  # should find one ether group
+
+
+def test_daylight_smarts_heterocycles():
+    # Test complex heterocyclic systems
+    # Create test molecules with sophisticated ring systems
+    isoxazole = smiles('c1noc1')  # five-membered N-O ring
+    indole = smiles('c1ccc2ccnc2c1')  # bicyclic with N
+    benzofuran = smiles('c1ccc2ccoc2c1')  # bicyclic with O
+    
+    # Test basic ring patterns
+    # Test individual atoms instead of full ring pattern
+    n_pattern = smarts('n')  # aromatic nitrogen
+    assert n_pattern.is_substructure(isoxazole)
+    
+    o_pattern = smarts('o')  # aromatic oxygen
+    assert o_pattern.is_substructure(isoxazole)
+    
+    # Test aromatic carbons
+    c_pattern = smarts('c')  # aromatic carbon
+    assert c_pattern.is_substructure(indole)
+    assert c_pattern.is_substructure(benzofuran)
+    
+    # Test aromatic ring fragments
+    c1c_pattern = smarts('c:c')  # aromatic C-C bond with explicit aromatic bond
+    assert c1c_pattern.is_substructure(indole)
+    assert c1c_pattern.is_substructure(benzofuran)
+    
+    # Test heteroatom connections
+    cn_pattern = smarts('c:n')  # aromatic C-N bond
+    assert cn_pattern.is_substructure(indole)
+    
+    co_pattern = smarts('c:o')  # aromatic C-O bond
+    assert co_pattern.is_substructure(benzofuran)
+
+
+def test_daylight_smarts_charged_aromatics():
+    # Test charged aromatic ring systems
+    pyridinium = smiles('c1cc[nH+]cc1')  # protonated pyridine
+    n_oxide = smiles('c1cc[n+]([O-])cc1')  # pyridine N-oxide
+    
+    # Test patterns for charged systems
+    charged_n = smarts('[N+]')  # positively charged nitrogen
+    assert charged_n.is_substructure(pyridinium)
+    assert charged_n.is_substructure(n_oxide)
+
+
+def test_daylight_smarts_drug_patterns():
+    # Test drug-like substructure patterns
+    # Create test molecules representing drug-like structures
+    aspirin = smiles('CC(=O)OC1=CC=CC=C1C(=O)O')  # aspirin
+    caffeine = smiles('CN1C=NC2=C1C(=O)N(C(=O)N2C)C')  # caffeine
+    
+    # Test common drug substructures
+    ester = smarts('CC(=O)O')  # ester group
+    assert ester.is_substructure(aspirin)
+    
+    amide = smarts('NC(=O)')  # amide group
+    assert amide.is_substructure(caffeine)
+    
+    carboxyl = smarts('C(=O)O')  # carboxylic acid
+    assert carboxyl.is_substructure(aspirin)
+
+
+def test_daylight_smarts_complex_rings():
+    # Test complex ring systems with multiple heteroatoms
+    tetrazole = smiles('c1nnnn1')  # five-membered ring with 4 nitrogens
+    oxadiazole = smiles('c1nnoc1')  # five-membered ring with O and 2 N
+    thiazole = smiles('c1scnc1')  # five-membered ring with S and N
+    
+    # Test patterns for heterocyclic systems
+    # Test individual atoms and bonds instead of full rings
+    n_pattern = smarts('n')  # aromatic nitrogen
+    assert n_pattern.is_substructure(tetrazole)
+    assert n_pattern.is_substructure(oxadiazole)
+    
+    o_pattern = smarts('o')  # aromatic oxygen
+    assert o_pattern.is_substructure(oxadiazole)
+    
+    s_pattern = smarts('s')  # aromatic sulfur
+    assert s_pattern.is_substructure(thiazole)
+
+
+def test_daylight_smarts_electronic_patterns():
+    # Test patterns for electron-withdrawing groups and electronic effects
+    
+    # Create test molecules
+    acetamide = smiles('CC(=O)N')  # amide
+    acetate = smiles('CC(=O)O')    # ester
+    acetic_acid = smiles('CC(=O)O')  # carboxylic acid
+    acetyl_chloride = smiles('CC(=O)Cl')  # acid chloride
+    nitromethane = smiles('CN(=O)=O')  # nitro compound
+    
+    # Test carbonyl-adjacent patterns
+    carbonyl_pattern = smarts('CC(=O)')  # basic carbonyl group
+    assert carbonyl_pattern.is_substructure(acetamide)
+    assert carbonyl_pattern.is_substructure(acetate)
+    assert carbonyl_pattern.is_substructure(acetic_acid)
+    
+    # Test carbonyl with heteroatom patterns
+    carbonyl_n = smarts('C(=O)N')  # C=O with adjacent N
+    assert carbonyl_n.is_substructure(acetamide)
+    
+    carbonyl_o = smarts('C(=O)O')  # C=O with adjacent O
+    assert carbonyl_o.is_substructure(acetate)
+    assert carbonyl_o.is_substructure(acetic_acid)
+    
+    # Test multiple bond patterns
+    double_bond_o = smarts('C=O')  # C=O double bond
+    assert double_bond_o.is_substructure(acetamide)
+    assert double_bond_o.is_substructure(acetate)
+    assert double_bond_o.is_substructure(acetic_acid)
+    
+    # Test halogen patterns
+    carbonyl_halogen = smarts('C(=O)Cl')  # acid chloride
+    assert carbonyl_halogen.is_substructure(acetyl_chloride)
+    
+    # Test nitro group pattern
+    nitro_pattern = smarts('N(=O)=O')  # nitro group
+    assert nitro_pattern.is_substructure(nitromethane)
+
+
+def test_daylight_smarts_conjugated_systems():
+    # Test patterns for conjugated systems
+    
+    # Create test molecules with conjugated systems
+    acrolein = smiles('C=CC=O')  # conjugated alkene-carbonyl
+    cinnamaldehyde = smiles('c1ccccc1C=CC=O')  # conjugated arene-alkene-carbonyl
+    acetophenone = smiles('CC(=O)c1ccccc1')  # conjugated arene-carbonyl
+    
+    # Test conjugated patterns
+    alkene_carbonyl = smarts('C=CC=O')  # conjugated alkene-carbonyl
+    assert alkene_carbonyl.is_substructure(acrolein)
+    assert alkene_carbonyl.is_substructure(cinnamaldehyde)
+    
+    # Test parts of the molecule separately
+    # Test aromatic carbons and bonds
+    c_pattern = smarts('c')  # aromatic carbon
+    assert c_pattern.is_substructure(acetophenone)
+    
+    cc_bond = smarts('cc')  # aromatic C-C bond
+    assert cc_bond.is_substructure(acetophenone)
+    
+    # Test carbonyl group
+    carbonyl = smarts('CC(=O)')  # carbonyl group
+    assert carbonyl.is_substructure(acetophenone)
+    
+    # Test extended conjugation
+    conj_bond = smarts('C=CC=O')  # conjugated double bonds
+    assert conj_bond.is_substructure(cinnamaldehyde)
+
+
+def test_daylight_smarts_complex_bicyclic():
+    # Test complex bicyclic pattern with N and S atoms
+    # Create test molecule - a simpler bicyclic system with N-S-N bridge
+    bicyclic = smiles('C1=CC=C2N=SN=C2C1')  # simplified bicyclic molecule without methyl group
+    
+    # Complex SMARTS pattern for bicyclic system
+    # Pattern matches: C1=C-C=C2-N=S-N=C2-C1
+    pattern = smarts('[#6]1=[#6]-[#6]=[#6]2-[#7]=[#16]-[#7]=[#6]2-[#6]1')
+    assert pattern.is_substructure(bicyclic)
+    
+    # Test non-matching molecule
+    benzene = smiles('c1ccccc1')
+    assert not pattern.is_substructure(benzene)
+    
+    # Test parts of the pattern
+    six_ring = smarts('[#6]1=[#6]-[#6]=[#6]-[#6]-[#6]1')  # matches C1=C-C=C-C-C1
+    assert six_ring.is_substructure(bicyclic)
+    
+    five_ring = smarts('[#6]1-[#7]=[#16]-[#7]=[#6]1')  # matches C1-N=S-N=C1
+    assert five_ring.is_substructure(bicyclic)
+    
+    # Test individual bonds
+    cn_double = smarts('[#6]=[#7]')  # C=N double bond
+    assert cn_double.is_substructure(bicyclic)
+    
+    ns_double = smarts('[#7]=[#16]')  # N=S double bond
+    assert ns_double.is_substructure(bicyclic) 

chython/files/daylight/test/test_daylight_smiles.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@gmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+import pytest
+from chython.exceptions import IncorrectSmiles
+from chython.files.daylight.parser import parser
+from chython.files.daylight.tokenize import smiles_tokenize
+
+
+def test_daylight_smiles_basic():
+    # Test basic SMILES
+    result = parser(list(smiles_tokenize('CC')), True)
+    assert len(result['atoms']) == 2
+    assert len(result['bonds']) == 1
+    
+    result = parser(list(smiles_tokenize('O')), True)
+    assert len(result['atoms']) == 1
+    assert not result['bonds']
+
+
+def test_daylight_smiles_empty():
+    # Test empty SMILES
+    tokens = list(smiles_tokenize(''))
+    assert len(tokens) == 0  # empty string should produce empty token list
+    
+    # Empty token list should raise error when parsing
+    with pytest.raises(IndexError):
+        parser(tokens, True)
+
+
+def test_daylight_smiles_invalid():
+    # Test invalid SMILES
+    with pytest.raises(IncorrectSmiles):
+        parser(list(smiles_tokenize('C1CC')), True)  # unclosed cycle
+
+
+def test_daylight_smiles_complex():
+    # Test complex SMILES
+    result = parser(list(smiles_tokenize('C1=CC=CC=C1')), True)
+    assert len(result['atoms']) == 6
+    assert len(result['bonds']) == 6
+    
+    result = parser(list(smiles_tokenize('C(=O)O')), True)
+    assert len(result['atoms']) == 3
+    assert len(result['bonds']) == 2
+
+
+def test_daylight_smiles_charged():
+    # Test charged species
+    result = parser(list(smiles_tokenize('[NH4+]')), True)
+    assert len(result['atoms']) == 1
+    
+    result = parser(list(smiles_tokenize('[OH-]')), True)
+    assert len(result['atoms']) == 1
+
+
+def test_daylight_smiles_aromatic():
+    # Test aromatic SMILES
+    result = parser(list(smiles_tokenize('c1ccccc1')), True)
+    assert len(result['atoms']) == 6
+    assert len(result['bonds']) == 6
+    
+    result = parser(list(smiles_tokenize('n1cccc1')), True)
+    assert len(result['atoms']) == 5
+    assert len(result['bonds']) == 5
+
+
+def test_daylight_smiles_isotopes():
+    # Test isotope labels
+    result = parser(list(smiles_tokenize('[2H]O')), True)
+    assert len(result['atoms']) == 2
+    assert result['atoms'][0]['isotope'] == 2
+    
+    result = parser(list(smiles_tokenize('[13C]')), True)
+    assert len(result['atoms']) == 1
+    assert result['atoms'][0]['isotope'] == 13
+
+
+def test_daylight_smiles_stereo():
+    # Test stereochemistry
+    result = parser(list(smiles_tokenize('C/C=C/C')), True)
+    assert result['stereo_bonds']
+    
+    result = parser(list(smiles_tokenize('C/C=C\\C')), True)
+    assert result['stereo_bonds'] 

chython/files/daylight/test/test_parser.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@gmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+import pytest
+from chython.exceptions import IncorrectSmiles, IncorrectSmarts
+from chython.files.daylight.parser import parser
+from chython.files.daylight.tokenize import smiles_tokenize, smarts_tokenize
+from chython.files.daylight.smarts import smarts
+
+
+def test_parser_basic():
+    # Test basic parsing
+    result = parser(list(smiles_tokenize('CC')), True)
+    assert len(result['atoms']) == 2
+    assert len(result['bonds']) == 1
+    
+    result = parser(list(smiles_tokenize('O')), True)
+    assert len(result['atoms']) == 1
+    assert not result['bonds']
+
+
+def test_parser_cycles():
+    # Test cycle notation
+    result = parser(list(smiles_tokenize('C1CCC1')), True)
+    assert len(result['atoms']) == 4
+    assert len(result['bonds']) == 4
+    
+    # Test multiple cycles
+    result = parser(list(smiles_tokenize('C1CC2CCC12')), True)
+    assert len(result['atoms']) == 6
+    assert len(result['bonds']) == 7
+
+
+def test_parser_branches():
+    # Test branched structures
+    result = parser(list(smiles_tokenize('CC(C)C')), True)
+    assert len(result['atoms']) == 4
+    assert len(result['bonds']) == 3
+    
+    # Test nested branches
+    result = parser(list(smiles_tokenize('CC(C(C)C)C')), True)
+    assert len(result['atoms']) == 6
+    assert len(result['bonds']) == 5
+
+
+def test_parser_errors():
+    # Test invalid structures
+    with pytest.raises(IncorrectSmiles):
+        parser(list(smiles_tokenize('C1CC')), True)  # unclosed cycle
+    
+    with pytest.raises(IncorrectSmiles):
+        parser(list(smiles_tokenize('C((C)')), True)  # unmatched parentheses
+    
+    with pytest.raises(IncorrectSmiles):
+        parser(list(smiles_tokenize('C1CC2')), True)  # unclosed cycles
+
+
+def test_parser_stereo():
+    # Test stereo bonds
+    result = parser(list(smiles_tokenize('C/C=C/C')), True)
+    assert result['stereo_bonds']
+    
+    result = parser(list(smiles_tokenize('C/C=C\\C')), True)
+    assert result['stereo_bonds']
+
+
+def test_parser_aromatic():
+    # Test aromatic structures
+    result = parser(list(smiles_tokenize('c1ccccc1')), True)
+    assert len(result['atoms']) == 6
+    assert len(result['bonds']) == 6
+    
+    result = parser(list(smiles_tokenize('n1ccccc1')), True)
+    assert len(result['atoms']) == 6
+    assert len(result['bonds']) == 6
+
+
+def test_parser_smarts():
+    # Test SMARTS parsing with supported primitives
+    result = parser(list(smarts_tokenize('[D2]')), False)
+    assert len(result['atoms']) == 1
+    
+    result = parser(list(smarts_tokenize('[h1]')), False)
+    assert len(result['atoms']) == 1
+    
+    result = parser(list(smarts_tokenize('[!R]')), False)
+    assert len(result['atoms']) == 1
+    
+    result = parser(list(smarts_tokenize('[r5]')), False)
+    assert len(result['atoms']) == 1
+
+
+def test_parser_smarts_errors():
+    # Test invalid SMARTS
+    with pytest.raises(IncorrectSmiles):
+        parser(list(smarts_tokenize('[')), False)  # unclosed bracket
+    
+    with pytest.raises(IncorrectSmiles):
+        parser(list(smarts_tokenize('[C')), False)  # unclosed bracket
+    
+    with pytest.raises(IncorrectSmiles):
+        parser(list(smarts_tokenize('C1C')), False)  # unclosed ring 

chython/files/daylight/test/test_tokenize.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+#
+#  Copyright 2025 Ramil Nugmanov <nougmanoff@protonmail.com>
+#  Copyright 2025 Tagir Akhmetshin <tagirshin@gmail.com>
+#  This file is part of chython.
+#
+#  chython is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+from chython.files.daylight.tokenize import smiles_tokenize, smarts_tokenize
+from chython.containers import QueryBond
+from chython.exceptions import IncorrectSmiles
+from pytest import raises
+
+
+def test_smiles_tokenize():
+    assert smiles_tokenize('C') == [(0, {'element': 'C'})]
+    assert smiles_tokenize('CC') == [(0, {'element': 'C'}), (0, {'element': 'C'})]
+    assert smiles_tokenize('C=O') == [(0, {'element': 'C'}), (1, 2), (0, {'element': 'O'})]
+    assert smiles_tokenize('C(O)N') == [(0, {'element': 'C'}), (2, None), (0, {'element': 'O'}),
+                                        (3, None), (0, {'element': 'N'})]
+    assert smiles_tokenize('C2CC2') == [(0, {'element': 'C'}), (6, 2), (0, {'element': 'C'}),
+                                        (0, {'element': 'C'}), (6, 2)]
+
+
+def test_smiles_tokenize_atom():
+    assert smiles_tokenize('[NH4+]') == [(0, {'element': 'N', 'isotope': None, 'parsed_mapping': None, 'charge': 1,
+                                              'implicit_hydrogens': 4, 'stereo': None})]
+    assert smiles_tokenize('[14N]') == [(0, {'element': 'N', 'isotope': 14, 'parsed_mapping': None, 'charge': 0,
+                                              'implicit_hydrogens': 0, 'stereo': None})]
+    assert smiles_tokenize('[N@H]') == [(0, {'element': 'N', 'isotope': None, 'parsed_mapping': None, 'charge': 0,
+                                             'implicit_hydrogens': 1, 'stereo': True})]
+    assert smiles_tokenize('[N@@H--]') == [(0, {'element': 'N', 'isotope': None, 'parsed_mapping': None, 'charge': -2,
+                                                'implicit_hydrogens': 1, 'stereo': False})]
+    assert smiles_tokenize('[N@+3]') == [(0, {'element': 'N', 'isotope': None, 'parsed_mapping': None, 'charge': 3,
+                                              'implicit_hydrogens': 0, 'stereo': True})]
+    assert smiles_tokenize('[CH2:2]') == [(0, {'element': 'C', 'isotope': None, 'parsed_mapping': 2, 'charge': 0,
+                                               'implicit_hydrogens': 2, 'stereo': None})]
+    with raises(IncorrectSmiles):
+        smiles_tokenize('[@N]')
+
+
+def test_smarts_tokenize_atom():
+    # Test basic SMARTS tokenization
+    assert smarts_tokenize('[C]') == [(0, {'element': 'C'})]
+    assert smarts_tokenize('[C,N]') == [(0, {'element': ['C', 'N']})]
+    assert smarts_tokenize('[C+]') == [(0, {'charge': 1, 'element': 'C'})]
+    assert smarts_tokenize('[#1]') == [(0, {'element': 1})]
+    assert smarts_tokenize('[C;h1;@]') == [(0, {'element': 'C', 'implicit_hydrogens': [1], 'stereo': True})]
+    assert smarts_tokenize('[O;z1,z2;x1]') == [(0, {'element': 'O', 'heteroatoms': [1], 'hybridization': [1, 2]})]
+    assert smarts_tokenize('[Se;a;D1,D2;r4,r7:3]') == [(0, {'parsed_mapping': 3, 'element': 'Se', 'hybridization': 4, 'neighbors': [1, 2], 'ring_sizes': [4, 7]})]
+    assert smarts_tokenize('[Cl;M]') == [(0, {'element': 'Cl', 'masked': True})]
+    assert smarts_tokenize('[A:1]') == [(0, {'parsed_mapping': 1, 'element': 'A'})]
+    assert smarts_tokenize('[M]') == [(0, {'element': 'M'})]
+
+
+def test_smarts_tokenize_bonds():
+    assert smarts_tokenize('[C][C]') == [(0, {'element': 'C'}), (0, {'element': 'C'})]
+    assert smarts_tokenize('[C]-[C]') == [(0, {'element': 'C'}), (1, 1), (0, {'element': 'C'})]
+    assert smarts_tokenize('[C]~[C]') == [(0, {'element': 'C'}), (1, 8), (0, {'element': 'C'})]
+    assert smarts_tokenize('[C]!:[C]') == [(0, {'element': 'C'}), (10, [1, 2, 3]), (0, {'element': 'C'})]
+    assert smarts_tokenize('[C]-,=[C]') == [(0, {'element': 'C'}), (10, [1, 2]), (0, {'element': 'C'})]
+    assert smarts_tokenize('[C]-;@[C]') == [(0, {'element': 'C'}), (12, QueryBond(1, True)), (0, {'element': 'C'})]
+    assert smarts_tokenize('[C]!-;!@[C]') == [(0, {'element': 'C'}), (12, QueryBond((2, 3, 4), False)),
+                                              (0, {'element': 'C'})]
+    assert smarts_tokenize('[C]-,=;!@[C]') == [(0, {'element': 'C'}), (12, QueryBond((1, 2), False)),
+                                               (0, {'element': 'C'})]