for candidate in Path(__file__).resolve().parents:

if (candidate / 'pyproject.toml').is_file():

return candidate

"""Rebuild a molecule carrying its constitution and nothing else -- no stereo, no coordinates.

m = MoleculeContainer()

with m.edit():

fresh = {}

for a in src.atoms():

fresh[a.n] = m.add_atom(a.element, isotope=a.isotope or 0, charge=a.charge,

radical=a.is_radical, implicit_h=a.implicit_h)

for b in src.bonds():

m.add_bond(fresh[b.n], fresh[b.m], b.order)

# `ignore_stereo=True` because this gate is about the core finding its own units in a

# constitution: reading the file's wedges would hand it the answer. Read off the reader here,

# and `mol.meta` holds the same dict -- copied out because the fixture outlives the reader.

from chython.formats import SDFRead

out = {}

with SDFRead(str(SDF), ignore_stereo=True) as f:

for mol in f:

out[f.meta['STRUCTURE_ID']] = (_constitution(mol), dict(f.meta))

assert len(out) == 300, f'expected 300 records, read {len(out)}'

"""Another encoding of `m`: the same constitution built in a shuffled atom order.

perm = list(m.atom_numbers)

rng.shuffle(perm)

out = MoleculeContainer()

with out.edit():

fresh = {sid: out.add_atom(m.element_of(sid),

isotope=0 if drop == 'isotope' else m.isotope_of(sid),

charge=0 if drop == 'charge' else m.charge_of(sid),

radical=False if drop == 'radical' else m.radical_of(sid),

implicit_h=0 if drop == 'implicit_h' else m.implicit_h_of(sid))

for sid in perm}

for a, b, order in _edges(m):

out.add_bond(fresh[a], fresh[b], order)

"""`m`'s constitution written out in `canonical_order()` positions.

pos = m.canonical_order()

atoms = [None] * len(pos)

for sid, p in pos.items():

atoms[p] = (m.element_of(sid), m.isotope_of(sid), m.charge_of(sid),

m.radical_of(sid), m.implicit_h_of(sid))

edges = sorted((min(pos[a], pos[b]), max(pos[a], pos[b]), order)

for a, b, order in _edges(m))

"""The distinct canonical forms of `m` over `count` relabelings AND the original.

"""The annotated unit codes. STEREOGENIC_UNITS holds 'TH', 'CT,TH', 'TH5,CT' and so on;

"""The gate's own preconditions, measured rather than assumed.

assert len(records) == 300

assert all(sid.startswith('VS') for sid in records), 'STRUCTURE_ID is the VS-numbered oracle key'

sizes = {sid: m.atom_count for sid, (m, _) in records.items()}

assert max(sizes.values()) == MAX_ATOMS, 'the size bound the truncation assertions rest on'

multi = {sid for sid, (m, _) in records.items() if m.connected_components_count > 1}

assert multi == {'VS031', 'VS054', 'VS068', 'VS095', 'VS165', 'VS186'}, \

'six multi-component records; five carry a one-atom counter-ion and only VS186 has units ' \

'in two components, which is why ruling F103 needs a record this corpus does not contain'

assert not [sid for sid, (m, _) in records.items()

if any(m.radical_of(a) for a in m.atom_numbers)], \

'no radical anywhere: the radical axis is uncovered by this corpus, and said so'

assert len([sid for sid, (m, _) in records.items()

if any(m.isotope_of(a) for a in m.atom_numbers)]) == 16

assert len([sid for sid, (m, _) in records.items()

"""Ruling F100's exclusion, as a measured precondition instead of a bare `except`.

contested = {}

for sid, (m, _) in records.items():

counts = Counter(u['anchor'] for u in m.stereo_units())

if any(v > 1 for v in counts.values()):

contested[sid] = [a for a, v in counts.items() if v > 1]

"""`stereo_truncated is False` -- asserted WITH the size bound that makes it true.

assert max(m.atom_count for m, _ in records.values()) == MAX_ATOMS

truncated = [sid for sid, (m, _) in records.items() if m.stereo_truncated]

"""The bridge's central claim, asserted positively rather than inferred from a clean validator.

for sid, (m, _) in records.items():

assert all(m.parity_of(a) == 0 for a in m.atom_numbers), sid

assert all(m.stereo_of(a) is False for a in m.atom_numbers), sid

assert m.canonical_stereo_groups() == {}, sid

"""60 relabelings of each record, plus the original, must give exactly one canonical form."""

rng = Random(20260901)

broken = {}

for sid, (m, _) in records.items():

forms = _forms(m, rng)

if len(forms) != 1:

broken[sid] = len(forms)

"""The one property `_relabel(drop=prop)` omits, read back off the core."""

if prop == 'isotope':

return m.isotope_of(sid)

elif prop == 'charge':

return m.charge_of(sid)

elif prop == 'radical':

return m.radical_of(sid)

named):

"""RULING F102: gate 1's zero above is evidence only from an instrument that can report dirt.

carrying = {sid for sid, (m, _) in records.items()

if any(_read(m, prop, a) for a in m.atom_numbers)}

assert len(carrying) == carriers, f'{prop} is carried by {len(carrying)} records, not {carriers}'

rng = Random(4242)

dirty = {sid for sid, (m, _) in records.items() if len(_forms(m, rng, 4, drop=prop)) != 1}

assert dirty == carrying, \

f'dropping {prop} was reported on {len(dirty)} records but is carried by {len(carrying)}'

"""The obligatory criterion: spiro and ring-double-bond handling is the one behaviour that must not

m, meta = records[structure_id]

kinds = {u['kind'] for u in m.stereo_units()}

want = {CODE_KIND[c] for c in _codes(meta) if c in CODE_KIND}

assert want, f'{structure_id} carries no code this gate knows: {_codes(meta)}'

"""Each axial, even-cumulene and atropisomer annotation must yield the right kind.

want = CODE_KIND[code]

carrying = [sid for sid, (_, meta) in records.items() if code in _codes(meta)]

assert len(carrying) == CODE_COUNT[code] > 0, \

f'{code} is carried by {len(carrying)} records; the assertion below would be vacuous at 0'

missing = [sid for sid in carrying

if not any(u['kind'] == want for u in records[sid][0].stereo_units())]

('VS071', 15, 'phosphine oxide'),

('VS147', 16, 'sulfoxide'),

('VS180', 6, 'isotopic methane'),

('VS183', 16, 'isotopic sulfone'),

('VS186', 16, 'sulfonimidoyl'),

('VS045', 7, 'N-oxide'),

('VS031', 7, 'ammonium'),

('VS054', 15, 'phosphonium'),

('VS104', 14, 'silicon'),

('VS130', 16, 'thio-sulfonyl'),

element, label):

"""`stereo_units()` and not `stereogenic_units()`: gate 4 asks about CANDIDATES.

m = records[structure_id][0]

anchors = [u['anchor'] for u in m.stereo_units() if u['kind'] == SU_TETRA]

assert any(m.element_of(a) == element for a in anchors), \

element):

"""The three records where the ISOTOPE is the only thing that makes the centre real.

m = records[structure_id][0]

units = [u for u in m.stereogenic_units()

if u['kind'] == SU_TETRA and m.element_of(u['anchor']) == element]

assert len(units) == 1, f'{structure_id}: one stereogenic centre on element {element}'

refs = [r for r in units[0]['refs'] if r is not None]

by_element = Counter(m.element_of(r) for r in refs)

twins = [e for e, c in by_element.items() if c > 1]

assert twins, 'the centre has two like directions, or the isotope decides nothing'

assert any(len({m.isotope_of(r) for r in refs if m.element_of(r) == e}) > 1 for e in twins), \

"""VS138 is a phosphine, and its phosphorus is the tetrahedral unit the oracle annotates `TH`.

m = records['VS138'][0]

phosphorus = [a for a in m.atom_numbers if m.element_of(a) == 15]

assert len(phosphorus) == 1, 'one phosphorus, which is the subject of the assertion below'

p = phosphorus[0]

assert (m.charge_of(p), m.degree_of(p), m.total_h_of(p)) == (0, 3, 0), \

'neutral, three-coordinate, no hydrogen: a P(III) lone-pair centre and not a phosphonium'

assert 'TH' in _codes(records['VS138'][1]), 'the oracle annotates it'

units = [u for u in m.stereo_units() if u['anchor'] == p]

assert [(u['kind'], u['stereogenic']) for u in units] == [(0, True)], \

"""VS010 and VS011 are [6]helicene of opposite helicity: one stereogenic SU_HELICAL unit each,

for sid in ('VS010', 'VS011'):

m, meta = records[sid]

assert _codes(meta) == {'HE'}, f'{sid} is the helicity annotation'

assert (m.atom_count, m.bond_count, m.rings_count) == (26, 31, 6)

assert {m.element_of(a) for a in m.atom_numbers} == {6}

(unit,) = m.stereo_units()

assert unit['kind'] == SU_HELICAL and unit['stereogenic'], sid

assert unit['owners'][1] not in m.neighbors_of(unit['owners'][0]), 'the fjord atoms are not bonded'

assert sorted(sid for sid, (m, _) in records.items()

"""The drawings' wedges: VS010 is P (parity 2), VS011 is M (parity 1)."""

from chython.formats import SDFRead

with SDFRead(str(SDF)) as f:

read = {f.meta['STRUCTURE_ID']: mol for mol in f}

for sid, parity in (('VS010', 2), ('VS011', 1)):

m = read[sid]

(unit,) = [u for u in m.stereo_units() if u['kind'] == SU_HELICAL]

assert m.parity_of(unit['anchor']) == parity, sid

"""VS002 and VS004 carry no STEREOGENIC_UNITS field, and here that means "no unit exists".

for sid, atoms, bonds, rings, doubles in (('VS002', 7, 7, 1, 3), ('VS004', 10, 11, 2, 4)):

m, meta = records[sid]

assert 'STEREOGENIC_UNITS' not in meta, f'{sid} is one of the two unannotated records'

assert (m.atom_count, m.bond_count, m.rings_count) == (atoms, bonds, rings), sid

assert {m.element_of(a) for a in m.atom_numbers} == {6}, f'{sid} is a hydrocarbon'

assert sum(1 for _, _, o in _edges(m) if o == 2) == doubles, sid

units = m.stereo_units()

assert units, f'{sid} does produce candidates, so the emptiness below is a verdict'

for u in units:

assert u['kind'] == SU_TETRA

assert m.total_h_of(u['anchor']) == 2, 'a ring CH2: two indistinguishable hydrogens'

assert bin(u['unnamed_mask']).count('1') == 2, 'two unnamed directions in one list'

"""VS186, the only Blue Book record whose units live in two components -- certified by name.

m, _ = records['VS186']

labels = m.component_labels()

assert m.connected_components_count == 2

assert sorted(Counter(labels.values()).values()) == [11, 17]

per_component = Counter(labels[u['anchor']] for u in m.stereo_units())

assert sorted(per_component.values()) == [1, 17], 'units on both sides of the salt'

chiral = m.chiral_atoms()

assert len(chiral) == 1 and m.chiral_bonds() == {}

centre = next(iter(chiral))

assert m.element_of(centre) == 16, 'the sulfonate sulfur, and nothing in the ammonium'

assert per_component[labels[centre]] == 1, \

'the marked component holds one unit; the seventeen next door are all refused'

for u in m.stereo_units():

"""RULING F103: the acceptance gate's counterpart to Task 6b's mechanism fixture.

m, blocks = _disjoint(*names)

where = {sid: (b, i) for b, sids in enumerate(blocks) for i, sid in enumerate(sids)}

assert m.connected_components_count == 2, 'two components, not one fused record'

assert m.atom_count == 15, 'far below the node budget, so the flag below is decided, not a guess'

assert m.stereo_truncated is False, 'these marks are proven, not taken conservatively'

# BY IDENTITY, and anchor-free per ruling F101: which end of a unit is keyed in SEG_PARITY is a

# slot-order artifact, so nothing here keys on an anchor or reaches a unit through `unit_of`.

assert {where[sid] for sid in m.chiral_atoms()} == {(marked_block, 1), (marked_block, 4)}, \

'both centres on the dimethyl ring, and none on the ring next door'

assert m.chiral_bonds() == {}, 'neither fragment carries a bond-kind unit'

other = 1 - marked_block

assert any(b == other for b, _ in where.values()), 'the refused component is really in there'

assert not [sid for sid, key in where.items() if key[0] == other and m.is_chiral(sid)], \

"""Every reader runs on all 300 records, and validation is clean by construction: no parity

for sid, (m, _) in records.items():

assert m.stereo_units() is not None

assert len(m.canonical_order()) == len(m.atom_numbers)