File: test_reader.py

package info (click to toggle)
python-ihm 2.7-1
links: PTS, VCS
area: main
in suites: forky, sid
size: 3,368 kB
sloc: python: 30,422; ansic: 5,990; sh: 24; makefile: 20
file content (5568 lines) | stat: -rw-r--r-- 209,401 bytes
import utils
import datetime
import os
import unittest
import gzip
import operator
import warnings
from io import StringIO, BytesIO

TOPDIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
utils.set_search_paths(TOPDIR)
import ihm.reader

try:
    from ihm import _format
except ImportError:
    _format = None


def cif_file_handles(cif):
    """Yield both in-memory and real-file handles for the given mmCIF text.
       This allows us to test both the pure Python reader and the C-accelerated
       version with the same input file."""
    yield StringIO(cif)
    with utils.temporary_directory() as tmpdir:
        fname = os.path.join(tmpdir, 'test')
        with open(fname, 'w') as fh:
            fh.write(cif)
        with open(fname) as fh:
            yield fh


ASYM_ENTITY = """
loop_
_entity_poly_seq.entity_id
_entity_poly_seq.num
_entity_poly_seq.mon_id
_entity_poly_seq.hetero
1 1 MET .
1 2 CYS .
1 3 MET .
1 4 SER .
#
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 1 foo
"""

CENTERS_TRANSFORMS = """
loop_
_ihm_geometric_object_center.id
_ihm_geometric_object_center.xcoord
_ihm_geometric_object_center.ycoord
_ihm_geometric_object_center.zcoord
1 1.000 2.000 3.000
#
#
loop_
_ihm_geometric_object_transformation.id
_ihm_geometric_object_transformation.rot_matrix[1][1]
_ihm_geometric_object_transformation.rot_matrix[2][1]
_ihm_geometric_object_transformation.rot_matrix[3][1]
_ihm_geometric_object_transformation.rot_matrix[1][2]
_ihm_geometric_object_transformation.rot_matrix[2][2]
_ihm_geometric_object_transformation.rot_matrix[3][2]
_ihm_geometric_object_transformation.rot_matrix[1][3]
_ihm_geometric_object_transformation.rot_matrix[2][3]
_ihm_geometric_object_transformation.rot_matrix[3][3]
_ihm_geometric_object_transformation.tr_vector[1]
_ihm_geometric_object_transformation.tr_vector[2]
_ihm_geometric_object_transformation.tr_vector[3]
1 1.000000 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000
1.000000 1.000 2.000 3.000
#
"""


class Tests(unittest.TestCase):
    def test_read(self):
        """Test read() function"""
        cif = "data_model\n_struct.entry_id testid\n"
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            self.assertEqual(s.id, 'testid')
        # Make sure we can read the file in binary mode too
        s, = ihm.reader.read(BytesIO(cif.encode('latin-1')))
        self.assertEqual(s.id, 'testid')

    def test_read_unicode(self):
        """Test that Unicode characters are handled sensibly"""
        # mmCIF files should technically be ASCII, but try not to fall over
        # if we're fed a Unicode file
        cif = "data_model\n_struct.entry_id test\u00dc\U0001f600\n"
        s, = ihm.reader.read(StringIO(cif))
        self.assertEqual(s.id, 'test\u00dc\U0001f600')
        s, = ihm.reader.read(BytesIO(cif.encode('utf-8')))
        # Reading in binary mode should give us the raw text (latin-1)
        self.assertEqual(s.id, 'test\xc3\x9c\xf0\x9f\x98\x80')
        with utils.temporary_directory() as tmpdir:
            fname = os.path.join(tmpdir, 'test')
            with open(fname, 'w', encoding='utf-8') as fh:
                fh.write(cif)
            # Should get the input back if we use the right UTF-8 encoding
            with open(fname, encoding='utf-8') as fh:
                s, = ihm.reader.read(fh)
                self.assertEqual(s.id, 'test\u00dc\U0001f600')
            # Should get a decode error if we treat it as ASCII:
            with open(fname, encoding='ascii') as fh:
                self.assertRaises(UnicodeDecodeError, ihm.reader.read, fh)
            # A permissive 8-bit encoding should work but give us garbage
            with open(fname, encoding='latin-1') as fh:
                s, = ihm.reader.read(fh)
                self.assertEqual(s.id, 'test\xc3\x9c\xf0\x9f\x98\x80')

    def test_read_custom_handler(self):
        """Test read() function with custom Handler"""
        class MyHandler(ihm.reader.Handler):
            category = "_custom_category"

            def __call__(self, field1, myfield):
                self.system.custom_data = (field1, myfield)

        cif = "data_model\n_struct.entry_id testid\n" \
              "_custom_category.field1 foo\n_custom_category.myfield bar\n"
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh, handlers=[MyHandler])
            self.assertEqual(s.id, 'testid')
            self.assertEqual(s.custom_data, ('foo', 'bar'))

    def test_system_reader(self):
        """Test SystemReader class"""
        _ = ihm.reader.SystemReader(ihm.model.Model,
                                    ihm.startmodel.StartingModel)

    def test_id_mapper(self):
        """Test IDMapper class"""
        class MockObject:
            def __init__(self, x, y):
                self.x, self.y = x, y

        testlist = []
        im = ihm.reader.IDMapper(testlist, MockObject, '1', y='2')
        a = im.get_by_id('ID1')
        b = im.get_by_id('ID1')
        self.assertEqual(id(a), id(b))
        self.assertEqual(a.x, '1')
        self.assertEqual(a.y, '2')
        self.assertEqual(testlist, [a])

    def test_handler(self):
        """Test Handler base class"""
        class MockObject:
            pass
        o = MockObject()
        o.system = 'foo'
        h = ihm.reader.Handler(o)
        self.assertEqual(h.system, 'foo')

    def test_handler_copy_if_present(self):
        """Test copy_if_present method"""
        class MockObject:
            pass
        # Keys = namedtuple('Keys', 'foo bar t test x')
        o = MockObject()
        h = ihm.reader.Handler(None)
        h.copy_if_present(o, {'foo': 'bar', 'bar': 'baz', 't': 'u'},
                          keys=['test', 'foo'],
                          mapkeys={'bar': 'baro', 'x': 'y'})
        self.assertEqual(o.foo, 'bar')
        self.assertEqual(o.baro, 'baz')
        self.assertFalse(hasattr(o, 't'))
        self.assertFalse(hasattr(o, 'x'))
        self.assertFalse(hasattr(o, 'bar'))

    def test_struct_handler(self):
        """Test StructHandler"""
        cif = """
_struct.entry_id eid
_struct.title 'Test title'
_struct.pdbx_model_details 'Test details'
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            self.assertEqual(s.id, 'eid')
            self.assertEqual(s.title, 'Test title')
            self.assertEqual(s.model_details, 'Test details')

    def test_multiple_systems(self):
        """Test multiple systems from data blocks"""
        cif = """
data_id1
_struct.entry_id id1
data_id2
_struct.entry_id id2
data_id3
_struct.entry_id id3
data_long-entry$#<>
_struct.entry_id id4
"""
        for fh in cif_file_handles(cif):
            s1, s2, s3, s4 = ihm.reader.read(fh)
            self.assertEqual(s1.id, 'id1')
            self.assertEqual(s2.id, 'id2')
            self.assertEqual(s3.id, 'id3')
            # Should not be tripped up by odd characters in data_ block,
            # and the system ID should match entry_id
            self.assertEqual(s4.id, 'id4')

    def test_collection_handler(self):
        """Test CollectionHandler"""
        cif = """
loop_
_ihm_entry_collection.id
_ihm_entry_collection.name
_ihm_entry_collection.details
foo bar 'more text'
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            c, = s.collections
            self.assertEqual(c.id, 'foo')
            self.assertEqual(c.name, 'bar')
            self.assertEqual(c.details, 'more text')

    def test_software_handler(self):
        """Test SoftwareHandler"""
        cif = """
loop_
_citation.id
_citation.journal_abbrev
_citation.journal_volume
_citation.page_first
_citation.page_last
_citation.year
_citation.pdbx_database_id_PubMed
_citation.pdbx_database_id_DOI
1 'Mol Cell Proteomics' 9 2943 . 2014 1234 .
#
loop_
_software.pdbx_ordinal
_software.name
_software.classification
_software.description
_software.version
_software.type
_software.location
_software.citation_id
1 'test software' 'test class' 'test desc' program 1.0.1 https://example.org .
2 'other software' 'oth class' 'test desc' program 1.0.1 https://example.org 1
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            software, s2 = s.software
            self.assertEqual(software._id, '1')
            self.assertEqual(software.name, 'test software')
            self.assertEqual(software.classification, 'test class')
            self.assertIsNone(software.citation)
            self.assertEqual(s2._id, '2')
            self.assertEqual(s2.name, 'other software')
            self.assertEqual(s2.classification, 'oth class')
            self.assertEqual(s2.citation.pmid, '1234')

    def test_audit_author_handler(self):
        """Test AuditAuthorHandler"""
        cif = """
loop_
_audit_author.name
_audit_author.pdbx_ordinal
auth1 1
auth2 2
auth3 3
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            self.assertEqual(s.authors, ['auth1', 'auth2', 'auth3'])

    def test_audit_revision_handler(self):
        """Test AuditRevisionHistoryHandler and related handlers"""
        cif = """
loop_
_pdbx_audit_revision_history.ordinal
_pdbx_audit_revision_history.data_content_type
_pdbx_audit_revision_history.major_revision
_pdbx_audit_revision_history.minor_revision
_pdbx_audit_revision_history.revision_date
40 'Structure model' 1 0 ?
41 'Structure model' 1 0 .
42 'Structure model' 2 0 1979-05-03
#
#
loop_
_pdbx_audit_revision_details.ordinal
_pdbx_audit_revision_details.revision_ordinal
_pdbx_audit_revision_details.data_content_type
_pdbx_audit_revision_details.provider
_pdbx_audit_revision_details.type
_pdbx_audit_revision_details.description
1 42 'Structure model' repository 'Initial release' 'Test desc'
#
#
loop_
_pdbx_audit_revision_group.ordinal
_pdbx_audit_revision_group.revision_ordinal
_pdbx_audit_revision_group.data_content_type
_pdbx_audit_revision_group.group
1 42 'Structure model' group1
2 42 'Structure model' group2
#
#
loop_
_pdbx_audit_revision_category.ordinal
_pdbx_audit_revision_category.revision_ordinal
_pdbx_audit_revision_category.data_content_type
_pdbx_audit_revision_category.category
1 42 'Structure model' cat1
2 42 'Structure model' cat2
#
#
loop_
_pdbx_audit_revision_item.ordinal
_pdbx_audit_revision_item.revision_ordinal
_pdbx_audit_revision_item.data_content_type
_pdbx_audit_revision_item.item
1 42 'Structure model' item1
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            r1, r2, r = s.revisions
            self.assertIs(r1.date, ihm.unknown)
            self.assertEqual(len(r1.details), 0)
            self.assertEqual(len(r1.groups), 0)
            self.assertEqual(len(r1.categories), 0)
            self.assertEqual(len(r1.items), 0)
            self.assertIsNone(r2.date)
            self.assertIsInstance(r, ihm.Revision)
            self.assertEqual(r.data_content_type, "Structure model")
            self.assertEqual(r.major, 2)
            self.assertEqual(r.minor, 0)
            self.assertEqual(r.date, datetime.date(1979, 5, 3))
            self.assertEqual(len(r.details), 1)
            self.assertEqual(r.details[0].provider, 'repository')
            self.assertEqual(r.details[0].type, 'Initial release')
            self.assertEqual(r.details[0].description, 'Test desc')
            self.assertEqual(r.groups, ['group1', 'group2'])
            self.assertEqual(r.categories, ['cat1', 'cat2'])
            self.assertEqual(r.items, ['item1'])

    def test_data_usage_handler(self):
        """Test DataUsageHandler"""
        cif = """
loop_
_pdbx_data_usage.id
_pdbx_data_usage.type
_pdbx_data_usage.details
_pdbx_data_usage.url
_pdbx_data_usage.name
1 license 'some license' someurl somename
2 disclaimer 'some disclaimer' . .
3 "some other type" 'misc usage' . ."""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            d1, d2, d3 = s.data_usage
            self.assertIsInstance(d1, ihm.License)
            self.assertEqual(d1.details, "some license")
            self.assertEqual(d1.name, "somename")
            self.assertEqual(d1.url, "someurl")

            self.assertIsInstance(d2, ihm.Disclaimer)
            self.assertEqual(d2.details, "some disclaimer")
            self.assertIsNone(d2.name)
            self.assertIsNone(d2.url)

            self.assertEqual(d3.type, "other")
            self.assertEqual(d3.details, "misc usage")

    def test_grant_handler(self):
        """Test GrantHandler"""
        cif = """
loop_
_pdbx_audit_support.funding_organization
_pdbx_audit_support.country
_pdbx_audit_support.grant_number
_pdbx_audit_support.ordinal
NIH 'United States' foo 1
NSF 'United States' bar 2
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            g1, g2 = s.grants
            self.assertEqual(g1.funding_organization, "NIH")
            self.assertEqual(g1.country, "United States")
            self.assertEqual(g1.grant_number, "foo")
            self.assertEqual(g2.funding_organization, "NSF")
            self.assertEqual(g2.country, "United States")
            self.assertEqual(g2.grant_number, "bar")

    def test_citation_handler(self):
        """Test CitationHandler and CitationAuthorHandler"""
        cif = """
loop_
_citation.id
_citation.journal_abbrev
_citation.journal_volume
_citation.page_first
_citation.page_last
_citation.year
_citation.pdbx_database_id_PubMed
_citation.pdbx_database_id_DOI
primary 'Mol Cell Proteomics' 9 2943 . 2014 1234 .
3 'Mol Cell Proteomics' 9 2943 2946 2014 1234 1.2.3.4
4 'Mol Cell Proteomics' 9 . . 2014 1234 1.2.3.4
#
#
loop_
_citation_author.citation_id
_citation_author.name
_citation_author.ordinal
3 'Foo A' 1
3 'Bar C' 2
3 . 3
5 'Baz X' 4
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            citation1, citation2, citation3, citation4 = s.citations
            self.assertEqual(citation1._id, 'primary')
            self.assertTrue(citation1.is_primary)
            self.assertEqual(citation1.page_range, '2943')
            self.assertEqual(citation1.authors, [])
            self.assertEqual(citation1.pmid, '1234')
            self.assertIsNone(citation1.doi)

            self.assertEqual(citation2._id, '3')
            self.assertFalse(citation2.is_primary)
            self.assertEqual(citation2.page_range, ('2943', '2946'))
            self.assertEqual(citation2.authors, ['Foo A', 'Bar C'])
            self.assertEqual(citation2.doi, '1.2.3.4')

            self.assertEqual(citation3._id, '4')
            self.assertFalse(citation3.is_primary)
            self.assertEqual(citation3.authors, [])
            self.assertIsNone(citation3.page_range)

            # todo: should probably be an error, no _citation.id == 4
            self.assertEqual(citation4._id, '5')
            self.assertEqual(citation4.authors, ['Baz X'])

    def test_chem_comp_handler(self):
        """Test ChemCompHandler and EntityPolySeqHandler"""
        chem_comp_cat = """
loop_
_chem_comp.id
_chem_comp.type
_chem_comp.name
_chem_comp.formula
MET 'L-peptide linking' . .
CYS 'D-peptide linking' CYSTEINE .
MYTYPE 'D-PEPTIDE LINKING' 'MY CUSTOM COMPONENT' 'C6 H12'
"""
        entity_poly_cat = """
loop_
_entity_poly_seq.entity_id
_entity_poly_seq.num
_entity_poly_seq.mon_id
_entity_poly_seq.hetero
1 1 MET .
1 4 MYTYPE .
1 5 CYS .
1 2 MET .
"""
        cif1 = chem_comp_cat + entity_poly_cat
        cif2 = entity_poly_cat + chem_comp_cat
        # Order of the two categories shouldn't matter
        for cif in cif1, cif2:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                e1, = s.entities
                s = e1.sequence
                self.assertEqual(len(s), 5)
                lpeptide = ihm.LPeptideAlphabet()
                self.assertEqual(id(s[0]), id(lpeptide['M']))
                self.assertEqual(id(s[1]), id(lpeptide['M']))
                self.assertEqual(id(s[4]), id(lpeptide['C']))
                self.assertEqual(s[0].name, 'METHIONINE')
                self.assertIsNone(s[2])
                self.assertEqual(s[3].id, 'MYTYPE')
                self.assertEqual(s[3].type, 'D-peptide linking')
                self.assertEqual(s[3].name, 'MY CUSTOM COMPONENT')
                self.assertAlmostEqual(s[3].formula_weight, 84.162, delta=0.1)
                self.assertEqual(s[3].__class__, ihm.DPeptideChemComp)
                # Class of standard type shouldn't be changed
                self.assertEqual(s[4].type, 'L-peptide linking')
                self.assertEqual(s[4].__class__, ihm.LPeptideChemComp)

    def test_entity_poly_handler(self):
        """Test EntityPolyHandler"""
        fh = StringIO("""
loop_
_entity_poly_seq.entity_id
_entity_poly_seq.num
_entity_poly_seq.mon_id
_entity_poly_seq.hetero
1 1 OCS .
1 2 MET .
1 3 ACE .
2 1 MET .
3 1 MET .
#
loop_
_entity_poly.entity_id
_entity_poly.type
_entity_poly.pdbx_seq_one_letter_code
_entity_poly.pdbx_seq_one_letter_code_can
1 'polypeptide(L)'
;(OCS)
M
;
SM
3 other . .
""")
        s, = ihm.reader.read(fh)
        e1, e2, e3 = s.entities
        c1, c2, c3 = e1.sequence
        self.assertEqual(c1.id, 'OCS')
        # Missing information should be filled in from entity_poly
        self.assertEqual(c1.code, 'OCS')
        self.assertEqual(c1.code_canonical, 'S')
        # No info in entity_poly for this component
        self.assertEqual(c3.id, 'ACE')
        self.assertIsNone(c3.code)
        self.assertIsNone(c3.code_canonical)

    def test_chem_comp_nonpoly_handler(self):
        """Test ChemCompHandler and EntityNonPolyHandler"""
        chem_comp_cat = """
loop_
_chem_comp.id
_chem_comp.type
HEM non-polymer
HOH non-polymer
"""
        entity_nonpoly_cat = """
loop_
_pdbx_entity_nonpoly.entity_id
_pdbx_entity_nonpoly.name
_pdbx_entity_nonpoly.comp_id
1 Heme HEM
2 Water HOH
"""
        cif1 = chem_comp_cat + entity_nonpoly_cat
        cif2 = entity_nonpoly_cat + chem_comp_cat
        # Order of the two categories shouldn't matter
        for cif in cif1, cif2:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                e1, e2 = s.entities
                s = e1.sequence
                self.assertEqual(len(s), 1)
                self.assertEqual(s[0].id, 'HEM')
                self.assertEqual(s[0].type, 'non-polymer')
                self.assertEqual(s[0].__class__, ihm.NonPolymerChemComp)
                s = e2.sequence
                self.assertEqual(len(s), 1)
                self.assertEqual(s[0].id, 'HOH')
                self.assertEqual(s[0].type, 'non-polymer')
                self.assertEqual(s[0].__class__, ihm.WaterChemComp)

    def test_chem_descriptor_handler(self):
        """Test ChemDescriptorHandler"""
        for cat in ("ihm_chemical_component_descriptor",
                    "flr_chemical_descriptor"):
            cif = """
loop_
_%(cat)s.id
_%(cat)s.auth_name
_%(cat)s.chemical_name
_%(cat)s.common_name
_%(cat)s.smiles
_%(cat)s.smiles_canonical
_%(cat)s.inchi
_%(cat)s.inchi_key
1 EDC "test-chem-EDC" . "CCN=C=NCCCN(C)C" . test-inchi test-inchi-key
""" % {'cat': cat}
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                d1, = s.orphan_chem_descriptors
                self.assertEqual(d1.auth_name, 'EDC')
                self.assertIsNone(d1.chem_comp_id)
                self.assertEqual(d1.chemical_name, 'test-chem-EDC')
                self.assertEqual(d1.smiles, 'CCN=C=NCCCN(C)C')
                self.assertIsNone(d1.smiles_canonical)
                self.assertEqual(d1.inchi, 'test-inchi')
                self.assertEqual(d1.inchi_key, 'test-inchi-key')

    def test_entity_handler(self):
        """Test EntityHandler"""
        cif = """
loop_
_entity.id
_entity.type
_entity.src_method
_entity.pdbx_description
_entity.pdbx_number_of_molecules
_entity.formula_weight
_entity.details
1 polymer nat Nup84 2 100.0 .
2 polymer syn Nup85 3 200.0 .
3 polymer . Nup86 3 300.0 .
4 polymer unknown Nup87 3 300.0 .
5 branched unknown Nup88 3 300.0 .
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            e1, e2, e3, e4, e5 = s.entities
            self.assertEqual(e1.description, 'Nup84')
            self.assertTrue(e1._force_polymer)
            self.assertEqual(
                e1.number_of_molecules, '2')  # todo: coerce to int
            self.assertEqual(e1.source.src_method, 'nat')
            self.assertEqual(e2.source.src_method, 'syn')
            self.assertIsNone(e3.source)
            self.assertIsNone(e4.source)
            self.assertFalse(e5._force_polymer)
            self.assertTrue(e5._hint_branched)

    def test_entity_handler_minimal(self):
        """Test EntityHandler with minimal entity category"""
        cif = """
loop_
_entity.id
1
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            e1, = s.entities
            self.assertIsNone(e1.description)

    def test_entity_src_gen_handler(self):
        """Test EntitySrcGenHandler"""
        entity = """
loop_
_entity.id
_entity.type
_entity.src_method
_entity.pdbx_description
_entity.pdbx_number_of_molecules
_entity.formula_weight
_entity.details
1 polymer man Nup84 2 100.0 .
"""
        src_gen = """
_entity_src_gen.entity_id 1
_entity_src_gen.pdbx_src_id 42
_entity_src_gen.pdbx_gene_src_scientific_name 'test latin name'
_entity_src_gen.pdbx_gene_src_ncbi_taxonomy_id 1234
_entity_src_gen.gene_src_common_name 'test common name'
_entity_src_gen.gene_src_strain 'test strain'
_entity_src_gen.pdbx_host_org_scientific_name 'host latin name'
_entity_src_gen.pdbx_host_org_ncbi_taxonomy_id 5678
_entity_src_gen.host_org_common_name 'other common name'
_entity_src_gen.pdbx_host_org_strain 'other strain'
"""
        # Order of the categories shouldn't matter
        cif1 = entity + src_gen
        cif2 = src_gen + entity
        for cif in cif1, cif2:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                e, = s.entities
                self.assertEqual(e.source.src_method, 'man')
                self.assertEqual(e.source._id, '42')
                self.assertEqual(e.source.host.ncbi_taxonomy_id, '5678')
                self.assertEqual(e.source.host.scientific_name,
                                 'host latin name')
                self.assertEqual(e.source.host.common_name,
                                 'other common name')
                self.assertEqual(e.source.host.strain, 'other strain')
                self.assertEqual(e.source.gene.ncbi_taxonomy_id, '1234')
                self.assertEqual(e.source.gene.scientific_name,
                                 'test latin name')
                self.assertEqual(e.source.gene.common_name, 'test common name')
                self.assertEqual(e.source.gene.strain, 'test strain')

    def test_entity_src_nat_handler(self):
        """Test EntitySrcNatHandler"""
        entity = """
loop_
_entity.id
_entity.type
_entity.src_method
_entity.pdbx_description
_entity.pdbx_number_of_molecules
_entity.formula_weight
_entity.details
1 polymer man Nup84 2 100.0 .
"""
        src_nat = """
_entity_src_nat.entity_id 1
_entity_src_nat.pdbx_src_id 42
_entity_src_nat.pdbx_organism_scientific 'test latin name'
_entity_src_nat.pdbx_ncbi_taxonomy_id 5678
_entity_src_nat.common_name 'test common name'
_entity_src_nat.strain 'test strain'
"""
        # Order of the categories shouldn't matter
        cif1 = entity + src_nat
        cif2 = src_nat + entity
        for cif in cif1, cif2:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                e, = s.entities
                self.assertEqual(e.source.src_method, 'nat')
                self.assertEqual(e.source._id, '42')
                self.assertEqual(e.source.ncbi_taxonomy_id, '5678')
                self.assertEqual(e.source.scientific_name, 'test latin name')
                self.assertEqual(e.source.common_name, 'test common name')
                self.assertEqual(e.source.strain, 'test strain')

    def test_entity_src_syn_handler(self):
        """Test EntitySrcSynHandler"""
        entity = """
loop_
_entity.id
_entity.type
_entity.src_method
_entity.pdbx_description
_entity.pdbx_number_of_molecules
_entity.formula_weight
_entity.details
1 polymer man Nup84 2 100.0 .
"""
        src_syn = """
_pdbx_entity_src_syn.entity_id 1
_pdbx_entity_src_syn.pdbx_src_id 42
_pdbx_entity_src_syn.organism_scientific 'test latin name'
_pdbx_entity_src_syn.organism_common_name 'test common name'
_pdbx_entity_src_syn.ncbi_taxonomy_id 5678
_pdbx_entity_src_syn.strain 'test strain'
"""
        # Order of the categories shouldn't matter
        cif1 = entity + src_syn
        cif2 = src_syn + entity
        for cif in cif1, cif2:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                e, = s.entities
                self.assertEqual(e.source.src_method, 'syn')
                self.assertEqual(e.source._id, '42')
                self.assertEqual(e.source.ncbi_taxonomy_id, '5678')
                self.assertEqual(e.source.scientific_name, 'test latin name')
                self.assertEqual(e.source.common_name, 'test common name')
                # _pdbx_entity_src_syn.strain is not used in current PDB
                self.assertIsNone(e.source.strain)

    def test_struct_ref_handler(self):
        """Test StructRefHandler"""
        entity = """
loop_
_entity.id
_entity.type
_entity.src_method
_entity.pdbx_description
_entity.pdbx_number_of_molecules
_entity.formula_weight
_entity.details
1 polymer man test 1 100.0 .
"""
        struct_ref = """
loop_
_struct_ref.id
_struct_ref.entity_id
_struct_ref.db_name
_struct_ref.db_code
_struct_ref.pdbx_db_accession
_struct_ref.pdbx_align_begin
_struct_ref.pdbx_seq_one_letter_code
_struct_ref.details
1 1 UNP NUP84_YEAST P52891 3
;LSP
TYQT
;
'test sequence'
2 1 MyDatabase testcode testacc 1 MEL 'other sequence'
3 1 MyDatabase testcode2 testacc2 1 . 'other sequence'
4 1 MyDatabase testcode3 testacc3 1 ? 'other sequence'
#
#
loop_
_struct_ref_seq.align_id
_struct_ref_seq.ref_id
_struct_ref_seq.seq_align_beg
_struct_ref_seq.seq_align_end
_struct_ref_seq.db_align_beg
_struct_ref_seq.db_align_end
1 1 1 4 3 6
2 1 5 5 8 8
#
#
loop_
_struct_ref_seq_dif.pdbx_ordinal
_struct_ref_seq_dif.align_id
_struct_ref_seq_dif.seq_num
_struct_ref_seq_dif.db_mon_id
_struct_ref_seq_dif.mon_id
_struct_ref_seq_dif.details
1 1 2 TRP SER 'Test mutation'
2 1 2 . . 'Test mutation'
#
"""
        # Order of the categories shouldn't matter
        cif1 = entity + struct_ref
        cif2 = struct_ref + entity
        for cif in cif1, cif2:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                e, = s.entities
                r1, r2, r3, r4 = e.references
                self.assertIsInstance(r1, ihm.reference.UniProtSequence)
                self.assertEqual(r1.db_name, 'UNP')
                self.assertEqual(r1.db_code, 'NUP84_YEAST')
                self.assertEqual(r1.accession, 'P52891')
                self.assertEqual(r1.sequence, '--LSPTYQT')
                self.assertEqual(r1.details, 'test sequence')
                self.assertIsNone(r3.sequence)
                self.assertEqual(r4.sequence, ihm.unknown)
                a1, a2 = r1.alignments
                self.assertEqual(a1.db_begin, 3)
                self.assertEqual(a1.db_end, 6)
                self.assertEqual(a1.entity_begin, 1)
                self.assertEqual(a1.entity_end, 4)
                sd, sd2 = a1.seq_dif
                self.assertEqual(sd.seq_id, 2)
                self.assertIsInstance(sd.db_monomer, ihm.ChemComp)
                self.assertIsInstance(sd.monomer, ihm.ChemComp)
                self.assertEqual(sd.db_monomer.id, 'TRP')
                self.assertEqual(sd.monomer.id, 'SER')
                self.assertEqual(sd.details, 'Test mutation')
                # Both mon_id and db_mon_id are optional, so could be empty
                self.assertIsNone(sd2.db_monomer)
                self.assertIsNone(sd2.monomer)

                self.assertEqual(a2.db_begin, 8)
                self.assertEqual(a2.db_end, 8)
                self.assertEqual(a2.entity_begin, 5)
                self.assertEqual(a2.entity_end, 5)
                self.assertEqual(len(a2.seq_dif), 0)
                self.assertIsInstance(r2, ihm.reference.Sequence)
                self.assertEqual(r2.db_name, 'MyDatabase')
                self.assertEqual(r2.db_code, 'testcode')
                self.assertEqual(r2.accession, 'testacc')
                self.assertEqual(r2.sequence, 'MEL')
                self.assertEqual(r2.details, 'other sequence')
                self.assertEqual(len(r2.alignments), 0)

    def test_asym_unit_handler(self):
        """Test AsymUnitHandler"""
        cif = """
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 1 Nup84
B 1 Nup85
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            a1, a2 = s.asym_units
            self.assertEqual(a1._id, 'A')
            self.assertEqual(a1.id, 'A')
            self.assertEqual(a1.entity._id, '1')

            self.assertEqual(a1.details, 'Nup84')
            self.assertEqual(a2.entity._id, '1')
            self.assertEqual(a2._id, 'B')
            self.assertEqual(a2.id, 'B')
            self.assertEqual(a2.details, 'Nup85')
            self.assertEqual(id(a1.entity), id(a2.entity))

    def test_assembly_handler(self):
        """Test AssemblyHandler"""
        cif = """
loop_
_ihm_struct_assembly.id
_ihm_struct_assembly.name
_ihm_struct_assembly.description
1 'Complete assembly' 'All known components'
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            a1, = s.orphan_assemblies
            self.assertEqual(a1._id, '1')
            self.assertEqual(a1.name, 'Complete assembly')
            self.assertEqual(a1.description, 'All known components')

    def test_assembly_details_handler(self):
        """Test AssemblyDetailsHandler"""
        entity_cif = """
loop_
_entity_poly_seq.entity_id
_entity_poly_seq.num
_entity_poly_seq.mon_id
1 1 ALA
1 2 ALA
2 1 ALA
2 2 ALA
#
loop_
_ihm_entity_poly_segment.id
_ihm_entity_poly_segment.entity_id
_ihm_entity_poly_segment.seq_id_begin
_ihm_entity_poly_segment.seq_id_end
1 1 1 726
2 2 1 744
3 1 1 2
4 2 1 50
5 2 1 2
"""
        assembly_cif = """
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 1 Nup84
B 2 Nup85
#
loop_
_ihm_struct_assembly.id
_ihm_struct_assembly.name
_ihm_struct_assembly.description
1 . .
2 . .
3 . .
4 'user-provided name' 'user-provided desc'
#
loop_
_ihm_struct_assembly_details.id
_ihm_struct_assembly_details.assembly_id
_ihm_struct_assembly_details.parent_assembly_id
_ihm_struct_assembly_details.entity_description
_ihm_struct_assembly_details.entity_id
_ihm_struct_assembly_details.asym_id
_ihm_struct_assembly_details.entity_poly_segment_id
1 1 1 Nup84 1 A 1
2 1 1 Nup85 2 B 2
3 1 1 Nup84 1 A 3
4 2 1 Nup86 2 . 4
5 2 1 Nup85 2 . 5
6 3 1 Nup84 1 A .
7 3 1 Nup85 2 . .
7 4 1 Nup84 1 A .
8 4 1 Nup85 2 B .
"""
        # Order of categories should not matter
        for cif in (entity_cif + assembly_cif, assembly_cif + entity_cif):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                a1, a2, a3, a4 = s.orphan_assemblies
                self.assertEqual(a1._id, '1')
                self.assertIsNone(a1.parent)
                self.assertEqual(len(a1), 3)
                # AsymUnitRange
                self.assertIsInstance(a1[0], ihm.AsymUnitRange)
                self.assertEqual(a1[0]._id, 'A')
                self.assertEqual(a1[0].seq_id_range, (1, 726))
                self.assertEqual(a1[1]._id, 'B')
                self.assertEqual(a1[1].seq_id_range, (1, 744))

                self.assertEqual(a2._id, '2')
                self.assertEqual(a2.parent, a1)
                # AsymUnit
                self.assertIsInstance(a1[2], ihm.AsymUnit)
                # EntityRange
                self.assertEqual(len(a2), 2)
                self.assertIsInstance(a2[0], ihm.EntityRange)
                self.assertEqual(a2[0]._id, '2')
                self.assertEqual(a2[0].seq_id_range, (1, 50))
                # Entity
                self.assertIsInstance(a2[1], ihm.Entity)

                # Assembly with no ranges given
                self.assertEqual(len(a3), 2)
                self.assertIsInstance(a3[0], ihm.AsymUnit)
                self.assertIsInstance(a3[1], ihm.Entity)

                # "Complete" assembly that covers all AsymUnits
                self.assertEqual(len(a4), 2)
                self.assertIsInstance(a4[0], ihm.AsymUnit)
                self.assertIsInstance(a4[1], ihm.AsymUnit)
                self.assertEqual(a4.name, 'user-provided name')
                self.assertEqual(a4.description, 'user-provided desc')
                # Should set name, description of system.complete_assembly
                self.assertEqual(s.complete_assembly.name, a4.name)
                self.assertEqual(s.complete_assembly.description,
                                 a4.description)

    def test_external_file_handler(self):
        """Test ExtRef and ExtFileHandler"""
        ext_ref_cat = """
loop_
_ihm_external_reference_info.reference_id
_ihm_external_reference_info.reference_provider
_ihm_external_reference_info.reference_type
_ihm_external_reference_info.reference
_ihm_external_reference_info.refers_to
_ihm_external_reference_info.associated_url
_ihm_external_reference_info.details
1 Zenodo DOI 10.5281/zenodo.1218053 Archive https://example.com/foo.zip
'test repo'
2 . 'Supplementary Files' . Other . .
3 Zenodo DOI 10.5281/zenodo.1218058 File https://example.com/foo.dcd .
"""
        ext_file_cat = """
loop_
_ihm_external_files.id
_ihm_external_files.reference_id
_ihm_external_files.file_path
_ihm_external_files.content_type
_ihm_external_files.file_format
_ihm_external_files.file_size_bytes
_ihm_external_files.details
1 1 scripts/test.py 'Modeling workflow or script' TXT 180 'Test script'
2 2 foo/bar.txt 'Input data or restraints' TXT 42.0 'Test text'
3 3 . 'Modeling or post-processing output' . . 'Ensemble structures'
4 3 . . . . .
5 3 foo.txt Other . . 'Other file'
"""
        # Order of the categories shouldn't matter
        cif1 = ext_ref_cat + ext_file_cat
        cif2 = ext_file_cat + ext_ref_cat
        for cif in cif1, cif2:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                l1, l2, l3, l4, l5 = s.locations
                self.assertEqual(l1.path, 'scripts/test.py')
                self.assertEqual(l1.details, 'Test script')
                self.assertEqual(l1.repo.doi, '10.5281/zenodo.1218053')
                self.assertIsInstance(l1.file_size, int)
                self.assertEqual(l1.file_size, 180)
                self.assertEqual(l1.file_format, 'TXT')
                self.assertEqual(l1.repo.details, 'test repo')
                self.assertEqual(l1.__class__,
                                 ihm.location.WorkflowFileLocation)

                self.assertEqual(l2.path, 'foo/bar.txt')
                self.assertEqual(l2.details, 'Test text')
                self.assertIsNone(l2.repo)
                self.assertIsInstance(l2.file_size, float)
                self.assertAlmostEqual(l2.file_size, 42.0, delta=0.01)
                self.assertEqual(l2.file_format, 'TXT')
                self.assertEqual(l2.__class__, ihm.location.InputFileLocation)

                self.assertEqual(l3.path, '.')
                self.assertEqual(l3.details, 'Ensemble structures')
                self.assertIsNone(l3.file_size)
                self.assertIsNone(l3.file_format)
                self.assertEqual(l3.repo.doi, '10.5281/zenodo.1218058')
                self.assertEqual(l3.__class__, ihm.location.OutputFileLocation)

                self.assertEqual(l4.path, '.')
                self.assertIsNone(l4.file_size)
                self.assertIsNone(l4.file_format)
                self.assertIsNone(l4.details)
                self.assertEqual(l4.repo.doi, '10.5281/zenodo.1218058')
                # Type is unspecified
                self.assertEqual(l4.__class__, ihm.location.FileLocation)

                self.assertEqual(l5.content_type, 'Other')
                self.assertEqual(l5.__class__, ihm.location.FileLocation)

    def test_dataset_list_handler(self):
        """Test DatasetListHandler"""
        cif = """
loop_
_ihm_dataset_list.id
_ihm_dataset_list.data_type
_ihm_dataset_list.database_hosted
_ihm_dataset_list.details
1 'Experimental model' YES .
2 'COMPARATIVE MODEL' YES .
3 'EM raw micrographs' YES 'test details'
4 . YES .
5 'Crosslinking-MS data' YES .
6 'CX-MS data' YES .
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            d1, d2, d3, d4, d5, d6 = s.orphan_datasets
            self.assertEqual(d1.__class__, ihm.dataset.PDBDataset)
            self.assertEqual(d2.__class__, ihm.dataset.ComparativeModelDataset)
            self.assertEqual(d3.__class__, ihm.dataset.EMMicrographsDataset)
            self.assertTrue(d1._allow_duplicates)
            self.assertTrue(d2._allow_duplicates)
            self.assertTrue(d3._allow_duplicates)
            # No specified data type - use base class
            self.assertEqual(d4.__class__, ihm.dataset.Dataset)
            self.assertIsNone(d1.details)
            self.assertEqual(d3.details, 'test details')
            # Both new and old data_types should map to the same
            # crosslink class
            self.assertEqual(d5.__class__, ihm.dataset.CXMSDataset)
            self.assertEqual(d6.__class__, ihm.dataset.CXMSDataset)

    def test_dataset_group_handler(self):
        """Test DatasetGroupHandler"""
        cif = """
loop_
_ihm_dataset_group.id
_ihm_dataset_group.name
_ihm_dataset_group.application
_ihm_dataset_group.details
1 "foo" "foo app" "foo details"
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            g1, = s.orphan_dataset_groups
            self.assertEqual(len(g1), 0)  # no datasets read yet
            self.assertEqual(g1.name, 'foo')
            self.assertEqual(g1.application, 'foo app')
            self.assertEqual(g1.details, 'foo details')

    def test_dataset_group_link_handler(self):
        """Test DatasetGroupLinkHandler"""
        cif = """
loop_
_ihm_dataset_group_link.group_id
_ihm_dataset_group_link.dataset_list_id
1 1
1 2
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            d1, d2 = s.orphan_datasets
            g1, = s.orphan_dataset_groups
            self.assertEqual(len(g1), 2)
            self.assertEqual(g1[0], d1)
            self.assertEqual(g1[1], d2)
            # No type specified yet
            self.assertEqual(d1.__class__, ihm.dataset.Dataset)
            self.assertEqual(d2.__class__, ihm.dataset.Dataset)

    def test_dataset_multiple_locations(self):
        """Check handling of a dataset with multiple locations"""
        cif = """
loop_
_ihm_dataset_external_reference.id
_ihm_dataset_external_reference.dataset_list_id
_ihm_dataset_external_reference.file_id
1 1 11
2 1 12
#
loop_
_ihm_dataset_related_db_reference.id
_ihm_dataset_related_db_reference.dataset_list_id
_ihm_dataset_related_db_reference.db_name
_ihm_dataset_related_db_reference.accession_code
_ihm_dataset_related_db_reference.version
_ihm_dataset_related_db_reference.details
1 1 PDB 3JRO . .
2 1 PDB 1ABC . .
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            d, = s.orphan_datasets
            # "location" should match first _locations
            self.assertEqual(d.location._id, '11')
            loc1, loc2, loc3, loc4 = d._locations
            self.assertEqual(loc1._id, '11')
            self.assertEqual(loc2._id, '12')
            self.assertEqual(loc3._id, '1')
            self.assertEqual(loc4._id, '2')
            self.assertIsInstance(loc1, ihm.location.FileLocation)
            self.assertIsInstance(loc2, ihm.location.FileLocation)
            self.assertIsInstance(loc3, ihm.location.PDBLocation)
            self.assertIsInstance(loc4, ihm.location.PDBLocation)

    def test_dataset_extref_handler(self):
        """Test DatasetExtRefHandler"""
        cif = """
loop_
_ihm_dataset_external_reference.id
_ihm_dataset_external_reference.dataset_list_id
_ihm_dataset_external_reference.file_id
1 4 11
2 6 12
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            d1, d2 = s.orphan_datasets
            self.assertEqual(d1._id, '4')
            self.assertEqual(d1.location._id, '11')
            self.assertEqual(d2._id, '6')
            self.assertEqual(d2.location._id, '12')

    def test_dataset_dbref_handler(self):
        """Test DatasetDBRefHandler"""
        cif = """
loop_
_ihm_dataset_related_db_reference.id
_ihm_dataset_related_db_reference.dataset_list_id
_ihm_dataset_related_db_reference.db_name
_ihm_dataset_related_db_reference.accession_code
_ihm_dataset_related_db_reference.version
_ihm_dataset_related_db_reference.details
1 1 PDB 3JRO . .
2 3 PDB 3F3F 30-OCT-08 'CRYSTAL STRUCTURE'
3 5 emdb EMD-123 . .
4 6 . . . .
5 7 testDB testcode testver testdetails
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            d1, d2, d3, d4, d5 = s.orphan_datasets
            self.assertEqual(d1.location.db_name, 'PDB')
            self.assertEqual(d1.location.__class__, ihm.location.PDBLocation)
            self.assertEqual(d1.location.access_code, '3JRO')
            self.assertEqual(d2.location.db_name, 'PDB')
            self.assertEqual(d2.location.__class__, ihm.location.PDBLocation)
            self.assertEqual(d2.location.access_code, '3F3F')
            self.assertEqual(d2.location.version, '30-OCT-08')
            self.assertEqual(d2.location.details, 'CRYSTAL STRUCTURE')
            self.assertEqual(d3.location.db_name, 'EMDB')
            self.assertEqual(d3.location.__class__, ihm.location.EMDBLocation)
            self.assertEqual(d3.location.access_code, 'EMD-123')
            self.assertIsNone(d3.location.version)
            self.assertIsNone(d3.location.details)
            self.assertEqual(d4.location.db_name, 'Other')
            self.assertEqual(d4.location.__class__,
                             ihm.location.DatabaseLocation)
            self.assertIsNone(d4.location.access_code)
            self.assertEqual(d5.location.__class__,
                             ihm.location.DatabaseLocation)
            self.assertEqual(d5.location.db_name, "testDB")
            self.assertEqual(d5.location.access_code, "testcode")
            self.assertEqual(d5.location.version, "testver")
            self.assertEqual(d5.location.details, "testdetails")

    def test_related_datasets_handler(self):
        """Test RelatedDatasetsHandler"""
        cif = """
loop_
_ihm_data_transformation.id
_ihm_data_transformation.rot_matrix[1][1]
_ihm_data_transformation.rot_matrix[2][1]
_ihm_data_transformation.rot_matrix[3][1]
_ihm_data_transformation.rot_matrix[1][2]
_ihm_data_transformation.rot_matrix[2][2]
_ihm_data_transformation.rot_matrix[3][2]
_ihm_data_transformation.rot_matrix[1][3]
_ihm_data_transformation.rot_matrix[2][3]
_ihm_data_transformation.rot_matrix[3][3]
_ihm_data_transformation.tr_vector[1]
_ihm_data_transformation.tr_vector[2]
_ihm_data_transformation.tr_vector[3]
42 -0.637588 0.089507 0.765160 0.755616 -0.120841 0.643771 0.150085
0.988628 0.009414 327.161 83.209 -227.800
#
loop_
_ihm_related_datasets.dataset_list_id_derived
_ihm_related_datasets.dataset_list_id_primary
_ihm_related_datasets.transformation_id
4 1 .
7 1 42
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            d1, d2, d3 = s.orphan_datasets
            self.assertEqual(d1._id, '4')
            self.assertEqual(d2._id, '1')
            self.assertEqual(d3._id, '7')
            self.assertEqual(d1.parents, [d2])
            self.assertEqual(d2.parents, [])
            self.assertEqual(len(d3.parents), 1)
            self.assertIsInstance(d3.parents[0],
                                  ihm.dataset.TransformedDataset)
            self.assertEqual(d3.parents[0].dataset._id, '1')
            t = d3.parents[0].transform
            self.assertEqual(t._id, '42')
            self.assertAlmostEqual(t.tr_vector[0], 327.161, delta=0.01)
            self.assertAlmostEqual(t.rot_matrix[1][2], 0.988628, delta=0.01)

    def test_model_representation_handler(self):
        """Test ModelRepresentationHandler"""
        cif = """
loop_
_ihm_model_representation.id
_ihm_model_representation.name
_ihm_model_representation.details
1 "rep A" "rep A details"
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            r1, = s.orphan_representations
            self.assertEqual(len(r1), 0)  # no segments read yet
            self.assertEqual(r1.name, 'rep A')
            self.assertEqual(r1.details, 'rep A details')

    def test_model_representation_details_handler(self):
        """Test ModelRepresentationDetailsHandler"""
        range_cif = """
loop_
_ihm_entity_poly_segment.id
_ihm_entity_poly_segment.entity_id
_ihm_entity_poly_segment.seq_id_begin
_ihm_entity_poly_segment.seq_id_end
1 1 1 6
2 1 7 20
"""
        repr_cif = """
loop_
_ihm_model_representation_details.id
_ihm_model_representation_details.representation_id
_ihm_model_representation_details.entity_id
_ihm_model_representation_details.entity_description
_ihm_model_representation_details.entity_asym_id
_ihm_model_representation_details.entity_poly_segment_id
_ihm_model_representation_details.model_object_primitive
_ihm_model_representation_details.starting_model_id
_ihm_model_representation_details.model_mode
_ihm_model_representation_details.model_granularity
_ihm_model_representation_details.model_object_count
_ihm_model_representation_details.description
1 1 1 Nup84 A 1 sphere . flexible by-feature 1 'test segment'
2 1 1 Nup84 A 2 sphere 1 rigid by-residue . .
3 2 1 Nup84 A . atomistic . flexible by-atom . .
4 3 2 Nup85 B . sphere . . multi-residue . .
"""
        # Order of categories should not matter
        for cif in (range_cif + repr_cif, repr_cif + range_cif):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                r1, r2, r3 = s.orphan_representations
                self.assertEqual(len(r1), 2)
                s1, s2 = r1
                self.assertEqual(s1.__class__,
                                 ihm.representation.FeatureSegment)
                self.assertEqual(s1.primitive, 'sphere')
                self.assertEqual(s1.count, 1)
                self.assertEqual(s1.rigid, False)
                self.assertIsNone(s1.starting_model)
                self.assertEqual(s1.asym_unit.seq_id_range, (1, 6))
                self.assertEqual(s1.description, 'test segment')

                self.assertEqual(s2.__class__,
                                 ihm.representation.ResidueSegment)
                self.assertEqual(s2.primitive, 'sphere')
                self.assertIsNone(s2.count)
                self.assertEqual(s2.rigid, True)
                self.assertEqual(s2.starting_model._id, '1')
                self.assertEqual(s2.asym_unit.seq_id_range, (7, 20))
                self.assertIsNone(s2.description)

                self.assertEqual(len(r2), 1)
                s1, = r2
                self.assertEqual(s1.__class__,
                                 ihm.representation.AtomicSegment)

                self.assertEqual(len(r3), 1)
                s1, = r3
                self.assertEqual(s1.__class__,
                                 ihm.representation.MultiResidueSegment)

    def test_starting_model_details_handler(self):
        """Test StartingModelDetailsHandler"""
        ps_cif = """
loop_
_ihm_entity_poly_segment.id
_ihm_entity_poly_segment.entity_id
_ihm_entity_poly_segment.seq_id_begin
_ihm_entity_poly_segment.seq_id_end
1 1 7 483
"""
        sm_cif = """
loop_
_ihm_starting_model_details.starting_model_id
_ihm_starting_model_details.entity_id
_ihm_starting_model_details.entity_description
_ihm_starting_model_details.asym_id
_ihm_starting_model_details.entity_poly_segment_id
_ihm_starting_model_details.starting_model_source
_ihm_starting_model_details.starting_model_auth_asym_id
_ihm_starting_model_details.starting_model_sequence_offset
_ihm_starting_model_details.dataset_list_id
_ihm_starting_model_details.description
1 1 Nup84 A 1 'comparative model' Q 8 4 .
2 1 Nup84 A . 'comparative model' X . 6 'test desc'
"""
        # Order of the two categories shouldn't matter
        for cif in ps_cif + sm_cif, sm_cif + ps_cif:
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                m1, m2 = s.orphan_starting_models
                self.assertEqual(m1.asym_unit._id, 'A')
                self.assertEqual(m1.asym_unit.seq_id_range, (7, 483))
                self.assertEqual(m1.asym_id, 'Q')
                self.assertEqual(m1.offset, 8)
                self.assertEqual(m1.dataset._id, '4')
                self.assertIsNone(m1.description)

                self.assertEqual(m2.asym_unit._id, 'A')
                self.assertEqual(m2.asym_id, 'X')
                self.assertEqual(m2.offset, 0)
                self.assertEqual(m2.dataset._id, '6')
                self.assertEqual(m2.description, 'test desc')

    def test_starting_computational_models_handler(self):
        """Test StartingComputationModelsHandler"""
        cif = """
loop_
_ihm_starting_computational_models.starting_model_id
_ihm_starting_computational_models.software_id
_ihm_starting_computational_models.script_file_id
1 99 8
2 . .
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            m1, m2 = s.orphan_starting_models
            self.assertEqual(m1.script_file._id, '8')
            self.assertEqual(m1.software._id, '99')
            self.assertIsNone(m2.script_file)
            self.assertIsNone(m2.software)

    def test_starting_comparative_models_handler(self):
        """Test StartingComparativeModelsHandler"""
        cif = """
loop_
_ihm_starting_comparative_models.id
_ihm_starting_comparative_models.starting_model_id
_ihm_starting_comparative_models.starting_model_auth_asym_id
_ihm_starting_comparative_models.starting_model_seq_id_begin
_ihm_starting_comparative_models.starting_model_seq_id_end
_ihm_starting_comparative_models.template_auth_asym_id
_ihm_starting_comparative_models.template_seq_id_begin
_ihm_starting_comparative_models.template_seq_id_end
_ihm_starting_comparative_models.template_sequence_identity
_ihm_starting_comparative_models.template_sequence_identity_denominator
_ihm_starting_comparative_models.template_dataset_list_id
_ihm_starting_comparative_models.alignment_file_id
1 1 A 7 436 C 9 438 90.000 1 3 2
2 1 A 33 424 C 33 424 100.000 1 1 .
3 1 A 33 424 C . ? 100.000 1 1 .
4 1 A . . C . . . . 1 .
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            m1, = s.orphan_starting_models
            t1, t2, t3, t4 = m1.templates
            self.assertEqual(t1.dataset._id, '3')
            self.assertEqual(t1.asym_id, 'C')
            self.assertEqual(t1.seq_id_range, (7, 436))
            self.assertEqual(t1.template_seq_id_range, (9, 438))
            self.assertAlmostEqual(t1.sequence_identity.value, 90.0,
                                   delta=0.1)
            self.assertEqual(t1.sequence_identity.denominator, 1)
            self.assertEqual(t1.alignment_file._id, '2')
            self.assertIsNone(t2.alignment_file)
            self.assertEqual(t3.template_seq_id_range, (None, ihm.unknown))
            self.assertEqual(t4.seq_id_range, (None, None))
            self.assertEqual(t4.template_seq_id_range, (None, None))

    def test_protocol_handler(self):
        """Test ProtocolHandler"""
        cif = """
loop_
_ihm_modeling_protocol.id
_ihm_modeling_protocol.protocol_name
_ihm_modeling_protocol.num_steps
_ihm_modeling_protocol.details
1 Prot1 5 'extra details'
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            p1, = s.orphan_protocols
            self.assertEqual(p1.name, "Prot1")
            self.assertEqual(p1.details, "extra details")
            # no step objects read yet, num_steps ignored
            self.assertEqual(len(p1.steps), 0)

    def test_protocol_details_handler(self):
        """Test ProtocolDetailsHandler"""
        cif = """
loop_
_ihm_modeling_protocol_details.id
_ihm_modeling_protocol_details.protocol_id
_ihm_modeling_protocol_details.step_id
_ihm_modeling_protocol_details.struct_assembly_id
_ihm_modeling_protocol_details.dataset_group_id
_ihm_modeling_protocol_details.struct_assembly_description
_ihm_modeling_protocol_details.step_name
_ihm_modeling_protocol_details.step_method
_ihm_modeling_protocol_details.num_models_begin
_ihm_modeling_protocol_details.num_models_end
_ihm_modeling_protocol_details.multi_scale_flag
_ihm_modeling_protocol_details.multi_state_flag
_ihm_modeling_protocol_details.ordered_flag
_ihm_modeling_protocol_details.ensemble_flag
_ihm_modeling_protocol_details.software_id
_ihm_modeling_protocol_details.script_file_id
_ihm_modeling_protocol_details.description
1 1 1 1 1 . Sampling 'Monte Carlo' 0 500 YES NO NO NO . . .
2 1 2 1 2 . Sampling 'Monte Carlo' 500 5000 YES . NO YES 401 501 'test step'
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            p1, = s.orphan_protocols
            self.assertEqual(len(p1.steps), 2)
            self.assertEqual(p1.steps[0]._id, '1')
            self.assertEqual(p1.steps[0].assembly._id, '1')
            self.assertEqual(p1.steps[0].dataset_group._id, '1')
            self.assertEqual(p1.steps[0].name, 'Sampling')
            self.assertEqual(p1.steps[0].method, 'Monte Carlo')
            self.assertEqual(p1.steps[0].num_models_begin, 0)
            self.assertEqual(p1.steps[0].num_models_end, 500)
            self.assertEqual(p1.steps[0].multi_scale, True)
            self.assertEqual(p1.steps[0].multi_state, False)
            self.assertEqual(p1.steps[0].ordered, False)
            self.assertEqual(p1.steps[0].ensemble, False)
            self.assertIsNone(p1.steps[0].software)
            self.assertIsNone(p1.steps[0].script_file)
            self.assertIsNone(p1.steps[0].description)
            self.assertEqual(p1.steps[1]._id, '2')
            self.assertEqual(p1.steps[1].multi_scale, True)
            self.assertIsNone(p1.steps[1].multi_state)
            self.assertEqual(p1.steps[1].ordered, False)
            self.assertEqual(p1.steps[1].ensemble, True)
            self.assertEqual(p1.steps[1].software._id, '401')
            self.assertEqual(p1.steps[1].script_file._id, '501')
            self.assertEqual(p1.steps[1].description, 'test step')

    def test_post_process_handler(self):
        """Test PostProcessHandler"""
        cif = """
loop_
_ihm_modeling_post_process.id
_ihm_modeling_post_process.protocol_id
_ihm_modeling_post_process.analysis_id
_ihm_modeling_post_process.step_id
_ihm_modeling_post_process.type
_ihm_modeling_post_process.feature
_ihm_modeling_post_process.num_models_begin
_ihm_modeling_post_process.num_models_end
_ihm_modeling_post_process.struct_assembly_id
_ihm_modeling_post_process.dataset_group_id
_ihm_modeling_post_process.software_id
_ihm_modeling_post_process.script_file_id
_ihm_modeling_post_process.details
1  1   1   1   'filter'  'energy/score'  15000   6520 . . 401 501 .
2  1   1   2   'cluster' 'invalid'       6520    6520 . . . . .
3  1   2   1   'filter'  'energy/score'  16000   7520 . . . . .
4  1   2   2   'filter'  'composition'   7520    5520 . . . . .
5  1   2   3   'cluster' 'dRMSD'         5520    6520 . . . . .
6  2   1   1   'filter'  'energy/score'  17000   6520 . . 401 501 .
7  3   1   1   'none' .         .    . . . . . 'empty step'
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            p1, p2, p3 = s.orphan_protocols
            self.assertEqual(len(p1.analyses), 2)
            self.assertEqual(len(p2.analyses), 1)
            self.assertEqual(len(p3.analyses), 1)
            # Analysis IDs should match analysis_id
            self.assertEqual([a._id for a in p1.analyses], ['1', '2'])
            self.assertEqual([a._id for a in p2.analyses], ['1'])
            self.assertEqual([a._id for a in p3.analyses], ['1'])
            a1, a2 = p1.analyses
            self.assertEqual(len(a1.steps), 2)
            self.assertEqual(a1.steps[0].__class__, ihm.analysis.FilterStep)
            self.assertEqual(a1.steps[0].feature, 'energy/score')
            self.assertEqual(a1.steps[0].num_models_begin, 15000)
            self.assertEqual(a1.steps[0].num_models_end, 6520)
            self.assertEqual(a1.steps[0].software._id, '401')
            self.assertEqual(a1.steps[0].script_file._id, '501')
            self.assertEqual(a1.steps[1].__class__, ihm.analysis.ClusterStep)
            # invalid feature should be mapped to default
            self.assertEqual(a1.steps[1].feature, 'other')
            self.assertEqual(a1.steps[1].num_models_begin, 6520)
            self.assertIsNone(a1.steps[1].software)
            self.assertIsNone(a1.steps[1].script_file)
            self.assertIsNone(a1.steps[1].details)
            self.assertEqual(len(a2.steps), 3)
            self.assertEqual([step.num_models_begin for step in a2.steps],
                             [16000, 7520, 5520])

            a1, = p2.analyses
            self.assertEqual(len(a1.steps), 1)
            self.assertEqual(a1.steps[0].__class__, ihm.analysis.FilterStep)
            self.assertEqual(a1.steps[0].feature, 'energy/score')
            self.assertEqual(a1.steps[0].num_models_begin, 17000)

            a1, = p3.analyses
            self.assertEqual(len(a1.steps), 1)
            self.assertEqual(a1.steps[0].__class__, ihm.analysis.EmptyStep)
            self.assertEqual(a1.steps[0].feature, 'none')
            self.assertIsNone(a1.steps[0].num_models_begin)
            self.assertIsNone(a1.steps[0].num_models_end)
            self.assertEqual(a1.steps[0].details, 'empty step')

    def test_model_list_handler(self):
        """Test ModelListHandler and ModelGroupHandler"""
        cif = """
loop_
_ihm_model_list.model_id
_ihm_model_list.model_name
_ihm_model_list.assembly_id
_ihm_model_list.protocol_id
_ihm_model_list.representation_id
1 'Best scoring model' 1 2 3
2 'Best scoring model' 1 1 1
#
loop_
_ihm_model_group.id
_ihm_model_group.name
_ihm_model_group.details
1 "Cluster 1" .
2 "Cluster 2" 'cluster 2 details'
#
loop_
_ihm_model_group_link.group_id
_ihm_model_group_link.model_id
1 1
2 2
loop_
_atom_site.group_PDB
_atom_site.id
_atom_site.type_symbol
_atom_site.label_atom_id
_atom_site.label_alt_id
_atom_site.label_comp_id
_atom_site.label_seq_id
_atom_site.label_asym_id
_atom_site.Cartn_x
_atom_site.Cartn_y
_atom_site.Cartn_z
_atom_site.occupancy
_atom_site.label_entity_id
_atom_site.auth_asym_id
_atom_site.B_iso_or_equiv
_atom_site.pdbx_PDB_model_num
_atom_site.ihm_model_id
ATOM 1 N N . MET 1 A 14.326 -2.326 8.122 1.000 1 A 0.000 42 42
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            sg, sg2 = s.state_groups
            # sg should contain all models in groups but not explicitly
            # put in a State
            state, = sg
            self.assertIsNone(state.name)  # auto-created state
            mg1, mg2 = state
            self.assertEqual(mg1.name, 'Cluster 1')
            self.assertEqual(mg1._id, '1')
            self.assertIsNone(mg1.details)
            m, = mg1
            self.assertEqual(m._id, '1')
            self.assertEqual(m.name, 'Best scoring model')
            self.assertEqual(m.assembly._id, '1')
            self.assertEqual(m.protocol._id, '2')
            self.assertEqual(m.representation._id, '3')
            self.assertEqual(mg2.name, 'Cluster 2')
            self.assertEqual(mg2.details, 'cluster 2 details')
            self.assertEqual(mg2._id, '2')
            m, = mg2
            self.assertEqual(m._id, '2')
            # sg2 should contain all models referenced by the file but not
            # put in groups (in this case, model ID 42 from atom_site)
            state, = sg2
            self.assertIsNone(state.name)  # auto-created state
            mg1, = state
            self.assertIsNone(mg1.name)  # auto-created group
            m, = mg1
            self.assertEqual(m._id, '42')

    def test_model_representative_handler(self):
        """Test ModelRepresentativeHandler"""
        cif = """
loop_
_ihm_model_representative.id
_ihm_model_representative.model_group_id
_ihm_model_representative.model_id
_ihm_model_representative.selection_criteria
1 42 5 medoid
2 42 8 'lowest energy'
3 99 3 'some unknown criterion'
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            state, = s.state_groups[0]
            mg1, mg2 = state
            self.assertEqual(mg1._id, '42')
            self.assertEqual(len(mg1.representatives), 2)
            self.assertEqual(mg1.representatives[0].model._id, '5')
            self.assertEqual(mg1.representatives[0].selection_criteria,
                             'medoid')
            self.assertEqual(mg1.representatives[1].model._id, '8')
            self.assertEqual(mg1.representatives[1].selection_criteria,
                             'lowest energy')
            self.assertEqual(mg2._id, '99')
            self.assertEqual(len(mg2.representatives), 1)
            self.assertEqual(mg2.representatives[0].model._id, '3')
            self.assertEqual(mg2.representatives[0].selection_criteria,
                             'other selction criteria')

    def test_multi_state_handler(self):
        """Test MultiStateHandler and MultiStateLinkHandler"""
        cif = """
loop_
_ihm_model_list.model_id
_ihm_model_list.model_name
_ihm_model_list.assembly_id
_ihm_model_list.protocol_id
_ihm_model_list.representation_id
1 'Best scoring model' 1 2 3
#
loop_
_ihm_model_group.id
_ihm_model_group.name
_ihm_model_group.details
1 "Cluster 1" .
#
loop_
_ihm_model_group_link.group_id
_ihm_model_group_link.model_id
1 1
#
loop_
_ihm_multi_state_modeling.state_id
_ihm_multi_state_modeling.state_group_id
_ihm_multi_state_modeling.population_fraction
_ihm_multi_state_modeling.state_type
_ihm_multi_state_modeling.state_name
_ihm_multi_state_modeling.experiment_type
_ihm_multi_state_modeling.details
1 1 0.4 'complex formation' 'unbound' 'Fraction of bulk'  'unbound molecule 1'
2 1 .  'complex formation' 'unbound' 'Fraction of bulk'  'unbound molecule 2'
3 1 .  'complex formation' 'bound' 'Fraction of bulk'
'bound molecules 1 and 2'
#
loop_
_ihm_multi_state_model_group_link.state_id
_ihm_multi_state_model_group_link.model_group_id
1 1
2 2
3 3
3 4
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            sg, = s.state_groups
            s1, s2, s3, = sg
            self.assertAlmostEqual(s1.population_fraction, 0.4, delta=0.1)
            self.assertEqual(s1.type, 'complex formation')
            self.assertEqual(s1.name, 'unbound')
            self.assertEqual(len(s1), 1)
            mg1, = s1
            self.assertEqual(mg1.name, 'Cluster 1')
            self.assertEqual(s1.experiment_type, 'Fraction of bulk')
            self.assertEqual(s1.details, 'unbound molecule 1')

            self.assertIsNone(s2.population_fraction)
            self.assertEqual(len(s2), 1)
            self.assertEqual(len(s3), 2)

    def test_not_modeled_residue_range_handler(self):
        """Test NotModeledResidueRangeHandler"""
        cif = """
loop_
_ihm_residues_not_modeled.id
_ihm_residues_not_modeled.model_id
_ihm_residues_not_modeled.entity_description
_ihm_residues_not_modeled.entity_id
_ihm_residues_not_modeled.asym_id
_ihm_residues_not_modeled.seq_id_begin
_ihm_residues_not_modeled.seq_id_end
_ihm_residues_not_modeled.comp_id_begin
_ihm_residues_not_modeled.comp_id_end
_ihm_residues_not_modeled.reason
1 1 Nup84 9 X 1 2 ALA CYS .
2 1 Nup84 9 X 3 4 GLY THR 'Highly variable models with poor precision'
3 1 Nup84 9 X 5 6 ALA CYS INVALID
#
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            m, = s.state_groups[0][0][0]
            rr1, rr2, rr3 = m.not_modeled_residue_ranges
            self.assertEqual(rr1.asym_unit._id, 'X')
            self.assertEqual(rr1.seq_id_begin, 1)
            self.assertEqual(rr1.seq_id_end, 2)
            self.assertIsNone(rr1.reason)
            self.assertEqual(rr2.asym_unit._id, 'X')
            self.assertEqual(rr2.seq_id_begin, 3)
            self.assertEqual(rr2.seq_id_end, 4)
            self.assertEqual(rr2.reason,
                             "Highly variable models with poor precision")
            self.assertEqual(rr3.reason, "Other")

    def test_ensemble_handler(self):
        """Test EnsembleHandler"""
        cif = """
loop_
_ihm_ensemble_info.ensemble_id
_ihm_ensemble_info.ensemble_name
_ihm_ensemble_info.post_process_id
_ihm_ensemble_info.model_group_id
_ihm_ensemble_info.ensemble_clustering_method
_ihm_ensemble_info.ensemble_clustering_feature
_ihm_ensemble_info.num_ensemble_models
_ihm_ensemble_info.num_ensemble_models_deposited
_ihm_ensemble_info.ensemble_precision_value
_ihm_ensemble_info.ensemble_file_id
_ihm_ensemble_info.details
_ihm_ensemble_info.model_group_superimposed_flag
_ihm_ensemble_info.sub_sample_flag
_ihm_ensemble_info.sub_sampling_type
1 'Cluster 1' 2 3 . dRMSD 1257 10 15.400 9 . . . .
2 'Cluster 2' 2 . . dRMSD 1257 10 15.400 9 'cluster details' NO YES independent
3 'Cluster 3' . . invalid_cluster invalid_feature 1 1 15.400 9 . YES . .
#
#
loop_
_ihm_ensemble_sub_sample.id
_ihm_ensemble_sub_sample.name
_ihm_ensemble_sub_sample.ensemble_id
_ihm_ensemble_sub_sample.num_models
_ihm_ensemble_sub_sample.num_models_deposited
_ihm_ensemble_sub_sample.model_group_id
_ihm_ensemble_sub_sample.file_id
1 ss1 2 5 0 . .
2 ss2 2 5 2 42 3
#
"""
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh)
            e, e2, e3 = s.ensembles
            self.assertEqual(e.model_group._id, '3')
            self.assertEqual(e.num_models, 1257)
            # model_group is empty
            self.assertEqual(e.num_models_deposited, 0)
            self.assertEqual(e.post_process._id, '2')
            self.assertIsNone(e.clustering_method)
            self.assertEqual(e.clustering_feature, 'dRMSD')
            self.assertEqual(e.name, 'Cluster 1')
            self.assertIsNone(e.details)
            self.assertAlmostEqual(e.precision, 15.4, delta=0.1)
            self.assertEqual(e.file._id, '9')
            self.assertIsNone(e.superimposed)
            self.assertIsNone(e2.model_group)
            self.assertEqual(e2.num_models_deposited, 10)
            self.assertEqual(e2.details, 'cluster details')
            s1, s2 = e2.subsamples
            self.assertEqual(s1.name, 'ss1')
            self.assertEqual(s1.num_models, 5)
            self.assertIsNone(s1.model_group)
            self.assertIsNone(s1.file)
            self.assertIsInstance(s1, ihm.model.IndependentSubsample)
            self.assertEqual(s2.name, 'ss2')
            self.assertEqual(s2.num_models, 5)
            self.assertEqual(s2.model_group._id, '42')
            self.assertEqual(s2.file._id, '3')
            self.assertIsInstance(s2, ihm.model.IndependentSubsample)
            self.assertFalse(e2.superimposed)
            # invalid cluster/feature should be mapped to default
            self.assertEqual(e3.clustering_method, 'Other')
            self.assertEqual(e3.clustering_feature, 'other')
            self.assertTrue(e3.superimposed)

    def test_density_handler(self):
        """Test DensityHandler"""
        segment_cif = """
loop_
_ihm_entity_poly_segment.id
_ihm_entity_poly_segment.entity_id
_ihm_entity_poly_segment.seq_id_begin
_ihm_entity_poly_segment.seq_id_end
1 1 1 726
"""
        density_cif = """
loop_
_ihm_localization_density_files.id
_ihm_localization_density_files.file_id
_ihm_localization_density_files.ensemble_id
_ihm_localization_density_files.entity_id
_ihm_localization_density_files.asym_id
_ihm_localization_density_files.entity_poly_segment_id
1 22 9 1 A 1
2 23 9 2 B .
"""
        # Order should not matter
        for cif in (segment_cif + density_cif, density_cif + segment_cif):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                e, = s.ensembles
                self.assertEqual(e._id, '9')
                d1, d2 = e.densities
                self.assertEqual(d1._id, '1')
                self.assertEqual(d1.file._id, '22')
                self.assertEqual(d1.asym_unit.__class__, ihm.AsymUnitRange)
                self.assertEqual(d1.asym_unit.seq_id_range, (1, 726))
                self.assertEqual(d2._id, '2')
                self.assertEqual(d2.asym_unit.__class__, ihm.AsymUnit)

    def test_em3d_restraint_handler(self):
        """Test EM3DRestraintHandler"""
        fh = StringIO("""
loop_
_ihm_3dem_restraint.id
_ihm_3dem_restraint.dataset_list_id
_ihm_3dem_restraint.fitting_method
_ihm_3dem_restraint.fitting_method_citation_id
_ihm_3dem_restraint.struct_assembly_id
_ihm_3dem_restraint.map_segment_flag
_ihm_3dem_restraint.number_of_gaussians
_ihm_3dem_restraint.model_id
_ihm_3dem_restraint.cross_correlation_coefficient
_ihm_3dem_restraint.details
1 26 'Gaussian mixture models' 9 2 YES 400 1 . details
2 26 'Gaussian mixture models' 9 2 YES 400 2 0.9 details
3 26 'Gaussian mixture models' 9 3 NO 400 1 0.8 'other assembly'
4 27 'Gaussian mixture models' 9 2 NO 400 1 0.8 'other dataset'
""")
        s, = ihm.reader.read(fh)
        r1, r2, r3 = s.restraints
        self.assertEqual(r1.dataset._id, '26')
        self.assertEqual(r1.fitting_method, 'Gaussian mixture models')
        self.assertEqual(r1.fitting_method_citation._id, '9')
        self.assertEqual(r1.assembly._id, '2')
        self.assertTrue(r1.segment)
        self.assertEqual(r1.number_of_gaussians, 400)
        self.assertEqual(r1.details, 'details')
        # Sort fits by model ID
        fits = sorted(r1.fits.items(), key=lambda x: x[0]._id)
        self.assertEqual(len(fits), 2)
        self.assertEqual(fits[0][0]._id, '1')
        self.assertIsNone(fits[0][1].cross_correlation_coefficient)
        self.assertEqual(fits[1][0]._id, '2')
        self.assertAlmostEqual(fits[1][1].cross_correlation_coefficient,
                               0.9, delta=0.1)
        # r2 acts on same dataset but a different assembly, so should be a
        # distinct restraint object
        self.assertEqual(r2.details, 'other assembly')
        self.assertFalse(r2.segment)
        # r3 acts on different dataset, so should be a distinct
        # restraint object
        self.assertEqual(r3.details, 'other dataset')

    def test_get_int(self):
        """Test _get_int method"""
        h = ihm.reader.Handler(None)
        self.assertEqual(h.get_int('45'), 45)
        self.assertIsNone(h.get_int(None))
        self.assertEqual(h.get_int(ihm.unknown), ihm.unknown)
        self.assertRaises(ValueError, h.get_int, ".")
        self.assertRaises(ValueError, h.get_int, "?")

    def test_get_int_or_string(self):
        """Test _get_int_or_string method"""
        h = ihm.reader.Handler(None)
        self.assertEqual(h.get_int_or_string('45A'), '45A')
        self.assertEqual(h.get_int_or_string('45'), 45)
        self.assertIsNone(h.get_int_or_string(None))
        self.assertEqual(h.get_int_or_string(ihm.unknown), ihm.unknown)
        self.assertEqual(h.get_int_or_string('.'), '.')
        self.assertEqual(h.get_int_or_string('?'), '?')
        self.assertEqual(h.get_int_or_string(45), 45)

    def test_get_float(self):
        """Test _get_float method"""
        h = ihm.reader.Handler(None)
        self.assertAlmostEqual(h.get_float('45.3'), 45.3, delta=0.1)
        self.assertIsNone(h.get_float(None))
        self.assertEqual(h.get_float(ihm.unknown), ihm.unknown)
        self.assertRaises(ValueError, h.get_float, ".")
        self.assertRaises(ValueError, h.get_float, "?")

    def test_get_bool(self):
        """Test _get_bool method"""
        h = ihm.reader.Handler(None)
        self.assertEqual(h.get_bool('YES'), True)
        self.assertEqual(h.get_bool('NO'), False)
        self.assertIsNone(h.get_bool('something else'))
        self.assertIsNone(h.get_bool(None))
        self.assertEqual(h.get_bool(ihm.unknown), ihm.unknown)

    def test_get_lower(self):
        """Test _get_lower method"""
        h = ihm.reader.Handler(None)
        self.assertEqual(h.get_lower('Test String'), 'test string')
        self.assertIsNone(h.get_lower(None))
        self.assertEqual(h.get_lower(ihm.unknown), ihm.unknown)
        self.assertEqual(h.get_lower('.'), '.')
        self.assertEqual(h.get_lower('?'), '?')

    def test_get_vector3(self):
        """Test _get_vector3 function"""
        d = {'tr_vector1': 4.0, 'tr_vector2': 6.0, 'tr_vector3': 9.0,
             'omitted1': None, 'unknown1': ihm.unknown}
        r = ihm.reader._get_vector3(d, 'tr_vector')
        # Coerce to int so we can compare exactly
        self.assertEqual([int(x) for x in r], [4, 6, 9])

        self.assertIsNone(ihm.reader._get_vector3(d, 'omitted'))
        self.assertEqual(ihm.reader._get_vector3(d, 'unknown'), ihm.unknown)

    def test_get_matrix33(self):
        """Test _get_matrix33 function"""
        d = {'m11': 4.0, 'm12': 6.0, 'm13': 9.0,
             'm21': 1.0, 'm22': 2.0, 'm23': 3.0,
             'm31': 8.0, 'm32': 1.0, 'm33': 7.0,
             'omitted11': None, 'unknown11': ihm.unknown}
        r = ihm.reader._get_matrix33(d, 'm')
        # Coerce to int so we can compare exactly
        self.assertEqual([[int(x) for x in row] for row in r],
                         [[4, 6, 9],
                          [1, 2, 3],
                          [8, 1, 7]])

        self.assertIsNone(ihm.reader._get_matrix33(d, 'omitted'))
        self.assertEqual(ihm.reader._get_matrix33(d, 'unknown'), ihm.unknown)

    def test_unknown_omitted(self):
        """Test that Handlers handle unknown/omitted values correctly"""
        fh = StringIO("""
loop_
_audit_author.name
_audit_author.pdbx_ordinal
. 1
? 2
'.' 3
'?' 4
#
""")
        s, = ihm.reader.read(fh)
        self.assertEqual(s.authors, [None, ihm.unknown, '.', '?'])

    def test_em2d_restraint_handler(self):
        """Test EM2DRestraintHandler"""
        fh = StringIO("""
loop_
_ihm_2dem_class_average_restraint.id
_ihm_2dem_class_average_restraint.dataset_list_id
_ihm_2dem_class_average_restraint.number_raw_micrographs
_ihm_2dem_class_average_restraint.pixel_size_width
_ihm_2dem_class_average_restraint.pixel_size_height
_ihm_2dem_class_average_restraint.image_resolution
_ihm_2dem_class_average_restraint.image_segment_flag
_ihm_2dem_class_average_restraint.number_of_projections
_ihm_2dem_class_average_restraint.struct_assembly_id
_ihm_2dem_class_average_restraint.details
1 65 800 2.030 4.030 35.000 NO 10000 42 .
#
loop_
_ihm_2dem_class_average_fitting.id
_ihm_2dem_class_average_fitting.restraint_id
_ihm_2dem_class_average_fitting.model_id
_ihm_2dem_class_average_fitting.cross_correlation_coefficient
_ihm_2dem_class_average_fitting.rot_matrix[1][1]
_ihm_2dem_class_average_fitting.rot_matrix[2][1]
_ihm_2dem_class_average_fitting.rot_matrix[3][1]
_ihm_2dem_class_average_fitting.rot_matrix[1][2]
_ihm_2dem_class_average_fitting.rot_matrix[2][2]
_ihm_2dem_class_average_fitting.rot_matrix[3][2]
_ihm_2dem_class_average_fitting.rot_matrix[1][3]
_ihm_2dem_class_average_fitting.rot_matrix[2][3]
_ihm_2dem_class_average_fitting.rot_matrix[3][3]
_ihm_2dem_class_average_fitting.tr_vector[1]
_ihm_2dem_class_average_fitting.tr_vector[2]
_ihm_2dem_class_average_fitting.tr_vector[3]
1 1 9 0.853 -0.637588 0.089507 0.765160 0.755616 -0.120841 0.643771 0.150085
0.988628 0.009414 327.161 83.209 -227.800
""")
        s, = ihm.reader.read(fh)
        r, = s.restraints
        self.assertEqual(r._id, '1')
        self.assertEqual(r.dataset._id, '65')
        self.assertEqual(r.number_raw_micrographs, 800)
        self.assertAlmostEqual(r.pixel_size_width, 2.030, delta=0.01)
        self.assertAlmostEqual(r.pixel_size_height, 4.030, delta=0.01)
        self.assertAlmostEqual(r.image_resolution, 35.0, delta=0.1)
        self.assertEqual(r.segment, False)
        self.assertEqual(r.number_of_projections, 10000)
        self.assertEqual(r.assembly._id, '42')
        fit, = list(r.fits.items())
        self.assertEqual(fit[0]._id, '9')
        self.assertAlmostEqual(fit[1].cross_correlation_coefficient, 0.853,
                               delta=0.01)
        self.assertAlmostEqual(fit[1].tr_vector[0], 327.161, delta=0.01)
        self.assertAlmostEqual(fit[1].rot_matrix[1][2], 0.988628, delta=0.01)
        self.assertEqual([int(x) for x in fit[1].tr_vector], [327, 83, -227])

    def test_sas_restraint_handler(self):
        """Test SASRestraintHandler"""
        fh = StringIO("""
loop_
_ihm_sas_restraint.id
_ihm_sas_restraint.dataset_list_id
_ihm_sas_restraint.model_id
_ihm_sas_restraint.struct_assembly_id
_ihm_sas_restraint.profile_segment_flag
_ihm_sas_restraint.fitting_atom_type
_ihm_sas_restraint.fitting_method
_ihm_sas_restraint.fitting_state
_ihm_sas_restraint.radius_of_gyration
_ihm_sas_restraint.chi_value
_ihm_sas_restraint.details
1 27 8 3 NO 'Heavy atoms' FoXS Single 27.9 1.36 .
2 27 8 4 NO 'Heavy atoms' FoXS Single 27.9 1.4 'different assembly'
2 28 8 3 NO 'Heavy atoms' FoXS Single 27.9 1.6 'different dataset'
""")
        s, = ihm.reader.read(fh)
        r, r2, r3 = s.restraints
        self.assertEqual(r.dataset._id, '27')
        self.assertEqual(r.assembly._id, '3')
        self.assertEqual(r.segment, False)
        self.assertEqual(r.fitting_method, 'FoXS')
        self.assertEqual(r.fitting_atom_type, 'Heavy atoms')
        self.assertEqual(r.multi_state, False)
        self.assertAlmostEqual(r.radius_of_gyration, 27.9, delta=0.1)
        fit, = list(r.fits.items())
        self.assertEqual(fit[0]._id, '8')
        self.assertAlmostEqual(fit[1].chi_value, 1.36, delta=0.01)
        # r2 acts on same dataset but a different assembly, so should be
        # a distinct restraint object
        self.assertEqual(r2.details, 'different assembly')
        # r3 acts on different dataset, so should be a distinct
        # restraint object
        self.assertEqual(r3.details, 'different dataset')

    def test_sphere_obj_site_handler(self):
        """Test SphereObjSiteHandler"""
        class MyModel(ihm.model.Model):
            def add_sphere(self, sphere):
                super().add_sphere(sphere)
                self.sphere_count = len(self._spheres)

        fh = StringIO("""
loop_
_ihm_model_list.model_id
_ihm_model_list.model_name
_ihm_model_list.assembly_id
_ihm_model_list.protocol_id
_ihm_model_list.representation_id
1 . 1 1 1
#
loop_
_ihm_model_group.id
_ihm_model_group.name
_ihm_model_group.details
1 "Cluster 1" .
#
loop_
_ihm_model_group_link.group_id
_ihm_model_group_link.model_id
1 1
#
loop_
_ihm_sphere_obj_site.id
_ihm_sphere_obj_site.entity_id
_ihm_sphere_obj_site.seq_id_begin
_ihm_sphere_obj_site.seq_id_end
_ihm_sphere_obj_site.asym_id
_ihm_sphere_obj_site.Cartn_x
_ihm_sphere_obj_site.Cartn_y
_ihm_sphere_obj_site.Cartn_z
_ihm_sphere_obj_site.object_radius
_ihm_sphere_obj_site.rmsf
_ihm_sphere_obj_site.model_id
1 1 1 6 A 389.993 145.089 134.782 4.931 . 1
2 1 7 7 B 406.895 142.176 135.653 3.318 1.34 1
""")
        s, = ihm.reader.read(fh, model_class=MyModel)
        m = s.state_groups[0][0][0][0]
        self.assertEqual(m.sphere_count, 2)
        s1, s2 = m._spheres
        self.assertEqual(s1.asym_unit._id, 'A')
        self.assertEqual(s1.seq_id_range, (1, 6))
        self.assertAlmostEqual(s1.x, 389.993, delta=0.01)
        self.assertAlmostEqual(s1.y, 145.089, delta=0.01)
        self.assertAlmostEqual(s1.z, 134.782, delta=0.01)
        self.assertAlmostEqual(s1.radius, 4.931, delta=0.01)
        self.assertIsNone(s1.rmsf)
        self.assertAlmostEqual(s2.rmsf, 1.34, delta=0.1)

    def test_atom_site_handler(self):
        """Test AtomSiteHandler"""
        fh = StringIO("""
loop_
_ihm_model_list.model_id
_ihm_model_list.model_name
_ihm_model_list.assembly_id
_ihm_model_list.protocol_id
_ihm_model_list.representation_id
1 . 1 1 1
#
loop_
_ihm_model_group.id
_ihm_model_group.name
_ihm_model_group.details
1 "Cluster 1" .
#
loop_
_ihm_model_group_link.group_id
_ihm_model_group_link.model_id
1 1
#
loop_
_atom_site.group_PDB
_atom_site.id
_atom_site.type_symbol
_atom_site.label_atom_id
_atom_site.label_alt_id
_atom_site.label_comp_id
_atom_site.label_seq_id
_atom_site.label_asym_id
_atom_site.Cartn_x
_atom_site.Cartn_y
_atom_site.Cartn_z
_atom_site.occupancy
_atom_site.label_entity_id
_atom_site.auth_asym_id
_atom_site.B_iso_or_equiv
_atom_site.pdbx_PDB_model_num
_atom_site.ihm_model_id
ATOM 1 N N . SER 1 A 54.401 -49.984 -35.287 . 1 A . 1 1
HETATM 2 C CA A SER . B 54.452 -48.492 -35.210 0.200 1 A 42.0 1 1
""")
        s, = ihm.reader.read(fh)
        m = s.state_groups[0][0][0][0]
        a1, a2 = m._atoms
        self.assertEqual(a1.asym_unit._id, 'A')
        self.assertEqual(a1.seq_id, 1)
        self.assertEqual(a1.atom_id, 'N')
        self.assertEqual(a1.type_symbol, 'N')
        self.assertAlmostEqual(a1.x, 54.401, delta=0.01)
        self.assertAlmostEqual(a1.y, -49.984, delta=0.01)
        self.assertAlmostEqual(a1.z, -35.287, delta=0.01)
        self.assertEqual(a1.het, False)
        self.assertIsNone(a1.biso)
        self.assertIsNone(a1.occupancy)
        self.assertIsNone(a1.alt_id)

        self.assertEqual(a2.asym_unit._id, 'B')
        self.assertEqual(a2.seq_id, 1)
        self.assertEqual(a2.atom_id, 'CA')
        self.assertEqual(a2.type_symbol, 'C')
        self.assertEqual(a2.het, True)
        self.assertAlmostEqual(a2.biso, 42.0, delta=1.0)
        self.assertAlmostEqual(a2.occupancy, 0.2, delta=0.1)
        self.assertEqual(a2.alt_id, 'A')

    def test_atom_site_handler_auth_seq_id(self):
        """Test AtomSiteHandler handling of auth_seq_id and ins_code"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_ihm_model_list.model_id
_ihm_model_list.model_name
_ihm_model_list.assembly_id
_ihm_model_list.protocol_id
_ihm_model_list.representation_id
1 . 1 1 1
#
loop_
_ihm_model_group.id
_ihm_model_group.name
_ihm_model_group.details
1 "Cluster 1" .
#
loop_
_ihm_model_group_link.group_id
_ihm_model_group_link.model_id
1 1
#
loop_
_atom_site.group_PDB
_atom_site.id
_atom_site.type_symbol
_atom_site.label_atom_id
_atom_site.label_alt_id
_atom_site.label_comp_id
_atom_site.label_seq_id
_atom_site.auth_seq_id
_atom_site.pdbx_PDB_ins_code
_atom_site.label_asym_id
_atom_site.Cartn_x
_atom_site.Cartn_y
_atom_site.Cartn_z
_atom_site.label_entity_id
_atom_site.auth_asym_id
_atom_site.B_iso_or_equiv
_atom_site.pdbx_PDB_model_num
_atom_site.ihm_model_id
ATOM 1 N N . SER 1 2 A A 54.401 -49.984 -35.287 1 A . 1 1
HETATM 2 C CA . SER 2 20A . A 54.452 -48.492 -35.210 1 A 42.0 1 1
ATOM 3 N N . SER 3 3 . A 54.401 -49.984 -35.287 1 A . 1 1
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertEqual(asym.auth_seq_id_map, {1: (2, 'A'), 2: ('20A', None)})

    def test_atom_site_handler_no_asym_id(self):
        """Test AtomSiteHandler with missing asym_id"""
        fh = StringIO("""
loop_
_entity_poly_seq.entity_id
_entity_poly_seq.num
_entity_poly_seq.mon_id
_entity_poly_seq.hetero
5 1 MET .
5 2 CYS .
5 3 MET .
5 4 SER .
#
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
D 5 foo
#
loop_
_atom_site.group_PDB
_atom_site.id
_atom_site.type_symbol
_atom_site.label_atom_id
_atom_site.label_alt_id
_atom_site.label_comp_id
_atom_site.label_asym_id
_atom_site.label_entity_id
_atom_site.label_seq_id
_atom_site.pdbx_PDB_ins_code
_atom_site.Cartn_x
_atom_site.Cartn_y
_atom_site.Cartn_z
_atom_site.occupancy
_atom_site.B_iso_or_equiv
_atom_site.pdbx_formal_charge
_atom_site.auth_asym_id
_atom_site.pdbx_PDB_model_num
ATOM   1  C CA  . MET . . 1 ?  1.000 1.000 1.000 1.00   2.95 0 A 1
ATOM   2  C CA  . ASP . . 2 ?  2.000 2.000 2.000 1.00   0.95 0 A 1
ATOM   3  C CA  . CYS . . 3 ?  3.000 3.000 3.000 1.00   0.95 0 A 1
ATOM   4  C CA  . MET . . 1 ?  1.000 1.000 1.000 1.00   2.95 0 B 1
ATOM   5  C CA  . ASP . . 2 ?  2.000 2.000 2.000 1.00   0.95 0 B 1
ATOM   6  C CA  . CYS . . 3 ?  3.000 3.000 3.000 1.00   0.95 0 B 1
ATOM   7  C CA  . CYS . . 2 ?  1.000 1.000 1.000 1.00   0.95 0 C 1
ATOM   8  C CA  . CYS . . 5 ?  3.000 3.000 3.000 1.00   0.95 0 C 1
ATOM   9  C CA  . MET . . 1 ?  3.000 3.000 3.000 1.00   0.95 0 D 1
""")
        s, = ihm.reader.read(fh)
        # No asym_id, so use auth_asym_id
        a1, a2, a3, a4 = s.asym_units
        self.assertEqual(a1._id, 'D')
        self.assertEqual(a2._id, 'A')
        self.assertEqual(a3._id, 'B')
        self.assertEqual(a4._id, 'C')
        # A and B should have same sequence, thus same entity
        self.assertIs(a2.entity, a3.entity)
        # Sequence should have been populated from comp_ids
        self.assertEqual("".join(c.code for c in a2.entity.sequence), "MDC")
        # C has different entity and sequence, with gaps
        self.assertEqual("".join(c.code_canonical for c in a4.entity.sequence),
                         "XCXXC")
        # D is defined in struct_asym and entity_poly so should use that
        # sequence
        self.assertEqual("".join(c.code_canonical for c in a1.entity.sequence),
                         "MCMS")

    def test_atom_site_handler_water(self):
        """Test AtomSiteHandler reading water molecules"""
        fh = StringIO("""
loop_
_entity.id
_entity.type
1 water
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 1 Water
B 1 Water
#
loop_
_pdbx_nonpoly_scheme.asym_id
_pdbx_nonpoly_scheme.entity_id
_pdbx_nonpoly_scheme.mon_id
_pdbx_nonpoly_scheme.ndb_seq_num
_pdbx_nonpoly_scheme.pdb_seq_num
_pdbx_nonpoly_scheme.auth_seq_num
_pdbx_nonpoly_scheme.auth_mon_id
_pdbx_nonpoly_scheme.pdb_strand_id
_pdbx_nonpoly_scheme.pdb_ins_code
A 1 HOH 1 50 500 HOH A .
#
loop_
_atom_site.group_PDB
_atom_site.id
_atom_site.type_symbol
_atom_site.label_atom_id
_atom_site.label_alt_id
_atom_site.label_comp_id
_atom_site.label_seq_id
_atom_site.auth_seq_id
_atom_site.pdbx_PDB_ins_code
_atom_site.label_asym_id
_atom_site.Cartn_x
_atom_site.Cartn_y
_atom_site.Cartn_z
_atom_site.occupancy
_atom_site.label_entity_id
_atom_site.auth_asym_id
_atom_site.B_iso_or_equiv
_atom_site.pdbx_PDB_model_num
_atom_site.ihm_model_id
HETATM 1 O O . HOH . 40 ? A 10.000 10.000 10.000 . 1 A . 1 1
HETATM 2 O O . HOH . 50 ? A 10.000 10.000 10.000 . 1 A . 1 1
HETATM 3 O O . HOH . 60 . A 20.000 20.000 20.000 . 1 A . 1 1
HETATM 4 O O . HOH . 70 . B 20.000 20.000 20.000 . 1 B . 1 1
""")
        s, = ihm.reader.read(fh)
        m = s.state_groups[0][0][0][0]
        a1, a2, a3, b1 = m._atoms
        # Should include info from both atom_site and scheme table
        self.assertEqual(a1.asym_unit.auth_seq_id_map,
                         {1: (40, None), 2: (50, None), 3: (60, None)})
        self.assertEqual(a1.asym_unit.orig_auth_seq_id_map,
                         {2: 500})
        self.assertEqual(b1.asym_unit.auth_seq_id_map, {1: (70, None)})
        self.assertIsNone(b1.asym_unit.orig_auth_seq_id_map)
        # seq_id should be assigned based on atom_site
        self.assertEqual(a1.seq_id, 1)
        self.assertEqual(a2.seq_id, 2)
        self.assertEqual(a3.seq_id, 3)
        self.assertEqual(b1.seq_id, 1)

    def test_atom_site_handler_branched(self):
        """Test AtomSiteHandler reading branched molecules"""
        cif = """
loop_
_entity.id
_entity.type
1 branched
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 1 .
#
loop_
_pdbx_branch_scheme.asym_id
_pdbx_branch_scheme.entity_id
_pdbx_branch_scheme.mon_id
_pdbx_branch_scheme.num
_pdbx_branch_scheme.pdb_seq_num
_pdbx_branch_scheme.auth_seq_num
_pdbx_branch_scheme.auth_mon_id
_pdbx_branch_scheme.pdb_asym_id
A 1 BGC 1 51 501 BGC A
A 1 BGC 2 52 502 BGC A
A 1 BGC 3 53 503 BGC A
#
loop_
_atom_site.group_PDB
_atom_site.id
_atom_site.type_symbol
_atom_site.label_atom_id
_atom_site.label_alt_id
_atom_site.label_comp_id
_atom_site.label_seq_id
_atom_site.auth_seq_id
_atom_site.pdbx_PDB_ins_code
_atom_site.label_asym_id
_atom_site.Cartn_x
_atom_site.Cartn_y
_atom_site.Cartn_z
_atom_site.occupancy
_atom_site.label_entity_id
_atom_site.auth_asym_id
_atom_site.B_iso_or_equiv
_atom_site.pdbx_PDB_model_num
_atom_site.ihm_model_id
HETATM 1 C C . BGC . 52 ? A 10.000 10.000 10.000 . 1 A . 1 1
HETATM 2 C C . BGC . 53 ? A 10.000 10.000 10.000 . 1 A . 1 1
"""
        # Should fail since residue #60 is not in the scheme table
        badline = "HETATM 3 C C . BGC . 60 . A 20.00 20.00 20.00 . 1 A . 1 1"
        fh = StringIO(cif + badline)
        self.assertRaises(ValueError, ihm.reader.read, fh)

        fh = StringIO(cif)
        s, = ihm.reader.read(fh)
        m = s.state_groups[0][0][0][0]
        a1, a2 = m._atoms
        # seq_id should match num, i.e. start at 2 since residue 51 is missing
        self.assertEqual(a1.seq_id, 2)
        self.assertEqual(a2.seq_id, 3)
        self.assertEqual(a1.asym_unit.auth_seq_id_map,
                         {1: (51, None), 2: (52, None), 3: (53, None)})
        self.assertEqual(a1.asym_unit.orig_auth_seq_id_map,
                         {1: 501, 2: 502, 3: 503})
        self.assertEqual(a1.asym_unit.num_map, {1: 2, 2: 3})

    def test_derived_distance_restraint_handler(self):
        """Test DerivedDistanceRestraintHandler"""
        feats = """
loop_
_ihm_poly_atom_feature.ordinal_id
_ihm_poly_atom_feature.feature_id
_ihm_poly_atom_feature.entity_id
_ihm_poly_atom_feature.asym_id
_ihm_poly_atom_feature.seq_id
_ihm_poly_atom_feature.comp_id
_ihm_poly_atom_feature.atom_id
1 1 1 A 1 ALA CA
2 1 1 . 1 ALA CB
#
loop_
_ihm_poly_residue_feature.ordinal_id
_ihm_poly_residue_feature.feature_id
_ihm_poly_residue_feature.entity_id
_ihm_poly_residue_feature.asym_id
_ihm_poly_residue_feature.seq_id_begin
_ihm_poly_residue_feature.comp_id_begin
_ihm_poly_residue_feature.seq_id_end
_ihm_poly_residue_feature.comp_id_end
1 2 1 B 2 CYS 3 GLY
2 2 1 . 2 CYS 3 GLY
#
loop_
_ihm_non_poly_feature.ordinal_id
_ihm_non_poly_feature.feature_id
_ihm_non_poly_feature.entity_id
_ihm_non_poly_feature.asym_id
_ihm_non_poly_feature.comp_id
_ihm_non_poly_feature.atom_id
1 3 3 C HEM FE
2 3 3 . HEM FE
3 4 3 C HEM .
4 4 3 . HEM .
#
loop_
_ihm_pseudo_site.id
_ihm_pseudo_site.Cartn_x
_ihm_pseudo_site.Cartn_y
_ihm_pseudo_site.Cartn_z
_ihm_pseudo_site.radius
_ihm_pseudo_site.description
55 10.000 20.000 30.000 4.0 'centroid'
#
loop_
_ihm_pseudo_site_feature.feature_id
_ihm_pseudo_site_feature.pseudo_site_id
5 55
"""
        rsr = """
loop_
_ihm_feature_list.feature_id
_ihm_feature_list.feature_type
_ihm_feature_list.entity_type
_ihm_feature_list.details
1 atom polymer 'test feature'
2 'residue range' polymer .
3 atom non-polymer .
4 atom non-polymer .
5 'pseudo site' other .
#
loop_
_ihm_derived_distance_restraint.id
_ihm_derived_distance_restraint.group_id
_ihm_derived_distance_restraint.feature_id_1
_ihm_derived_distance_restraint.feature_id_2
_ihm_derived_distance_restraint.restraint_type
_ihm_derived_distance_restraint.distance_lower_limit
_ihm_derived_distance_restraint.distance_upper_limit
_ihm_derived_distance_restraint.probability
_ihm_derived_distance_restraint.mic_value
_ihm_derived_distance_restraint.group_conditionality
_ihm_derived_distance_restraint.dataset_list_id
1 . 1 2 'lower bound' 25.000 . 0.800 0.400 . 97
2 . 1 4 'upper bound' . 45.000 0.800 . ALL 98
3 1 1 2 'lower and upper bound' 22.000 45.000 0.800 . ANY 99
4 1 5 3 'harmonic' 35.000 35.000 0.800 . ALL .
5 . 5 3 . ? ? ? . ALL .
"""
        # Test both ways to make sure features still work if they are
        # referenced by ID before their type is known
        for text in (feats + rsr, rsr + feats):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            self.assertEqual(len(s.orphan_features), 5)
            r1, r2, r3, r4, r5 = s.restraints
            rg1, = s.restraint_groups
            self.assertEqual([r for r in rg1], [r3, r4])
            self.assertEqual(r1.dataset._id, '97')
            self.assertIsInstance(r1.feature1,
                                  ihm.restraint.AtomFeature)
            self.assertEqual(len(r1.feature1.atoms), 2)
            self.assertEqual(r1.feature1.atoms[0].id, 'CA')
            self.assertEqual(r1.feature1.atoms[0].residue.seq_id, 1)
            self.assertIsNone(r1.feature1.atoms[0].residue.entity)
            self.assertEqual(r1.feature1.atoms[1].id, 'CB')
            self.assertEqual(r1.feature1.atoms[1].residue.seq_id, 1)
            self.assertIsNone(r1.feature1.atoms[1].residue.asym)
            self.assertEqual(r1.feature1.details, 'test feature')
            self.assertIsInstance(r1.feature2,
                                  ihm.restraint.ResidueFeature)
            self.assertEqual(len(r1.feature2.ranges), 2)
            self.assertEqual(r1.feature2.ranges[0].seq_id_range, (2, 3))
            self.assertIsInstance(r1.feature2.ranges[0], ihm.AsymUnitRange)
            self.assertEqual(r1.feature2.ranges[1].seq_id_range, (2, 3))
            self.assertIsInstance(r1.feature2.ranges[1], ihm.EntityRange)
            self.assertIsInstance(r1.distance,
                                  ihm.restraint.LowerBoundDistanceRestraint)
            self.assertAlmostEqual(r1.distance.distance, 25.000, delta=0.1)
            self.assertAlmostEqual(r1.probability, 0.8000, delta=0.1)
            self.assertAlmostEqual(r1.mic_value, 0.4000, delta=0.1)
            self.assertIsNone(r1.restrain_all)
            self.assertEqual(r2.restrain_all, True)
            self.assertEqual(r3.restrain_all, False)
            self.assertIsInstance(r2.feature2,
                                  ihm.restraint.NonPolyFeature)
            self.assertEqual(len(r2.feature2.objs), 2)
            self.assertIsInstance(r2.feature2.objs[0], ihm.AsymUnit)
            self.assertEqual(r2.feature2.objs[0]._id, 'C')
            self.assertIsInstance(r2.feature2.objs[1], ihm.Entity)
            self.assertIsInstance(r2.distance,
                                  ihm.restraint.UpperBoundDistanceRestraint)
            self.assertIsNone(r2.mic_value)
            self.assertIsInstance(
                r3.distance, ihm.restraint.LowerUpperBoundDistanceRestraint)
            self.assertIsInstance(r4.distance,
                                  ihm.restraint.HarmonicDistanceRestraint)
            self.assertIsInstance(r4.feature2,
                                  ihm.restraint.AtomFeature)
            self.assertIsNone(r4.feature2.atoms[0].residue.entity)
            self.assertIsNone(r4.feature2.atoms[1].residue.asym)
            self.assertIsInstance(r4.feature1,
                                  ihm.restraint.PseudoSiteFeature)
            self.assertAlmostEqual(r4.feature1.site.x, 10.0, delta=0.1)
            self.assertAlmostEqual(r4.feature1.site.y, 20.0, delta=0.1)
            self.assertAlmostEqual(r4.feature1.site.z, 30.0, delta=0.1)
            self.assertAlmostEqual(r4.feature1.site.radius, 4.0, delta=0.1)
            self.assertEqual(r4.feature1.site.description, 'centroid')

    def test_hdx_restraint_handler(self):
        """Test HDXRestraintHandler"""
        rsr = """
loop_
_ihm_hdx_restraint.id
_ihm_hdx_restraint.feature_id
_ihm_hdx_restraint.protection_factor
_ihm_hdx_restraint.dataset_list_id
_ihm_hdx_restraint.details
1 1 1.000 2 foo
2 2 . . .
"""
        fh = StringIO(rsr)
        s, = ihm.reader.read(fh)
        self.assertEqual(len(s.orphan_features), 2)
        r1, r2 = s.restraints
        self.assertEqual(r1.feature._id, '1')
        self.assertAlmostEqual(r1.protection_factor, 1.0, delta=1e-4)
        self.assertEqual(r1.dataset._id, '2')
        self.assertEqual(r1.details, 'foo')

        self.assertEqual(r2.feature._id, '2')
        self.assertIsNone(r2.protection_factor)
        self.assertIsNone(r2.dataset)
        self.assertIsNone(r2.details)

    def test_sphere_handler(self):
        """Test SphereHandler"""
        obj_list = CENTERS_TRANSFORMS + """
loop_
_ihm_geometric_object_list.object_id
_ihm_geometric_object_list.object_type
_ihm_geometric_object_list.object_name
_ihm_geometric_object_list.object_description
1 sphere 'my sphere' 'a test sphere'
"""
        spheres = """
loop_
_ihm_geometric_object_sphere.object_id
_ihm_geometric_object_sphere.center_id
_ihm_geometric_object_sphere.transformation_id
_ihm_geometric_object_sphere.radius_r
1 1 1 2.200
2 . . 3.200
"""
        # Order of categories shouldn't matter
        for text in (obj_list + spheres, spheres + obj_list):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            s1, s2 = s.orphan_geometric_objects
            self.assertIsInstance(s1, ihm.geometry.Sphere)
            self.assertIsInstance(s2, ihm.geometry.Sphere)
            self.assertEqual(s1.name, 'my sphere')
            self.assertEqual(s1.description, 'a test sphere')
            self.assertAlmostEqual(s1.center.x, 1.000, delta=0.1)
            self.assertAlmostEqual(s1.center.y, 2.000, delta=0.1)
            self.assertAlmostEqual(s1.center.z, 3.000, delta=0.1)
            self.assertAlmostEqual(s1.transformation.tr_vector[1], 2.000,
                                   delta=0.1)
            self.assertIsNone(s2.name)
            self.assertIsNone(s2.center)
            self.assertIsNone(s2.transformation)

    def test_torus_handler(self):
        """Test TorusHandler"""
        obj_list = CENTERS_TRANSFORMS + """
loop_
_ihm_geometric_object_list.object_id
_ihm_geometric_object_list.object_type
_ihm_geometric_object_list.object_name
_ihm_geometric_object_list.object_description
1 torus . .
"""
        tori = """
loop_
_ihm_geometric_object_torus.object_id
_ihm_geometric_object_torus.center_id
_ihm_geometric_object_torus.transformation_id
_ihm_geometric_object_torus.major_radius_R
_ihm_geometric_object_torus.minor_radius_r
1 1 1 5.600 1.200
2 . . 3.600 2.200
"""
        # Order of categories shouldn't matter
        for text in (obj_list + tori, tori + obj_list):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            t1, t2 = s.orphan_geometric_objects
            self.assertIsInstance(t1, ihm.geometry.Torus)
            self.assertIsInstance(t2, ihm.geometry.Torus)
            self.assertAlmostEqual(t1.center.x, 1.000, delta=0.1)
            self.assertAlmostEqual(t1.transformation.tr_vector[1], 2.000,
                                   delta=0.1)
            self.assertAlmostEqual(t1.major_radius, 5.600, delta=0.1)
            self.assertAlmostEqual(t1.minor_radius, 1.200, delta=0.1)
            self.assertIsNone(t2.center)
            self.assertIsNone(t2.transformation)

    def test_half_torus_handler(self):
        """Test HalfTorusHandler"""
        obj_list = CENTERS_TRANSFORMS + """
loop_
_ihm_geometric_object_list.object_id
_ihm_geometric_object_list.object_type
_ihm_geometric_object_list.object_name
_ihm_geometric_object_list.object_description
1 half-torus . .
2 half-torus . .
3 half-torus . .
"""
        tori = """
loop_
_ihm_geometric_object_torus.object_id
_ihm_geometric_object_torus.center_id
_ihm_geometric_object_torus.transformation_id
_ihm_geometric_object_torus.major_radius_R
_ihm_geometric_object_torus.minor_radius_r
1 1 1 5.600 1.200
2 . . 3.600 2.200
3 . . 3.600 2.200
"""
        half_tori = """
loop_
_ihm_geometric_object_half_torus.object_id
_ihm_geometric_object_half_torus.thickness_th
_ihm_geometric_object_half_torus.section
1 0.100 'inner half'
2 0.200 'outer half'
3 0.200 .
"""

        # Order of categories shouldn't matter
        for text in (obj_list + tori + half_tori, tori + half_tori + obj_list,
                     obj_list + half_tori + tori, half_tori + tori + obj_list):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            t1, t2, t3 = s.orphan_geometric_objects
            self.assertIsInstance(t1, ihm.geometry.HalfTorus)
            self.assertIsInstance(t2, ihm.geometry.HalfTorus)
            self.assertIsInstance(t3, ihm.geometry.HalfTorus)
            self.assertAlmostEqual(t1.center.x, 1.000, delta=0.1)
            self.assertAlmostEqual(t1.transformation.tr_vector[1], 2.000,
                                   delta=0.1)
            self.assertAlmostEqual(t1.major_radius, 5.600, delta=0.1)
            self.assertAlmostEqual(t1.minor_radius, 1.200, delta=0.1)
            self.assertAlmostEqual(t1.thickness, 0.100, delta=0.1)
            self.assertEqual(t1.inner, True)
            self.assertIsNone(t2.center)
            self.assertIsNone(t2.transformation)
            self.assertEqual(t2.inner, False)
            self.assertIsNone(t3.inner)

    def test_axis_handler(self):
        """Test AxisHandler"""
        obj_list = CENTERS_TRANSFORMS + """
loop_
_ihm_geometric_object_list.object_id
_ihm_geometric_object_list.object_type
_ihm_geometric_object_list.object_name
_ihm_geometric_object_list.object_description
1 axis . .
2 axis . .
"""
        axes = """
loop_
_ihm_geometric_object_axis.object_id
_ihm_geometric_object_axis.axis_type
_ihm_geometric_object_axis.transformation_id
1 x-axis 1
2 y-axis .
"""
        # Order of categories shouldn't matter
        for text in (obj_list + axes, axes + obj_list):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            a1, a2 = s.orphan_geometric_objects
            self.assertIsInstance(a1, ihm.geometry.XAxis)
            self.assertIsInstance(a2, ihm.geometry.YAxis)
            self.assertAlmostEqual(a1.transformation.tr_vector[1], 2.000,
                                   delta=0.1)
            self.assertIsNone(a2.transformation)

    def test_plane_handler(self):
        """Test PlaneHandler"""
        obj_list = CENTERS_TRANSFORMS + """
loop_
_ihm_geometric_object_list.object_id
_ihm_geometric_object_list.object_type
_ihm_geometric_object_list.object_name
_ihm_geometric_object_list.object_description
1 plane . .
2 plane . .
"""
        planes = """
loop_
_ihm_geometric_object_plane.object_id
_ihm_geometric_object_plane.plane_type
_ihm_geometric_object_plane.transformation_id
1 xy-plane 1
2 yz-plane .
"""
        # Order of categories shouldn't matter
        for text in (obj_list + planes, planes + obj_list):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            p1, p2 = s.orphan_geometric_objects
            self.assertIsInstance(p1, ihm.geometry.XYPlane)
            self.assertIsInstance(p2, ihm.geometry.YZPlane)
            self.assertAlmostEqual(p1.transformation.tr_vector[1], 2.000,
                                   delta=0.1)
            self.assertIsNone(p2.transformation)

    def test_geometric_restraint_handler(self):
        """Test GeometricRestraintHandler"""
        fh = StringIO("""
loop_
_ihm_geometric_object_distance_restraint.id
_ihm_geometric_object_distance_restraint.object_id
_ihm_geometric_object_distance_restraint.feature_id
_ihm_geometric_object_distance_restraint.object_characteristic
_ihm_geometric_object_distance_restraint.restraint_type
_ihm_geometric_object_distance_restraint.harmonic_force_constant
_ihm_geometric_object_distance_restraint.distance_lower_limit
_ihm_geometric_object_distance_restraint.distance_upper_limit
_ihm_geometric_object_distance_restraint.group_conditionality
_ihm_geometric_object_distance_restraint.dataset_list_id
1 23 44 other 'upper bound' 2.000 . 25.000 ANY 97
2 23 44 center 'lower bound' 2.000 15.000 . ALL .
3 23 44 'inner surface' 'lower and upper bound' 2.000 10.000 25.000 . 97
4 23 44 'outer surface' 'harmonic' 2.000 . 25.000 . 97
#
""")
        s, = ihm.reader.read(fh)
        r1, r2, r3, r4 = s.restraints
        self.assertIsInstance(r1, ihm.restraint.GeometricRestraint)
        self.assertEqual(r1.dataset._id, '97')
        self.assertEqual(r1.geometric_object._id, '23')
        self.assertEqual(r1.feature._id, '44')
        self.assertIsInstance(r1.distance,
                              ihm.restraint.UpperBoundDistanceRestraint)
        self.assertAlmostEqual(r1.distance.distance, 25.000, delta=0.1)
        self.assertAlmostEqual(r1.harmonic_force_constant, 2.000, delta=0.1)
        self.assertEqual(r1.restrain_all, False)
        self.assertEqual(r2.restrain_all, True)
        self.assertIsNone(r3.restrain_all)

        self.assertIsInstance(r2, ihm.restraint.CenterGeometricRestraint)
        self.assertIsInstance(r3, ihm.restraint.InnerSurfaceGeometricRestraint)
        self.assertIsInstance(r4, ihm.restraint.OuterSurfaceGeometricRestraint)

        self.assertIsInstance(r2.distance,
                              ihm.restraint.LowerBoundDistanceRestraint)
        self.assertIsInstance(r3.distance,
                              ihm.restraint.LowerUpperBoundDistanceRestraint)
        self.assertIsInstance(r4.distance,
                              ihm.restraint.HarmonicDistanceRestraint)

    def test_poly_seq_scheme_handler_offset(self):
        """Test PolySeqSchemeHandler with constant offset"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_pdbx_poly_seq_scheme.asym_id
_pdbx_poly_seq_scheme.entity_id
_pdbx_poly_seq_scheme.seq_id
_pdbx_poly_seq_scheme.pdb_seq_num
_pdbx_poly_seq_scheme.pdb_strand_id
A 1 1 6 A
A 1 2 7 A
A 1 3 8 A
A 1 4 9 A
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertEqual(asym.auth_seq_id_map, 5)
        self.assertIsNone(asym._strand_id)
        self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)],
                         [6, 7, 8, 9])
        self.assertIsNone(asym.orig_auth_seq_id_map)

    def test_poly_seq_scheme_handler_offset_ins_code(self):
        """Test PolySeqSchemeHandler with constant offset but inscodes"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_pdbx_poly_seq_scheme.asym_id
_pdbx_poly_seq_scheme.entity_id
_pdbx_poly_seq_scheme.seq_id
_pdbx_poly_seq_scheme.pdb_seq_num
_pdbx_poly_seq_scheme.pdb_strand_id
_pdbx_poly_seq_scheme.pdb_ins_code
A 1 1 6 A .
A 1 2 7 A .
A 1 3 8 A .
A 1 4 9 A A
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertEqual(asym.auth_seq_id_map,
                         {1: (6, None), 2: (7, None), 3: (8, None),
                          4: (9, 'A')})
        self.assertIsNone(asym._strand_id)
        self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)],
                         [6, 7, 8, 9])
        self.assertIsNone(asym.residue(1).ins_code)
        self.assertEqual(asym.residue(4).ins_code, 'A')
        self.assertIsNone(asym.orig_auth_seq_id_map)

    def test_poly_seq_scheme_handler_empty(self):
        """Test PolySeqSchemeHandler with no poly_seq_scheme"""
        fh = StringIO(ASYM_ENTITY)
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertEqual(asym.auth_seq_id_map, 0)
        self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)],
                         [1, 2, 3, 4])
        self.assertIsNone(asym.orig_auth_seq_id_map)

    def test_poly_seq_scheme_handler_nop(self):
        """Test PolySeqSchemeHandler with a do-nothing poly_seq_scheme"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_pdbx_poly_seq_scheme.asym_id
_pdbx_poly_seq_scheme.entity_id
_pdbx_poly_seq_scheme.seq_id
_pdbx_poly_seq_scheme.pdb_seq_num
A 1 1 1
A 1 2 2
A 1 3 3
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertEqual(asym.auth_seq_id_map, 0)
        self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)],
                         [1, 2, 3, 4])
        self.assertIsNone(asym.orig_auth_seq_id_map)

    def test_poly_seq_scheme_handler_partial(self):
        """Test PolySeqSchemeHandler with partial information"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_pdbx_poly_seq_scheme.asym_id
_pdbx_poly_seq_scheme.entity_id
_pdbx_poly_seq_scheme.seq_id
_pdbx_poly_seq_scheme.pdb_seq_num
_pdbx_poly_seq_scheme.auth_seq_num
A 1 1 6 .
A 1 2 7 9
A 1 3 8 .
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        # No mapping for residue 4 (and no insertion codes at all)
        self.assertEqual(asym.auth_seq_id_map, {1: (6, None), 2: (7, None),
                                                3: (8, None)})
        self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)],
                         [6, 7, 8, 4])
        self.assertIsNone(asym.residue(1).ins_code)
        self.assertEqual(asym.orig_auth_seq_id_map, {2: 9})

    def test_poly_seq_scheme_handler_incon_off(self):
        """Test PolySeqSchemeHandler with inconsistent offset"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_pdbx_poly_seq_scheme.asym_id
_pdbx_poly_seq_scheme.entity_id
_pdbx_poly_seq_scheme.seq_id
_pdbx_poly_seq_scheme.pdb_seq_num
_pdbx_poly_seq_scheme.pdb_strand_id
A 1 1 6 X
A 1 2 7 X
A 1 3 8 X
A 1 4 10 X
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertEqual(asym._strand_id, 'X')
        self.assertEqual(asym.auth_seq_id_map, {1: (6, None), 2: (7, None),
                                                3: (8, None), 4: (10, None)})
        self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)],
                         [6, 7, 8, 10])
        self.assertIsNone(asym.residue(1).ins_code)
        self.assertIsNone(asym.orig_auth_seq_id_map)

    def test_poly_seq_scheme_handler_unknown_auth_seq(self):
        """Test PolySeqSchemeHandler with explicit unknown auth_seq_num"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_pdbx_poly_seq_scheme.asym_id
_pdbx_poly_seq_scheme.entity_id
_pdbx_poly_seq_scheme.seq_id
_pdbx_poly_seq_scheme.pdb_seq_num
_pdbx_poly_seq_scheme.auth_seq_num
_pdbx_poly_seq_scheme.pdb_strand_id
A 1 1 1 1 A
A 1 2 2 2 A
A 1 3 3 ? A
A 1 4 4 4 A
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertEqual(asym.auth_seq_id_map, 0)
        self.assertEqual(asym.orig_auth_seq_id_map, {3: ihm.unknown})

    def test_poly_seq_scheme_handler_str_seq_id(self):
        """Test PolySeqSchemeHandler with a non-integer pdb_seq_num"""
        fh = StringIO(ASYM_ENTITY + """
loop_
_pdbx_poly_seq_scheme.asym_id
_pdbx_poly_seq_scheme.entity_id
_pdbx_poly_seq_scheme.seq_id
_pdbx_poly_seq_scheme.pdb_seq_num
_pdbx_poly_seq_scheme.auth_seq_num
_pdbx_poly_seq_scheme.pdb_strand_id
_pdbx_poly_seq_scheme.pdb_ins_code
A 1 1 6 6 ? .
A 1 2 7 12 ? .
A 1 3 8 24 ? .
A 1 4 9A 48A ? .
""")
        s, = ihm.reader.read(fh)
        asym, = s.asym_units
        self.assertIsNone(asym._strand_id)
        self.assertEqual(asym.auth_seq_id_map, {1: (6, None), 2: (7, None),
                                                3: (8, None), 4: ('9A', None)})
        self.assertEqual([asym.residue(i).auth_seq_id for i in range(1, 5)],
                         [6, 7, 8, '9A'])
        self.assertIsNone(asym.residue(1).ins_code)
        self.assertIsNone(asym.residue(3).ins_code)
        self.assertEqual(asym.orig_auth_seq_id_map, {2: 12, 3: 24, 4: '48A'})

    def test_nonpoly_scheme_handler(self):
        """Test NonPolySchemeHandler"""
        fh = StringIO("""
loop_
_chem_comp.id
_chem_comp.type
_chem_comp.name
CA non-polymer 'CALCIUM ION'
#
loop_
_entity.id
_entity.type
_entity.pdbx_description
1 non-polymer 'CALCIUM ION entity'
2 non-polymer 'no-chem-comp entity'
3 water       'no-chem-comp water'
#
loop_
_pdbx_entity_nonpoly.entity_id
_pdbx_entity_nonpoly.name
_pdbx_entity_nonpoly.comp_id
1 'CALCIUM ION'             CA
#
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 1 foo
B 2 bar
C 3 baz
#
loop_
_pdbx_nonpoly_scheme.asym_id
_pdbx_nonpoly_scheme.entity_id
_pdbx_nonpoly_scheme.mon_id
_pdbx_nonpoly_scheme.ndb_seq_num
_pdbx_nonpoly_scheme.pdb_seq_num
_pdbx_nonpoly_scheme.auth_seq_num
_pdbx_nonpoly_scheme.pdb_strand_id
_pdbx_nonpoly_scheme.pdb_ins_code
A 1 BAR 1 101 202 . .
B 2 BAR 1 1 1 Q X
C 3 HOH . 1 1 . .
C 3 HOH 2 2 2 . .
C 3 HOH 3 5 10 . .
C 3 HOH 4 1 20 . .
C 3 HOH 5 7 7 . .
""")
        s, = ihm.reader.read(fh)
        e1, e2, e3 = s.entities
        # e1 should have sequence filled in by pdbx_entity_nonpoly
        self.assertEqual([cc.name for cc in e1.sequence], ['CALCIUM ION'])
        # e2,e3 should have sequence filled in by pdbx_nonpoly_scheme
        self.assertEqual([(cc.id, cc.name) for cc in e2.sequence],
                         [('BAR', 'no-chem-comp entity')])
        self.assertEqual([(cc.id, cc.name) for cc in e3.sequence],
                         [('HOH', 'WATER')])
        asym, a2, a3 = s.asym_units
        # non-polymers have no seq_id_range
        self.assertEqual(asym.seq_id_range, (None, None))
        self.assertEqual(asym.auth_seq_id_map, {1: (101, None)})
        self.assertEqual(asym.residue(1).auth_seq_id, 101)
        self.assertIsNone(asym.residue(1).ins_code)
        self.assertEqual(asym.strand_id, asym._id)
        self.assertIsNone(asym._strand_id)
        self.assertEqual(asym.orig_auth_seq_id_map, {1: 202})

        self.assertEqual(a2.auth_seq_id_map, {1: (1, 'X')})
        self.assertEqual(a2.residue(1).auth_seq_id, 1)
        self.assertEqual(a2.residue(1).ins_code, 'X')
        self.assertEqual(a2.strand_id, 'Q')
        self.assertEqual(a2._strand_id, 'Q')
        self.assertIsNone(a2.orig_auth_seq_id_map)

        self.assertEqual(a3.auth_seq_id_map, {1: (1, None), 2: (2, None),
                                              3: (5, None), 4: (1, None),
                                              5: (7, None)})
        self.assertEqual(a3.orig_auth_seq_id_map, {3: 10, 4: 20})

    def test_cross_link_list_handler(self):
        """Test CrossLinkListHandler"""
        fh = StringIO("""
loop_
_ihm_cross_link_list.id
_ihm_cross_link_list.group_id
_ihm_cross_link_list.entity_description_1
_ihm_cross_link_list.entity_id_1
_ihm_cross_link_list.seq_id_1
_ihm_cross_link_list.comp_id_1
_ihm_cross_link_list.entity_description_2
_ihm_cross_link_list.entity_id_2
_ihm_cross_link_list.seq_id_2
_ihm_cross_link_list.comp_id_2
_ihm_cross_link_list.linker_chem_comp_descriptor_id
_ihm_cross_link_list.dataset_list_id
_ihm_cross_link_list.details
1 1 foo 1 2 THR foo 1 3 CYS 44 97 .
2 2 foo 1 2 THR bar 2 3 PHE 44 97 'test xl'
3 2 foo 1 2 THR bar 2 2 GLU 44 97 .
4 3 foo 1 1 ALA bar 2 1 ASP 44 97 .
5 4 foo 1 1 ALA bar 2 1 ASP 88 97 .
6 5 foo 1 1 ALA bar 2 1 ASP 44 98 .
""")
        s, = ihm.reader.read(fh)
        # Check grouping
        self.assertEqual([[len(g) for g in r.experimental_cross_links]
                          for r in s.restraints], [[1, 2, 1], [1], [1]])
        r1, r2, r3 = s.restraints
        self.assertEqual(r1.dataset._id, '97')
        self.assertEqual(r1.linker._id, '44')
        xl = r1.experimental_cross_links[1][0]
        self.assertEqual(xl.residue1.entity._id, '1')
        self.assertEqual(xl.residue2.entity._id, '2')
        self.assertEqual(xl.residue1.seq_id, 2)
        self.assertEqual(xl.residue2.seq_id, 3)
        self.assertEqual(xl.details, 'test xl')

    def test_cross_link_list_handler_linker_type(self):
        """Test CrossLinkListHandler with old-style linker_type"""
        fh = StringIO("""
loop_
_ihm_cross_link_list.id
_ihm_cross_link_list.group_id
_ihm_cross_link_list.entity_description_1
_ihm_cross_link_list.entity_id_1
_ihm_cross_link_list.seq_id_1
_ihm_cross_link_list.comp_id_1
_ihm_cross_link_list.entity_description_2
_ihm_cross_link_list.entity_id_2
_ihm_cross_link_list.seq_id_2
_ihm_cross_link_list.comp_id_2
_ihm_cross_link_list.linker_type
_ihm_cross_link_list.dataset_list_id
1 1 foo 1 2 THR foo 1 3 CYS DSS 97
2 2 foo 1 2 THR bar 2 3 PHE DSS 97
3 2 foo 1 2 THR bar 2 2 GLU DSS 97
4 3 foo 1 1 ALA bar 2 1 ASP DSS 97
5 4 foo 1 1 ALA bar 2 1 ASP TST 97
6 5 foo 1 1 ALA bar 2 1 ASP DSS 98
""")
        s, = ihm.reader.read(fh)
        # Check grouping
        r1, r2, r3 = s.restraints
        self.assertEqual(r1.linker.auth_name, 'DSS')
        self.assertEqual(r1.linker.chemical_name, 'disuccinimidyl suberate')
        self.assertEqual(r2.linker.auth_name, 'TST')
        self.assertIsNone(r2.linker.chemical_name)
        self.assertEqual(r3.linker.auth_name, 'DSS')
        self.assertEqual(r3.linker.chemical_name, 'disuccinimidyl suberate')

    def test_cross_link_list_handler_empty_descriptor(self):
        """Test CrossLinkListHandler with empty descriptor name"""
        fh = StringIO("""
loop_
_ihm_chemical_component_descriptor.id
_ihm_chemical_component_descriptor.auth_name
1 DSS
2 .
3 .
#
loop_
_ihm_cross_link_list.id
_ihm_cross_link_list.group_id
_ihm_cross_link_list.entity_description_1
_ihm_cross_link_list.entity_id_1
_ihm_cross_link_list.seq_id_1
_ihm_cross_link_list.comp_id_1
_ihm_cross_link_list.entity_description_2
_ihm_cross_link_list.entity_id_2
_ihm_cross_link_list.seq_id_2
_ihm_cross_link_list.comp_id_2
_ihm_cross_link_list.linker_chem_comp_descriptor_id
_ihm_cross_link_list.linker_type
_ihm_cross_link_list.dataset_list_id
1 1 foo 1 2 THR foo 1 3 CYS 1 NOTDSS 97
2 2 foo 1 2 THR bar 2 3 PHE 2 EDC 97
3 2 foo 1 2 THR bar 2 3 PHE 3 . 97
""")
        s, = ihm.reader.read(fh)
        d1, d2, d3 = s.orphan_chem_descriptors
        # Descriptor name (DSS) should take precedence over
        # linker_type (NOTDSS)
        self.assertEqual(d1.auth_name, 'DSS')
        # If descriptor name is empty, fill it in using linker_type
        self.assertEqual(d2.auth_name, 'EDC')
        # If both names are empty, name is None
        self.assertIsNone(d3.auth_name)

    def test_cross_link_restraint_handler(self):
        """Test CrossLinkRestraintHandler"""
        xl_list = """
loop_
_ihm_cross_link_list.id
_ihm_cross_link_list.group_id
_ihm_cross_link_list.entity_description_1
_ihm_cross_link_list.entity_id_1
_ihm_cross_link_list.seq_id_1
_ihm_cross_link_list.comp_id_1
_ihm_cross_link_list.entity_description_2
_ihm_cross_link_list.entity_id_2
_ihm_cross_link_list.seq_id_2
_ihm_cross_link_list.comp_id_2
_ihm_cross_link_list.linker_type
_ihm_cross_link_list.dataset_list_id
1 1 foo 1 2 THR foo 1 3 CYS DSS 97
2 2 foo 1 2 THR bar 2 3 PHE DSS 97
#
loop_
_ihm_cross_link_pseudo_site.id
_ihm_cross_link_pseudo_site.restraint_id
_ihm_cross_link_pseudo_site.cross_link_partner
_ihm_cross_link_pseudo_site.pseudo_site_id
_ihm_cross_link_pseudo_site.model_id
1 2 1 44 .
2 2 2 88 99
3 2 2 880 990
"""
        xl_rsr = """
loop_
_ihm_cross_link_restraint.id
_ihm_cross_link_restraint.group_id
_ihm_cross_link_restraint.entity_id_1
_ihm_cross_link_restraint.asym_id_1
_ihm_cross_link_restraint.seq_id_1
_ihm_cross_link_restraint.comp_id_1
_ihm_cross_link_restraint.entity_id_2
_ihm_cross_link_restraint.asym_id_2
_ihm_cross_link_restraint.seq_id_2
_ihm_cross_link_restraint.comp_id_2
_ihm_cross_link_restraint.atom_id_1
_ihm_cross_link_restraint.atom_id_2
_ihm_cross_link_restraint.restraint_type
_ihm_cross_link_restraint.conditional_crosslink_flag
_ihm_cross_link_restraint.model_granularity
_ihm_cross_link_restraint.distance_threshold
_ihm_cross_link_restraint.psi
_ihm_cross_link_restraint.sigma_1
_ihm_cross_link_restraint.sigma_2
1 1 1 A 2 THR 1 B 3 CYS . . 'upper bound' ALL by-residue 25.000 0.500 1.000
2.000
2 2 1 A 2 THR 2 B 2 GLU C N 'lower bound' ANY by-atom 34.000 . . .
"""
        # Order of categories shouldn't matter
        for text in (xl_list + xl_rsr, xl_rsr + xl_list):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            r, = s.restraints
            xl1, xl2 = sorted(r.cross_links, key=operator.attrgetter('_id'))
            self.assertIsInstance(xl1, ihm.restraint.ResidueCrossLink)
            self.assertEqual(xl1.experimental_cross_link.residue1.seq_id, 2)
            self.assertEqual(xl1.experimental_cross_link.residue2.seq_id, 3)
            self.assertEqual(xl1.fits, {})
            self.assertEqual(xl1.asym1._id, 'A')
            self.assertEqual(xl1.asym2._id, 'B')
            self.assertIsInstance(xl1.distance,
                                  ihm.restraint.UpperBoundDistanceRestraint)
            self.assertAlmostEqual(xl1.distance.distance, 25.000, delta=0.1)
            self.assertAlmostEqual(xl1.psi, 0.500, delta=0.1)
            self.assertAlmostEqual(xl1.sigma1, 1.000, delta=0.1)
            self.assertAlmostEqual(xl1.sigma2, 2.000, delta=0.1)
            self.assertIsNone(xl1.pseudo1)
            self.assertIsNone(xl1.pseudo2)

            self.assertIsInstance(xl2, ihm.restraint.AtomCrossLink)
            self.assertEqual(xl2.fits, {})
            self.assertIsInstance(xl2.distance,
                                  ihm.restraint.LowerBoundDistanceRestraint)
            self.assertTrue(xl2.atom1, 'C')
            self.assertTrue(xl2.atom2, 'N')
            self.assertAlmostEqual(xl2.distance.distance, 34.000, delta=0.1)
            self.assertIsNone(xl2.psi)
            self.assertIsNone(xl2.sigma1)
            self.assertIsNone(xl2.sigma2)
            ps1, = xl2.pseudo1
            self.assertEqual(ps1.site._id, '44')
            self.assertIsNone(ps1.model)
            ps21, ps22 = xl2.pseudo2
            self.assertEqual(ps21.site._id, '88')
            self.assertEqual(ps21.model._id, '99')
            self.assertEqual(ps22.site._id, '880')
            self.assertEqual(ps22.model._id, '990')

    def test_cross_link_result_handler(self):
        """Test CrossLinkResultHandler"""
        xl_list = """
loop_
_ihm_cross_link_list.id
_ihm_cross_link_list.group_id
_ihm_cross_link_list.entity_description_1
_ihm_cross_link_list.entity_id_1
_ihm_cross_link_list.seq_id_1
_ihm_cross_link_list.comp_id_1
_ihm_cross_link_list.entity_description_2
_ihm_cross_link_list.entity_id_2
_ihm_cross_link_list.seq_id_2
_ihm_cross_link_list.comp_id_2
_ihm_cross_link_list.linker_type
_ihm_cross_link_list.dataset_list_id
1 1 foo 1 2 THR foo 1 3 CYS DSS 97
"""
        xl_rsr = """
loop_
_ihm_cross_link_restraint.id
_ihm_cross_link_restraint.group_id
_ihm_cross_link_restraint.entity_id_1
_ihm_cross_link_restraint.asym_id_1
_ihm_cross_link_restraint.seq_id_1
_ihm_cross_link_restraint.comp_id_1
_ihm_cross_link_restraint.entity_id_2
_ihm_cross_link_restraint.asym_id_2
_ihm_cross_link_restraint.seq_id_2
_ihm_cross_link_restraint.comp_id_2
_ihm_cross_link_restraint.atom_id_1
_ihm_cross_link_restraint.atom_id_2
_ihm_cross_link_restraint.restraint_type
_ihm_cross_link_restraint.conditional_crosslink_flag
_ihm_cross_link_restraint.model_granularity
_ihm_cross_link_restraint.distance_threshold
_ihm_cross_link_restraint.psi
_ihm_cross_link_restraint.sigma_1
_ihm_cross_link_restraint.sigma_2
1 1 1 A 2 THR 1 B 3 CYS . . 'upper bound' ALL by-residue 25.000 0.500 1.000
2.000
"""
        xl_fit = """
loop_
_ihm_cross_link_result_parameters.id
_ihm_cross_link_result_parameters.restraint_id
_ihm_cross_link_result_parameters.model_id
_ihm_cross_link_result_parameters.psi
_ihm_cross_link_result_parameters.sigma_1
_ihm_cross_link_result_parameters.sigma_2
1 1 201 0.100 4.200 2.100
2 1 301 . . .
#
loop_
_ihm_cross_link_result.id
_ihm_cross_link_result.restraint_id
_ihm_cross_link_result.ensemble_id
_ihm_cross_link_result.model_group_id
_ihm_cross_link_result.num_models
_ihm_cross_link_result.distance_threshold
_ihm_cross_link_result.median_distance
_ihm_cross_link_result.details
1 1 401 . 10 99.0 10.0 'details 1'
2 1 . 501 20 99.0 20.0 .
"""
        # Order of categories shouldn't matter
        for text in (xl_list + xl_rsr + xl_fit, xl_fit + xl_rsr + xl_list):
            fh = StringIO(text)
            s, = ihm.reader.read(fh)
            r, = s.restraints
            xl, = r.cross_links
            # Sort fits by ID
            fits = sorted(xl.fits.items(), key=lambda x: x[0]._id)
            self.assertEqual(len(fits), 4)
            self.assertIsInstance(fits[0][0], ihm.model.Model)
            self.assertEqual(fits[0][0]._id, '201')
            self.assertAlmostEqual(fits[0][1].psi, 0.100, delta=0.1)
            self.assertAlmostEqual(fits[0][1].sigma1, 4.200, delta=0.1)
            self.assertAlmostEqual(fits[0][1].sigma2, 2.100, delta=0.1)

            self.assertEqual(fits[1][0]._id, '301')
            self.assertIsInstance(fits[1][0], ihm.model.Model)
            self.assertIsNone(fits[1][1].psi)
            self.assertIsNone(fits[1][1].sigma1)
            self.assertIsNone(fits[1][1].sigma2)

            self.assertEqual(fits[2][0]._id, '401')
            self.assertIsInstance(fits[2][0], ihm.model.Ensemble)
            self.assertEqual(fits[2][1].num_models, 10)
            self.assertAlmostEqual(fits[2][1].median_distance, 10.0,
                                   delta=0.01)
            self.assertEqual(fits[2][1].details, 'details 1')

            self.assertEqual(fits[3][0]._id, '501')
            self.assertIsInstance(fits[3][0], ihm.model.ModelGroup)
            self.assertEqual(fits[3][1].num_models, 20)
            self.assertAlmostEqual(fits[3][1].median_distance, 20.0,
                                   delta=0.01)
            self.assertIsNone(fits[3][1].details)

    def test_ordered_model_handler(self):
        """Test OrderedModelHandler"""
        # Test both old and new category names
        fh = StringIO("""
loop_
_ihm_ordered_model.process_id
_ihm_ordered_model.process_description
_ihm_ordered_model.ordered_by
_ihm_ordered_model.step_id
_ihm_ordered_model.step_description
_ihm_ordered_model.edge_id
_ihm_ordered_model.edge_description
_ihm_ordered_model.model_group_id_begin
_ihm_ordered_model.model_group_id_end
1 pdesc 'steps in a reaction pathway' 1 'step 1 desc' 1 .  1 2
1 pdesc 'steps in a reaction pathway' 2 'step 2 desc' 2 'edge 2 desc'  1 3
#
loop_
_ihm_ordered_ensemble.process_id
_ihm_ordered_ensemble.process_description
_ihm_ordered_ensemble.ordered_by
_ihm_ordered_ensemble.step_id
_ihm_ordered_ensemble.step_description
_ihm_ordered_ensemble.edge_id
_ihm_ordered_ensemble.edge_description
_ihm_ordered_ensemble.model_group_id_begin
_ihm_ordered_ensemble.model_group_id_end
1 pdesc 'steps in a reaction pathway' 2 'step 2 desc' 3 .  1 4
""")
        s, = ihm.reader.read(fh)
        op, = s.ordered_processes
        self.assertEqual(op.description, 'pdesc')
        self.assertEqual(len(op.steps), 2)
        s1, s2 = op.steps
        self.assertEqual(s1.description, 'step 1 desc')
        self.assertEqual(len(s1), 1)
        e1 = s1[0]
        self.assertIsNone(e1.description)
        self.assertEqual(e1.group_begin._id, '1')
        self.assertEqual(e1.group_end._id, '2')

        self.assertEqual(s2.description, 'step 2 desc')
        self.assertEqual(len(s2), 2)
        e1 = s2[0]
        self.assertEqual(e1.description, 'edge 2 desc')
        self.assertEqual(e1.group_begin._id, '1')
        self.assertEqual(e1.group_end._id, '3')
        e2 = s2[1]
        self.assertIsNone(e2.description)
        self.assertEqual(e2.group_begin._id, '1')
        self.assertEqual(e2.group_end._id, '4')

    def _check_pdbx(self, s):
        self.assertEqual(
            s.title, 'Enterococcus faecalis FIC protein in complex '
            'with AMP and calcium ion.')
        self.assertEqual(len(s.databases), 2)
        self.assertEqual(s.databases[0].code, '6EP0')
        self.assertEqual(s.databases[1].code, 'D_1200006994')
        self.assertEqual(s.authors, ['Veyron, S.', 'Cherfils, J.'])
        self.assertEqual(s.citations[0].doi, '10.1038/s41467-019-09023-1')
        self.assertEqual(s.grants[0].funding_organization, 'DIM Malinf')
        self.assertEqual(len(s.revisions), 4)
        self.assertEqual(len(s.entities), 5)
        self.assertEqual(len(s.asym_units), 14)
        self.assertEqual(
            [x.name for x in s.software],
            ['BUSTER', 'autoPROC', 'XDS', 'PHENIX'])
        m = s.state_groups[0][0][0][0]
        self.assertEqual(len(m._atoms), 3528)
        self.assertAlmostEqual(m._atoms[0].x, -23.51, delta=0.01)
        self.assertAlmostEqual(m._atoms[0].y, 15.583, delta=0.01)
        self.assertAlmostEqual(m._atoms[0].z, 17.773, delta=0.01)

    def test_read_full_pdbx_mmcif(self):
        """Test reading a full PDBx file in mmCIF format"""
        fname = utils.get_input_file_name(TOPDIR, '6ep0.cif.gz')
        with gzip.open(fname, 'rt') as f:
            s, = ihm.reader.read(f)
        self._check_pdbx(s)

    @unittest.skipIf(_format is None, "No C tokenizer")
    def test_read_full_pdbx_bcif(self):
        """Test reading a full PDBx file in BinaryCIF format"""
        fname = utils.get_input_file_name(TOPDIR, '6ep0.bcif.gz')
        with gzip.open(fname, 'rb') as f:
            s, = ihm.reader.read(f, format='BCIF')
        self._check_pdbx(s)

    def test_old_file_read_default(self):
        """Test default handling of old files"""
        cif = """
loop_
_audit_conform.dict_name
_audit_conform.dict_version
mmcif_pdbx.dic     5.311
ihm-extension.dic  0.14
"""
        s, = ihm.reader.read(StringIO(cif))

    def test_old_file_read_fail(self):
        """Test failure reading old files"""
        cif = """
loop_
_audit_conform.dict_name
_audit_conform.dict_version
mmcif_pdbx.dic     5.311
ihm-extension.dic  0.14
"""
        self.assertRaises(ihm.reader.OldFileError,
                          ihm.reader.read, StringIO(cif), reject_old_file=True)

    def test_new_file_read_ok(self):
        """Test success reading not-old files"""
        # File read is OK if version is new enough, or version cannot be parsed
        # because it is non-int or has too many elements
        for ver in ('1.0', '0.0.4', '0.0a'):
            cif = """
loop_
_audit_conform.dict_name
_audit_conform.dict_version
mmcif_pdbx.dic     5.311
ihm-extension.dic  %s
""" % ver
            s, = ihm.reader.read(StringIO(cif), reject_old_file=True)

    def test_warn_unknown_category(self):
        """Test warnings for unknown categories"""
        cif = """
_cat1.foo baz
_cat1.bar baz
#
loop_
_cat2.foo
_cat2.bar
x y
"""
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            # Test with no warnings
            s, = ihm.reader.read(StringIO(cif))
            self.assertEqual(len(w), 0)
            s, = ihm.reader.read(StringIO(cif), warn_unknown_category=True)
            # Should only warn once per category
            self.assertEqual(len(w), 2)
            self.assertEqual(w[0].category, ihm.reader.UnknownCategoryWarning)
            self.assertTrue('Unknown category _cat1 encountered on line 2'
                            in str(w[0].message))
            self.assertEqual(w[1].category, ihm.reader.UnknownCategoryWarning)
            self.assertTrue('Unknown category _cat2 encountered on line 6'
                            in str(w[1].message))

    def test_warn_unknown_keyword(self):
        """Test warnings for unknown keywords"""
        cif = """
_cat1.foo baz
_struct.unknown foo
#
loop_
_struct_asym.id
_struct_asym.bar
1 y
loop_
_audit_author.pdbx_ordinal
_audit_author.name
1 "Smith J"
"""
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            # Test with no warnings
            s, = ihm.reader.read(StringIO(cif))
            self.assertEqual(len(w), 0)
            s, = ihm.reader.read(StringIO(cif), warn_unknown_keyword=True)
            # pdbx_ordinal is explicitly ignored, so should not trigger
            # a warning
            self.assertEqual(len(w), 2)
            self.assertEqual(w[0].category, ihm.reader.UnknownKeywordWarning)
            self.assertTrue('keyword _struct.unknown encountered on line 3'
                            in str(w[0].message))
            self.assertEqual(w[1].category, ihm.reader.UnknownKeywordWarning)
            self.assertTrue('keyword _struct_asym.bar encountered on line 7'
                            in str(w[1].message))

    def test_predicted_contact_restraint_handler(self):
        """Test PredictedContactRestraintHandler"""
        fh = StringIO("""
loop_
_ihm_predicted_contact_restraint.id
_ihm_predicted_contact_restraint.group_id
_ihm_predicted_contact_restraint.entity_id_1
_ihm_predicted_contact_restraint.asym_id_1
_ihm_predicted_contact_restraint.comp_id_1
_ihm_predicted_contact_restraint.seq_id_1
_ihm_predicted_contact_restraint.rep_atom_1
_ihm_predicted_contact_restraint.entity_id_2
_ihm_predicted_contact_restraint.asym_id_2
_ihm_predicted_contact_restraint.comp_id_2
_ihm_predicted_contact_restraint.seq_id_2
_ihm_predicted_contact_restraint.rep_atom_2
_ihm_predicted_contact_restraint.restraint_type
_ihm_predicted_contact_restraint.distance_lower_limit
_ihm_predicted_contact_restraint.distance_upper_limit
_ihm_predicted_contact_restraint.probability
_ihm_predicted_contact_restraint.model_granularity
_ihm_predicted_contact_restraint.dataset_list_id
_ihm_predicted_contact_restraint.software_id
1 . 1 A ALA 1 . 2 B TRP 2 . 'lower bound' 25.000 . 0.800 by-residue 97 34
2 1 1 A ALA 1 CA 2 B TRP 2 CB 'lower bound' 25.000 . 0.400 by-residue 97 .
3 1 1 A ALA 1 . 2 B TRP 2 . 'upper bound' . 14.000 0.600 by-feature 97 .
""")
        s, = ihm.reader.read(fh)
        r1, r2, r3 = s.restraints
        rg1, = s.restraint_groups
        self.assertEqual([r for r in rg1], [r2, r3])
        self.assertEqual(r1.dataset._id, '97')
        self.assertIsInstance(r1.resatom1, ihm.Residue)
        self.assertEqual(r1.resatom1.seq_id, 1)
        self.assertEqual(r1.resatom1.asym._id, 'A')
        self.assertIsInstance(r1.resatom2, ihm.Residue)
        self.assertEqual(r1.resatom2.seq_id, 2)
        self.assertEqual(r1.resatom2.asym._id, 'B')
        self.assertIsInstance(r1.distance,
                              ihm.restraint.LowerBoundDistanceRestraint)
        self.assertAlmostEqual(r1.distance.distance, 25.000, delta=0.1)
        self.assertAlmostEqual(r1.probability, 0.8000, delta=0.1)
        self.assertEqual(r1.by_residue, True)
        self.assertEqual(r1.software._id, '34')

        self.assertIsInstance(r2.resatom1, ihm.Atom)
        self.assertEqual(r2.resatom1.seq_id, 1)
        self.assertEqual(r2.resatom1.asym._id, 'A')
        self.assertEqual(r2.resatom1.id, 'CA')
        self.assertIsInstance(r2.resatom2, ihm.Atom)
        self.assertEqual(r2.resatom2.seq_id, 2)
        self.assertEqual(r2.resatom2.asym._id, 'B')
        self.assertEqual(r2.resatom2.id, 'CB')
        self.assertIsInstance(r3.distance,
                              ihm.restraint.UpperBoundDistanceRestraint)
        self.assertAlmostEqual(r3.distance.distance, 14.000, delta=0.1)
        self.assertIsNone(r3.software)

    def get_starting_model_coord(self):
        return """
loop_
_ihm_starting_model_coord.starting_model_id
_ihm_starting_model_coord.group_PDB
_ihm_starting_model_coord.id
_ihm_starting_model_coord.type_symbol
_ihm_starting_model_coord.atom_id
_ihm_starting_model_coord.comp_id
_ihm_starting_model_coord.entity_id
_ihm_starting_model_coord.asym_id
_ihm_starting_model_coord.seq_id
_ihm_starting_model_coord.Cartn_x
_ihm_starting_model_coord.Cartn_y
_ihm_starting_model_coord.Cartn_z
_ihm_starting_model_coord.B_iso_or_equiv
_ihm_starting_model_coord.ordinal_id
1 ATOM 1 N N TYR 1 A 7 8.436 112.871 97.789 . 1
1 HETATM 2 C CA TYR 1 B . 7.951 111.565 97.289 91.820 2
"""

    def test_starting_model_coord_handler(self):
        """Test StartingModelCoordHandler"""
        fh = StringIO(self.get_starting_model_coord())
        s, = ihm.reader.read(fh)
        sm, = s.orphan_starting_models
        a1, a2 = sm._atoms
        self.assertEqual(a1.asym_unit._id, 'A')
        self.assertEqual(a1.seq_id, 7)
        self.assertEqual(a1.atom_id, 'N')
        self.assertEqual(a1.type_symbol, 'N')
        self.assertAlmostEqual(a1.x, 8.436, delta=0.01)
        self.assertAlmostEqual(a1.y, 112.871, delta=0.01)
        self.assertAlmostEqual(a1.z, 97.789, delta=0.01)
        self.assertEqual(a1.het, False)
        self.assertIsNone(a1.biso)

        self.assertEqual(a2.asym_unit._id, 'B')
        self.assertIsNone(a2.seq_id)
        self.assertEqual(a2.atom_id, 'CA')
        self.assertEqual(a2.type_symbol, 'C')
        self.assertEqual(a2.het, True)
        self.assertAlmostEqual(a2.biso, 91.820, delta=0.1)

    def test_starting_model_coord_ignored(self):
        """Test read, ignoring starting model coordinates"""
        fh = StringIO(self.get_starting_model_coord())
        s, = ihm.reader.read(fh, read_starting_model_coord=False)
        self.assertEqual(len(s.orphan_starting_models), 0)

    def test_starting_model_seq_dif_handler(self):
        """Test StartingModelSeqDifHandler"""
        fh = StringIO("""
loop_
_ihm_starting_model_seq_dif.ordinal_id
_ihm_starting_model_seq_dif.entity_id
_ihm_starting_model_seq_dif.asym_id
_ihm_starting_model_seq_dif.seq_id
_ihm_starting_model_seq_dif.comp_id
_ihm_starting_model_seq_dif.starting_model_id
_ihm_starting_model_seq_dif.db_asym_id
_ihm_starting_model_seq_dif.db_seq_id
_ihm_starting_model_seq_dif.db_comp_id
_ihm_starting_model_seq_dif.details
1 7 G 11 LEU 9 D 12 MSE 'Mutation of MSE to LEU'
2 7 G 17 LEU 9 D 18 MSE 'Mutation of MSE to LEU'
""")
        s, = ihm.reader.read(fh)
        sm, = s.orphan_starting_models
        sd1, sd2 = sm._seq_difs
        self.assertEqual(sd1.seq_id, 11)
        self.assertEqual(sd1.db_seq_id, 12)
        self.assertEqual(sd1.db_comp_id, "MSE")
        self.assertEqual(sd1.details, "Mutation of MSE to LEU")

    def test_multi_state_scheme_handler(self):
        """Test MultiStateSchemeHandler"""
        fh = StringIO("""
loop_
_ihm_multi_state_scheme.id
_ihm_multi_state_scheme.name
_ihm_multi_state_scheme.details
1 'scheme1' 'details1'
2 'scheme2' .
""")
        s, = ihm.reader.read(fh)
        schemes = s.multi_state_schemes
        mss1 = schemes[0]
        self.assertIsInstance(mss1, ihm.multi_state_scheme.MultiStateScheme)
        self.assertEqual(mss1._id, '1')
        self.assertEqual(mss1.name, 'scheme1')
        self.assertEqual(mss1.details, 'details1')
        mss2 = schemes[1]
        self.assertIsInstance(mss2, ihm.multi_state_scheme.MultiStateScheme)
        self.assertEqual(mss2._id, '2')
        self.assertEqual(mss2.name, 'scheme2')
        self.assertIsNone(mss2.details)

    def test_multi_state_scheme_connectivity_handler(self):
        """Test MultiStateSchemeConnectivityHandler"""
        mss_cif = """
loop_
_ihm_multi_state_scheme.id
_ihm_multi_state_scheme.name
_ihm_multi_state_scheme.details
1 'scheme1' 'details1'
2 'scheme2' 'details2'
#
"""
        mssc_cif = """
#
loop_
_ihm_multi_state_scheme_connectivity.id
_ihm_multi_state_scheme_connectivity.scheme_id
_ihm_multi_state_scheme_connectivity.begin_state_id
_ihm_multi_state_scheme_connectivity.end_state_id
_ihm_multi_state_scheme_connectivity.dataset_group_id
_ihm_multi_state_scheme_connectivity.details
1 1 1 2 10 'connectivity1'
2 1 2 1 11 .
3 1 3 . 12 'connectivity3'
4 2 2 1 11 .
"""
        # Order of categories should not matter
        for cif in (mss_cif + mssc_cif, mssc_cif + mss_cif):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                schemes = s.multi_state_schemes
                mss1 = schemes[0]
                # Connectivity 1
                c1 = mss1._connectivity_list[0]
                self.assertIsInstance(
                    c1,
                    ihm.multi_state_scheme.Connectivity)
                self.assertEqual(c1._id, '1')
                self.assertIsInstance(c1.begin_state, ihm.model.State)
                self.assertEqual(c1.begin_state._id, '1')
                self.assertIsInstance(c1.end_state, ihm.model.State)
                self.assertEqual(c1.end_state._id, '2')
                self.assertIsInstance(c1.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(c1.dataset_group._id, '10')
                self.assertEqual(c1.details, 'connectivity1')
                # Connectivity 2
                c2 = mss1._connectivity_list[1]
                self.assertIsInstance(
                    c2,
                    ihm.multi_state_scheme.Connectivity)
                self.assertEqual(c2._id, '2')
                self.assertIsInstance(c2.begin_state, ihm.model.State)
                self.assertEqual(c2.begin_state._id, '2')
                self.assertIsInstance(c1.end_state, ihm.model.State)
                self.assertEqual(c2.end_state._id, '1')
                self.assertIsInstance(c2.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(c2.dataset_group._id, '11')
                self.assertIsNone(c2.details)
                # Connectivity 1 is unequal to Connectivity 2
                self.assertFalse(c1 == c2)
                # Connectivity 3
                c3 = mss1._connectivity_list[2]
                self.assertIsInstance(
                    c3,
                    ihm.multi_state_scheme.Connectivity)
                self.assertEqual(c3._id, '3')
                self.assertIsInstance(c3.begin_state, ihm.model.State)
                self.assertEqual(c3.begin_state._id, '3')
                self.assertIsNone(c3.end_state)
                self.assertIsInstance(c3.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(c3.dataset_group._id, '12')
                self.assertEqual(c3.details, 'connectivity3')
                # Connectivity 4 - belongs to scheme 2
                mss2 = schemes[1]
                c4 = mss2._connectivity_list[0]
                self.assertIsInstance(
                    c4,
                    ihm.multi_state_scheme.Connectivity)
                self.assertEqual(c4._id, '4')
                self.assertIsInstance(c4.begin_state, ihm.model.State)
                self.assertEqual(c4.begin_state._id, '2')
                self.assertIsInstance(c4.end_state, ihm.model.State)
                self.assertEqual(c4.end_state._id, '1')
                self.assertIsInstance(c4.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(c4.dataset_group._id, '11')
                self.assertIsNone(c4.details)

    def test_kinetic_rate_handler(self):
        """Test KineticRateHandler"""
        mss_cif = """
loop_
_ihm_multi_state_scheme.id
_ihm_multi_state_scheme.name
_ihm_multi_state_scheme.details
1 'scheme1' 'details1'
2 'scheme2' 'details2'
#
#
loop_
_ihm_multi_state_scheme_connectivity.id
_ihm_multi_state_scheme_connectivity.scheme_id
_ihm_multi_state_scheme_connectivity.begin_state_id
_ihm_multi_state_scheme_connectivity.end_state_id
_ihm_multi_state_scheme_connectivity.dataset_group_id
_ihm_multi_state_scheme_connectivity.details
1 1 1 2 10 'connectivity1'
2 1 2 1 11 'connectivity2'
3 2 1 2 10 'connectivity1'
4 1 1 2 10 'connectivity3'
5 1 1 2 10 'connectivity4'
#
"""
        rate_cif = """
#
loop_
_ihm_kinetic_rate.id
_ihm_kinetic_rate.transition_rate_constant
_ihm_kinetic_rate.equilibrium_constant
_ihm_kinetic_rate.equilibrium_constant_determination_method
_ihm_kinetic_rate.equilibrium_constant_unit
_ihm_kinetic_rate.details
_ihm_kinetic_rate.scheme_connectivity_id
_ihm_kinetic_rate.dataset_group_id
_ihm_kinetic_rate.external_file_id
1 3.0 . . . 'rate1' 1 4 5
2 . 6.5 'equilibrium constant is determined from population' . 'rate2' 2  . .
3 7.0 . . . 'rate3' 3 8 9
4 . 8.5 'equilibrium constant is determined from kinetic rates, kAB/kBA'
 'unit' 'rate4' 4 . .
5 . 9.5 'equilibrium constant is determined from another method not listed' .
 'rate5' 5 . .
"""
        # Order of categories should not matter
        for cif in (mss_cif + rate_cif, rate_cif + mss_cif):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                schemes = s.multi_state_schemes
                mss1 = schemes[0]
                k1 = mss1._connectivity_list[0].kinetic_rate
                self.assertIsInstance(k1,
                                      ihm.multi_state_scheme.KineticRate)
                self.assertEqual(k1._id, '1')
                self.assertEqual(k1.transition_rate_constant, '3.0')
                self.assertIsNone(k1.equilibrium_constant)
                self.assertEqual(k1.details, 'rate1')
                self.assertIsInstance(k1.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(k1.dataset_group._id, '4')
                self.assertIsInstance(k1.external_file,
                                      ihm.location.Location)
                self.assertEqual(k1.external_file._id, '5')
                k2 = mss1._connectivity_list[1].kinetic_rate
                self.assertIsInstance(k2, ihm.multi_state_scheme.KineticRate)
                self.assertEqual(k2._id, '2')
                self.assertIsNone(k2.transition_rate_constant)
                self.assertIsInstance(
                    k2.equilibrium_constant,
                    ihm.multi_state_scheme.PopulationEquilibriumConstant)
                self.assertEqual(k2.equilibrium_constant.value, '6.5')
                self.assertEqual(
                    k2.equilibrium_constant.method,
                    'equilibrium constant is determined from population')
                self.assertIsNone(k2.equilibrium_constant.unit)
                self.assertEqual(k2.details, 'rate2')
                self.assertIsNone(k2.dataset_group)
                self.assertIsNone(k2.external_file)
                mss2 = schemes[1]
                k3 = mss2._connectivity_list[0].kinetic_rate
                self.assertIsInstance(k3, ihm.multi_state_scheme.KineticRate)
                self.assertEqual(k3._id, '3')
                self.assertEqual(k3.transition_rate_constant, '7.0')
                self.assertIsNone(k3.equilibrium_constant)
                self.assertEqual(k3.details, 'rate3')
                self.assertIsInstance(k3.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(k3.dataset_group._id, '8')
                self.assertIsInstance(k3.external_file, ihm.location.Location)
                self.assertEqual(k3.external_file._id, '9')
                k4 = mss1._connectivity_list[2].kinetic_rate
                self.assertIsInstance(k4, ihm.multi_state_scheme.KineticRate)
                self.assertEqual(k4._id, '4')
                self.assertIsNone(k4.transition_rate_constant)
                self.assertIsInstance(
                    k4.equilibrium_constant,
                    ihm.multi_state_scheme.KineticRateEquilibriumConstant)
                self.assertEqual(k4.equilibrium_constant.value, '8.5')
                self.assertEqual(
                    k4.equilibrium_constant.method,
                    'equilibrium constant is determined from kinetic '
                    'rates, kAB/kBA')
                self.assertEqual(k4.equilibrium_constant.unit, 'unit')
                self.assertEqual(k4.details, 'rate4')
                self.assertIsNone(k4.dataset_group)
                self.assertIsNone(k4.external_file)
                k5 = mss1._connectivity_list[3].kinetic_rate
                self.assertIsInstance(k5, ihm.multi_state_scheme.KineticRate)
                self.assertEqual(k5._id, '5')
                self.assertIsNone(k5.transition_rate_constant)
                self.assertIsInstance(
                    k5.equilibrium_constant,
                    ihm.multi_state_scheme.EquilibriumConstant)
                self.assertEqual(k5.equilibrium_constant.value, '9.5')
                self.assertEqual(
                    k5.equilibrium_constant.method,
                    'equilibrium constant is determined from another '
                    'method not listed')
                self.assertIsNone(k5.equilibrium_constant.unit)
                self.assertEqual(k5.details, 'rate5')
                self.assertIsNone(k5.dataset_group)
                self.assertIsNone(k5.external_file)

    def test_relaxation_time_handler(self):
        """Test RelaxationTimeHandler and
        RelaxationTimeMultiStateSchemeHandler"""
        mss_cif = """
loop_
_ihm_multi_state_scheme.id
_ihm_multi_state_scheme.name
_ihm_multi_state_scheme.details
1 'scheme1' 'details1'
#
#
loop_
_ihm_multi_state_scheme_connectivity.id
_ihm_multi_state_scheme_connectivity.scheme_id
_ihm_multi_state_scheme_connectivity.begin_state_id
_ihm_multi_state_scheme_connectivity.end_state_id
_ihm_multi_state_scheme_connectivity.dataset_group_id
_ihm_multi_state_scheme_connectivity.details
1 1 1 2 10 'connectivity1'
2 1 2 1 11 'connectivity2'
#
"""
        relaxation_time_cif = """
#
loop_
_ihm_relaxation_time.id
_ihm_relaxation_time.value
_ihm_relaxation_time.unit
_ihm_relaxation_time.amplitude
_ihm_relaxation_time.dataset_group_id
_ihm_relaxation_time.external_file_id
_ihm_relaxation_time.details
1 10.0 seconds 0.5 20 21 'relaxation_time1'
2 11.5 milliseconds . 22 23 'relaxation_time2'
3 12.0 seconds 0.4 24 25 'relaxation_time3'
#
#
loop_
_ihm_relaxation_time_multi_state_scheme.id
_ihm_relaxation_time_multi_state_scheme.relaxation_time_id
_ihm_relaxation_time_multi_state_scheme.scheme_id
_ihm_relaxation_time_multi_state_scheme.scheme_connectivity_id
_ihm_relaxation_time_multi_state_scheme.details
1 1 1 1 .
2 2 1 2 .
3 3 1 . .
"""
        # Order of categories should not matter
        for cif in (relaxation_time_cif + mss_cif,
                    mss_cif + relaxation_time_cif,
                    ):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                schemes = s.multi_state_schemes
                mss1 = schemes[0]
                self.assertEqual(len(mss1._connectivity_list), 2)
                r1 = mss1._connectivity_list[0].relaxation_time
                self.assertIsInstance(r1,
                                      ihm.multi_state_scheme.RelaxationTime)
                self.assertEqual(r1._id, '1')
                self.assertEqual(r1.value, '10.0')
                self.assertEqual(r1.unit, 'seconds')
                self.assertEqual(r1.amplitude, '0.5')
                self.assertIsInstance(r1.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(r1.dataset_group._id, '20')
                self.assertIsInstance(r1.external_file, ihm.location.Location)
                self.assertEqual(r1.external_file._id, '21')
                self.assertEqual(r1.details, 'relaxation_time1')
                r2 = mss1._connectivity_list[1].relaxation_time
                self.assertIsInstance(r2,
                                      ihm.multi_state_scheme.RelaxationTime)
                self.assertEqual(r2._id, '2')
                self.assertEqual(r2.value, '11.5')
                self.assertEqual(r2.unit, 'milliseconds')
                self.assertIsNone(r2.amplitude)
                self.assertIsInstance(r2.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(r2.dataset_group._id, '22')
                self.assertIsInstance(r2.external_file, ihm.location.Location)
                self.assertEqual(r2.external_file._id, '23')
                self.assertEqual(r2.details, 'relaxation_time2')
                # Relaxation time 3 is only assigned to a scheme,
                # not to a connectivity
                self.assertEqual(len(mss1._relaxation_time_list), 1)
                r3 = mss1._relaxation_time_list[0]
                self.assertIsInstance(r3,
                                      ihm.multi_state_scheme.RelaxationTime)
                self.assertEqual(r3._id, '3')
                self.assertEqual(r3.value, '12.0')
                self.assertEqual(r3.unit, 'seconds')
                self.assertEqual(r3.amplitude, '0.4')
                self.assertIsInstance(r3.dataset_group,
                                      ihm.dataset.DatasetGroup)
                self.assertEqual(r3.dataset_group._id, '24')
                self.assertIsInstance(r3.external_file, ihm.location.Location)
                self.assertEqual(r3.external_file._id, '25')
                self.assertEqual(r3.details, 'relaxation_time3')

    def test_flr_experiment_handler(self):
        """Test FLRExperimentHandler"""
        fh = StringIO("""
loop_
_flr_experiment.ordinal_id
_flr_experiment.id
_flr_experiment.instrument_id
_flr_experiment.inst_setting_id
_flr_experiment.exp_condition_id
_flr_experiment.sample_id
_flr_experiment.details
1 1 1 12 22 42 "exp 1"
2 1 1 2 2 2 .
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        experiment, = list(flr._collection_flr_experiment.values())
        self.assertIsInstance(experiment, ihm.flr.Experiment)
        self.assertIsInstance(experiment.instrument_list[0],
                              ihm.flr.Instrument)
        self.assertIsInstance(experiment.inst_setting_list[0],
                              ihm.flr.InstSetting)
        self.assertIsInstance(experiment.exp_condition_list[0],
                              ihm.flr.ExpCondition)
        self.assertIsInstance(experiment.sample_list[0], ihm.flr.Sample)
        self.assertEqual([i._id for i in experiment.instrument_list],
                         ['1', '1'])
        self.assertEqual([i._id for i in experiment.inst_setting_list],
                         ['12', '2'])
        self.assertEqual([i._id for i in experiment.exp_condition_list],
                         ['22', '2'])
        self.assertEqual([i._id for i in experiment.sample_list],
                         ['42', '2'])
        self.assertEqual(experiment.details_list, ["exp 1", None])

    def test_flr_inst_setting_handler(self):
        """Test FLRInstSettingHandler"""
        fh = StringIO("""
loop_
_flr_inst_setting.id
_flr_inst_setting.details
1 My_Inst_setting_1
2 .
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_inst_setting.keys()),
                         ['1', '2'])
        is1 = flr._collection_flr_inst_setting['1']
        self.assertIsInstance(is1, ihm.flr.InstSetting)
        self.assertEqual(is1.details, 'My_Inst_setting_1')
        is2 = flr._collection_flr_inst_setting['2']
        self.assertIsInstance(is2, ihm.flr.InstSetting)
        self.assertIsNone(is2.details)

    def test_flr_exp_condition_handler(self):
        """Test FLRExpConditionHandler"""
        fh = StringIO("""
loop_
_flr_exp_condition.id
_flr_exp_condition.details
1 My_Exp_condition_1
2 .
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_exp_condition.keys()),
                         ['1', '2'])
        ec1 = flr._collection_flr_exp_condition['1']
        self.assertIsInstance(ec1, ihm.flr.ExpCondition)
        self.assertEqual(ec1.details, 'My_Exp_condition_1')
        ec2 = flr._collection_flr_exp_condition['2']
        self.assertIsInstance(ec2, ihm.flr.ExpCondition)
        self.assertIsNone(ec2.details)

    def test_flr_instrument_handler(self):
        """Test FLRInstrumentHandler"""
        fh = StringIO("""
loop_
_flr_instrument.id
_flr_instrument.details
1 test
2 .
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_instrument.keys()),
                         ['1', '2'])
        i1 = flr._collection_flr_instrument['1']
        self.assertIsInstance(i1, ihm.flr.Instrument)
        self.assertEqual(i1.details, 'test')
        i2 = flr._collection_flr_instrument['2']
        self.assertIsInstance(i2, ihm.flr.Instrument)
        self.assertIsNone(i2.details)

    def test_flr_entity_assembly_handler(self):
        """Test FLREntityAssemblyHandler"""
        fh = StringIO("""
loop_
_flr_entity_assembly.ordinal_id
_flr_entity_assembly.assembly_id
_flr_entity_assembly.entity_id
_flr_entity_assembly.num_copies
_flr_entity_assembly.entity_description
1 1 1 1 Entity_1
2 1 2 4 Entity_2
""")
        s, = ihm.reader.read(fh)
        self.assertEqual(len(s.entities), 2)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_entity_assembly.keys()),
                         ['1'])
        a1 = flr._collection_flr_entity_assembly['1']
        self.assertIsInstance(a1, ihm.flr.EntityAssembly)
        self.assertEqual([x._id for x in a1.entity_list], ['1', '2'])
        self.assertEqual(a1.num_copies_list, [1, 4])

    def test_flr_sample_condition_handler(self):
        """Test FLRSampleConditionHandler"""
        fh = StringIO("""
loop_
_flr_sample_condition.id
_flr_sample_condition.details
1 test
2 .
#
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_sample_condition.keys()),
                         ['1', '2'])
        s1 = flr._collection_flr_sample_condition['1']
        self.assertIsInstance(s1, ihm.flr.SampleCondition)
        self.assertEqual(s1.details, 'test')
        s2 = flr._collection_flr_sample_condition['2']
        self.assertIsInstance(s2, ihm.flr.SampleCondition)
        self.assertIsNone(s2.details)

    def test_flr_sample_handler(self):
        """Test FLRSampleHandler"""
        fh = StringIO("""
loop_
_flr_sample.id
_flr_sample.entity_assembly_id
_flr_sample.num_of_probes
_flr_sample.sample_condition_id
_flr_sample.sample_description
_flr_sample.sample_details
_flr_sample.solvent_phase
1 1 2 1 Sample_1 'Details sample 1' liquid
2 1 4 2 Sample_2 'Details sample 2' vitrified
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_sample.keys()),
                         ['1', '2'])
        s1 = flr._collection_flr_sample['1']
        self.assertIsInstance(s1, ihm.flr.Sample)
        self.assertEqual(s1.entity_assembly._id, '1')
        self.assertEqual(s1.num_of_probes, 2)
        self.assertEqual(s1.condition._id, '1')
        self.assertEqual(s1.description, 'Sample_1')
        self.assertEqual(s1.details, 'Details sample 1')
        self.assertEqual(s1.solvent_phase, 'liquid')

    def test_flr_probe_list_handler(self):
        """Test FLRProbeListHandler"""
        fh = StringIO("""
loop_
_flr_probe_list.probe_id
_flr_probe_list.chromophore_name
_flr_probe_list.reactive_probe_flag
_flr_probe_list.reactive_probe_name
_flr_probe_list.probe_origin
_flr_probe_list.probe_link_type
1 Donor1 NO . extrinsic covalent
2 Acceptor2 YES 'Acceptor1 reactive' extrinsic covalent
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_probe.keys()),
                         ['1', '2'])
        p1 = flr._collection_flr_probe['1'].probe_list_entry
        self.assertIsInstance(p1, ihm.flr.ProbeList)
        self.assertEqual(p1.chromophore_name, 'Donor1')
        self.assertEqual(p1.reactive_probe_flag, False)
        self.assertIsNone(p1.reactive_probe_name)
        self.assertEqual(p1.probe_origin, 'extrinsic')
        self.assertEqual(p1.probe_link_type, 'covalent')
        p2 = flr._collection_flr_probe['2'].probe_list_entry
        self.assertIsInstance(p2, ihm.flr.ProbeList)
        self.assertEqual(p2.chromophore_name, 'Acceptor2')
        self.assertEqual(p2.reactive_probe_flag, True)
        self.assertEqual(p2.reactive_probe_name, 'Acceptor1 reactive')
        self.assertEqual(p2.probe_origin, 'extrinsic')
        self.assertEqual(p2.probe_link_type, 'covalent')

    def test_flr_probe_descriptor_handler(self):
        """Test FLRProbeDescriptorHandler"""
        fh = StringIO("""
loop_
_flr_probe_descriptor.probe_id
_flr_probe_descriptor.reactive_probe_chem_descriptor_id
_flr_probe_descriptor.chromophore_chem_descriptor_id
_flr_probe_descriptor.chromophore_center_atom
1 . 1 CB
2 3 2 CB
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_probe.keys()),
                         ['1', '2'])
        p1 = flr._collection_flr_probe['1'].probe_descriptor
        self.assertIsInstance(p1, ihm.flr.ProbeDescriptor)
        self.assertIsNone(p1.reactive_probe_chem_descriptor)
        self.assertIsInstance(p1.chromophore_chem_descriptor,
                              ihm.ChemDescriptor)
        self.assertEqual(p1.chromophore_chem_descriptor._id, '1')
        self.assertEqual(p1.chromophore_center_atom, 'CB')

        p2 = flr._collection_flr_probe['2'].probe_descriptor
        self.assertIsInstance(p2, ihm.flr.ProbeDescriptor)
        self.assertIsInstance(p2.reactive_probe_chem_descriptor,
                              ihm.ChemDescriptor)
        self.assertEqual(p2.reactive_probe_chem_descriptor._id, '3')
        self.assertIsInstance(p2.chromophore_chem_descriptor,
                              ihm.ChemDescriptor)
        self.assertEqual(p2.chromophore_chem_descriptor._id, '2')
        self.assertEqual(p2.chromophore_center_atom, 'CB')

    def test_flr_sample_probe_details_handler(self):
        """Test FLRSampleProbeDetailsHandler"""
        fh = StringIO("""
loop_
_flr_sample_probe_details.sample_probe_id
_flr_sample_probe_details.sample_id
_flr_sample_probe_details.probe_id
_flr_sample_probe_details.fluorophore_type
_flr_sample_probe_details.description
_flr_sample_probe_details.poly_probe_position_id
1 42 99 donor 'Donor in position1-position3' 34
2 1 2 acceptor 'Acceptor in position1-position3' 2
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_sample_probe_details.keys()),
            ['1', '2'])
        p1 = flr._collection_flr_sample_probe_details['1']
        self.assertIsInstance(p1, ihm.flr.SampleProbeDetails)
        self.assertIsInstance(p1.sample, ihm.flr.Sample)
        self.assertEqual(p1.sample._id, '42')
        self.assertIsInstance(p1.probe, ihm.flr.Probe)
        self.assertEqual(p1.probe._id, '99')
        self.assertEqual(p1.fluorophore_type, 'donor')
        self.assertEqual(p1.description, 'Donor in position1-position3')
        self.assertIsInstance(p1.poly_probe_position,
                              ihm.flr.PolyProbePosition)
        self.assertEqual(p1.poly_probe_position._id, '34')

    def test_flr_poly_probe_position_handler(self):
        """Test FLRPolyProbePositionHandler"""
        fh = StringIO("""
loop_
_flr_poly_probe_position.id
_flr_poly_probe_position.entity_id
_flr_poly_probe_position.entity_description
_flr_poly_probe_position.asym_id
_flr_poly_probe_position.seq_id
_flr_poly_probe_position.comp_id
_flr_poly_probe_position.atom_id
_flr_poly_probe_position.mutation_flag
_flr_poly_probe_position.modification_flag
_flr_poly_probe_position.auth_name
1 1 Entity_1 . 1 ALA . NO YES Position_1
2 2 Entity_2 C 10 CYS CB NO YES Position_3
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(len(s.entities), 2)
        self.assertEqual(
            sorted(flr._collection_flr_poly_probe_position.keys()), ['1', '2'])
        p1 = flr._collection_flr_poly_probe_position['1']
        self.assertIsInstance(p1, ihm.flr.PolyProbePosition)
        self.assertIsInstance(p1.resatom, ihm.Residue)
        self.assertEqual(p1.resatom.seq_id, 1)
        self.assertEqual(p1.resatom.entity._id, '1')
        self.assertIsNone(p1.resatom.asym)

        p2 = flr._collection_flr_poly_probe_position['2']
        self.assertIsInstance(p2, ihm.flr.PolyProbePosition)
        self.assertIsInstance(p2.resatom, ihm.Atom)
        self.assertIsInstance(p2.resatom.asym, ihm.AsymUnit)
        self.assertEqual(p2.resatom.id, 'CB')
        self.assertEqual(p2.resatom.seq_id, 10)
        self.assertEqual(p2.resatom.entity._id, '2')
        self.assertEqual(p2.resatom.asym.entity._id, '2')
        self.assertEqual(p2.resatom.asym.id, 'C')

    def test_flr_poly_probe_position_modified_handler(self):
        """Test FLRPolyProbePositionModifiedHandler"""
        fh = StringIO("""
loop_
_flr_poly_probe_position_modified.id
_flr_poly_probe_position_modified.chem_descriptor_id
_flr_poly_probe_position_modified.atom_id
1 4 .
2 4 CB
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_poly_probe_position.keys()), ['1', '2'])
        p1 = flr._collection_flr_poly_probe_position['1']
        self.assertIsInstance(p1.modified_chem_descriptor,
                              ihm.ChemDescriptor)
        self.assertEqual(p1.modified_chem_descriptor._id, '4')

        p2 = flr._collection_flr_poly_probe_position['2']
        self.assertIsInstance(p2.modified_chem_descriptor,
                              ihm.ChemDescriptor)
        self.assertEqual(p2.modified_chem_descriptor._id, '4')

    def test_flr_poly_probe_position_mutated_handler(self):
        """Test FLRPolyProbePositionMutatedHandler"""
        fh = StringIO("""
loop_
_flr_poly_probe_position_mutated.id
_flr_poly_probe_position_mutated.chem_comp_id
_flr_poly_probe_position_mutated.atom_id
1 Ala .
2 Cys CB
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_poly_probe_position.keys()), ['1', '2'])
        p1 = flr._collection_flr_poly_probe_position['1']
        self.assertIsInstance(p1.mutated_chem_comp_id,
                              ihm.ChemComp)
        self.assertEqual(p1.mutated_chem_comp_id.id, 'Ala')

        p2 = flr._collection_flr_poly_probe_position['2']
        self.assertIsInstance(p2.mutated_chem_comp_id,
                              ihm.ChemComp)
        self.assertEqual(p2.mutated_chem_comp_id.id, 'Cys')

    def test_flr_poly_probe_conjugate_handler(self):
        """Test FLRPolyProbeConjugateHandler"""
        fh = StringIO("""
loop_
_flr_poly_probe_conjugate.id
_flr_poly_probe_conjugate.sample_probe_id
_flr_poly_probe_conjugate.chem_descriptor_id
_flr_poly_probe_conjugate.ambiguous_stoichiometry_flag
_flr_poly_probe_conjugate.probe_stoichiometry
1 1 5 NO .
2 2 5 YES 2
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_poly_probe_conjugate.keys()),
            ['1', '2'])
        p1, p2 = s.flr_data[0].poly_probe_conjugates
        self.assertIsInstance(p1.sample_probe,
                              ihm.flr.SampleProbeDetails)
        self.assertEqual(p1.sample_probe._id, '1')
        self.assertIsInstance(p1.chem_descriptor, ihm.ChemDescriptor)
        self.assertEqual(p1.chem_descriptor._id, '5')
        self.assertEqual(p1.ambiguous_stoichiometry, False)
        self.assertIsNone(p1.probe_stoichiometry)

        self.assertIsInstance(p2.sample_probe,
                              ihm.flr.SampleProbeDetails)
        self.assertEqual(p2.sample_probe._id, '2')
        self.assertIsInstance(p2.chem_descriptor, ihm.ChemDescriptor)
        self.assertEqual(p2.chem_descriptor._id, '5')
        self.assertEqual(p2.ambiguous_stoichiometry, True)
        self.assertAlmostEqual(p2.probe_stoichiometry, 2.0, delta=1.0)

    def test_flr_fret_forster_radius_handler(self):
        """Test FLRFretForsterRadiusHandler"""
        fh = StringIO("""
loop_
_flr_fret_forster_radius.id
_flr_fret_forster_radius.donor_probe_id
_flr_fret_forster_radius.acceptor_probe_id
_flr_fret_forster_radius.forster_radius
_flr_fret_forster_radius.reduced_forster_radius
1 9 10 252.000 53.200
2 11 12 52.000 .
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_fret_forster_radius.keys()), ['1', '2'])
        r1 = flr._collection_flr_fret_forster_radius['1']
        self.assertIsInstance(r1.donor_probe, ihm.flr.Probe)
        self.assertEqual(r1.donor_probe._id, '9')
        self.assertIsInstance(r1.acceptor_probe, ihm.flr.Probe)
        self.assertEqual(r1.acceptor_probe._id, '10')
        self.assertAlmostEqual(r1.forster_radius, 252.000, delta=0.1)
        self.assertAlmostEqual(r1.reduced_forster_radius, 53.200, delta=0.1)

        r2 = flr._collection_flr_fret_forster_radius['2']
        self.assertIsNone(r2.reduced_forster_radius)

    def test_flr_fret_calibration_parameters_handler(self):
        """Test FLRFretCalibrationParametersHandler"""
        fh = StringIO("""
loop_
_flr_fret_calibration_parameters.id
_flr_fret_calibration_parameters.phi_acceptor
_flr_fret_calibration_parameters.alpha
_flr_fret_calibration_parameters.alpha_sd
_flr_fret_calibration_parameters.gG_gR_ratio
_flr_fret_calibration_parameters.beta
_flr_fret_calibration_parameters.gamma
_flr_fret_calibration_parameters.delta
_flr_fret_calibration_parameters.a_b
1 0.350 2.400 0.1 0.400 1.0 2.0 3.0 0.800
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        p1 = flr._collection_flr_fret_calibration_parameters['1']
        self.assertAlmostEqual(p1.phi_acceptor, 0.350, delta=0.01)
        self.assertAlmostEqual(p1.alpha, 2.400, delta=0.1)
        self.assertAlmostEqual(p1.alpha_sd, 0.1, delta=0.1)
        self.assertAlmostEqual(p1.gg_gr_ratio, 0.4, delta=0.1)
        self.assertAlmostEqual(p1.beta, 1.0, delta=0.1)
        self.assertAlmostEqual(p1.gamma, 2.0, delta=0.1)
        self.assertAlmostEqual(p1.delta, 3.0, delta=0.1)
        self.assertAlmostEqual(p1.a_b, 0.8, delta=0.1)

    def test_flr_fret_analysis_handler(self):
        """Test FLRFretAnalysisHandler"""
        fh = StringIO("""
loop_
_flr_fret_analysis.id
_flr_fret_analysis.experiment_id
_flr_fret_analysis.type
_flr_fret_analysis.sample_probe_id_1
_flr_fret_analysis.sample_probe_id_2
_flr_fret_analysis.forster_radius_id
_flr_fret_analysis.dataset_list_id
_flr_fret_analysis.external_file_id
_flr_fret_analysis.software_id
1 8 intensity-based 9 2 11 18 42 99
2 13 lifetime-based 24 5 19 32 81 98
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        a = flr._collection_flr_fret_analysis['1']
        self.assertIsInstance(a.experiment, ihm.flr.Experiment)
        self.assertEqual(a.experiment._id, '8')
        self.assertIsInstance(a.sample_probe_1, ihm.flr.SampleProbeDetails)
        self.assertEqual(a.sample_probe_1._id, '9')
        self.assertIsInstance(a.sample_probe_2, ihm.flr.SampleProbeDetails)
        self.assertEqual(a.sample_probe_2._id, '2')
        self.assertIsInstance(a.forster_radius, ihm.flr.FRETForsterRadius)
        self.assertEqual(a.forster_radius._id, '11')
        self.assertEqual(a.type, 'intensity-based')
        self.assertIsInstance(a.dataset, ihm.dataset.Dataset)
        self.assertEqual(a.dataset._id, '18')
        self.assertIsInstance(a.external_file, ihm.location.Location)
        self.assertEqual(a.external_file._id, '42')
        self.assertIsInstance(a.software, ihm.Software)
        self.assertEqual(a.software._id, '99')
        b = flr._collection_flr_fret_analysis['2']
        self.assertIsInstance(b.experiment, ihm.flr.Experiment)
        self.assertEqual(b.experiment._id, '13')
        self.assertIsInstance(b.sample_probe_1, ihm.flr.SampleProbeDetails)
        self.assertEqual(b.sample_probe_1._id, '24')
        self.assertIsInstance(b.sample_probe_2, ihm.flr.SampleProbeDetails)
        self.assertEqual(b.sample_probe_2._id, '5')
        self.assertIsInstance(b.forster_radius, ihm.flr.FRETForsterRadius)
        self.assertEqual(b.forster_radius._id, '19')
        self.assertEqual(b.type, 'lifetime-based')
        self.assertIsInstance(b.dataset, ihm.dataset.Dataset)
        self.assertEqual(b.dataset._id, '32')
        self.assertIsInstance(b.external_file, ihm.location.Location)
        self.assertEqual(b.external_file._id, '81')
        self.assertIsInstance(b.software, ihm.Software)
        self.assertEqual(b.software._id, '98')

    def test_flr_fret_analysis_intensity_handler(self):
        """Test FLRFretAnalysisIntensityHandler"""
        fh = StringIO("""
loop_
_flr_fret_analysis_intensity.ordinal_id
_flr_fret_analysis_intensity.analysis_id
_flr_fret_analysis_intensity.calibration_parameters_id
_flr_fret_analysis_intensity.donor_only_fraction
_flr_fret_analysis_intensity.chi_square_reduced
_flr_fret_analysis_intensity.method_name
_flr_fret_analysis_intensity.details
2 5 3 0.200 1.400 PDA Details
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        a = flr._collection_flr_fret_analysis['5']
        self.assertEqual(a.type, 'intensity-based')
        self.assertIsInstance(a.calibration_parameters,
                              ihm.flr.FRETCalibrationParameters)
        self.assertEqual(a.calibration_parameters._id, '3')
        self.assertAlmostEqual(a.donor_only_fraction, 0.2, delta=0.1)
        self.assertAlmostEqual(a.chi_square_reduced, 1.4, delta=0.1)
        self.assertEqual(a.method_name, 'PDA')
        self.assertEqual(a.details, 'Details')

    def test_flr_fret_analysis_lifetime_handler(self):
        """Test FLRFretAnalysisLifetimeHandler"""
        fh = StringIO("""
loop_
_flr_fret_analysis_lifetime.ordinal_id
_flr_fret_analysis_lifetime.analysis_id
_flr_fret_analysis_lifetime.reference_measurement_group_id
_flr_fret_analysis_lifetime.lifetime_fit_model_id
_flr_fret_analysis_lifetime.donor_only_fraction
_flr_fret_analysis_lifetime.chi_square_reduced
_flr_fret_analysis_lifetime.method_name
_flr_fret_analysis_lifetime.details
4 2 19 23 0.300 1.500 'Lifetime fit' 'Details on lifetime fit'
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        a = flr._collection_flr_fret_analysis['2']
        self.assertEqual(a.type, 'lifetime-based')
        self.assertIsInstance(a.ref_measurement_group,
                              ihm.flr.RefMeasurementGroup)
        self.assertEqual(a.ref_measurement_group._id, '19')
        self.assertIsInstance(a.lifetime_fit_model, ihm.flr.LifetimeFitModel)
        self.assertEqual(a.lifetime_fit_model._id, '23')
        self.assertAlmostEqual(a.donor_only_fraction, 0.3, delta=0.1)
        self.assertAlmostEqual(a.chi_square_reduced, 1.5, delta=0.1)
        self.assertEqual(a.method_name, 'Lifetime fit')
        self.assertEqual(a.details, 'Details on lifetime fit')

    def test_flr_lifetime_fit_model_handler(self):
        """Test FLRLifetimeFitModelHandler"""
        fh = StringIO("""
loop_
_flr_lifetime_fit_model.id
_flr_lifetime_fit_model.name
_flr_lifetime_fit_model.description
_flr_lifetime_fit_model.external_file_id
_flr_lifetime_fit_model.citation_id
1 'FitModel 15' 'Description of the fit model' 3 8
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        f = flr._collection_flr_lifetime_fit_model['1']
        self.assertEqual(f.name, 'FitModel 15')
        self.assertEqual(f.description, 'Description of the fit model')
        self.assertIsInstance(f.external_file, ihm.location.Location)
        self.assertEqual(f.external_file._id, '3')
        self.assertIsInstance(f.citation, ihm.Citation)
        self.assertEqual(f.citation._id, '8')

    def test_flr_ref_measurement_handler(self):
        """Test FLRRefMeasurementHandler"""
        fh = StringIO("""
loop_
_flr_reference_measurement.id
_flr_reference_measurement.reference_sample_probe_id
_flr_reference_measurement.num_species
_flr_reference_measurement.details
4 9 2 Details1
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        r = flr._collection_flr_ref_measurement['4']
        self.assertIsInstance(r.ref_sample_probe, ihm.flr.SampleProbeDetails)
        self.assertEqual(r.ref_sample_probe._id, '9')
        self.assertEqual(r.details, 'Details1')
        # num_species is set automatically when adding lifetimes to the object
        self.assertEqual(r.num_species, 0)
        r.add_lifetime('1')
        r.add_lifetime('2')
        self.assertEqual(r.num_species, 2)

    def test_flr_ref_measurement_group_handler(self):
        """Test FLRRefMeasurementGroupHandler"""
        fh = StringIO("""
loop_
_flr_reference_measurement_group.id
_flr_reference_measurement_group.num_measurements
_flr_reference_measurement_group.details
5 3 Details
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        r = flr._collection_flr_ref_measurement_group['5']
        self.assertEqual(r.details, 'Details')
        # num_measurements is set automatically when adding measurements
        # to the object
        self.assertEqual(r.num_measurements, 0)
        r.add_ref_measurement('1')
        self.assertEqual(r.num_measurements, 1)
        r.add_ref_measurement('2')
        self.assertEqual(r.num_measurements, 2)

    def test_flr_ref_measurement_group_link_handler(self):
        """Test FLRRefMeasurementGroupLinkHandler"""
        fh = StringIO("""
loop_
_flr_reference_measurement_group_link.group_id
_flr_reference_measurement_group_link.reference_measurement_id
3 12
3 25
5 19
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        g1 = flr._collection_flr_ref_measurement_group['3']
        self.assertEqual(g1.num_measurements, 2)
        self.assertIsInstance(g1.ref_measurement_list[0],
                              ihm.flr.RefMeasurement)
        self.assertEqual(g1.ref_measurement_list[0]._id, '12')
        self.assertIsInstance(g1.ref_measurement_list[1],
                              ihm.flr.RefMeasurement)
        self.assertEqual(g1.ref_measurement_list[1]._id, '25')
        g2 = flr._collection_flr_ref_measurement_group['5']
        self.assertEqual(g2.num_measurements, 1)
        self.assertIsInstance(g2.ref_measurement_list[0],
                              ihm.flr.RefMeasurement)
        self.assertEqual(g2.ref_measurement_list[0]._id, '19')

    def test_flr_ref_measurement_lifetime_handler(self):
        """Test FLRRefMeasurementLifetimeHandler"""
        fh = StringIO("""
loop_
_flr_reference_measurement_lifetime.ordinal_id
_flr_reference_measurement_lifetime.reference_measurement_id
_flr_reference_measurement_lifetime.species_name
_flr_reference_measurement_lifetime.species_fraction
_flr_reference_measurement_lifetime.lifetime
1 15 species1 0.300 4.100
2 15 species2 0.700 2.100
3 12 species1 1.000 3.800
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        # Check the lifetime objects themselves
        f1 = flr._collection_flr_ref_measurement_lifetime['1']
        self.assertEqual(f1.species_name, 'species1')
        self.assertAlmostEqual(f1.species_fraction, 0.3, delta=0.1)
        self.assertAlmostEqual(f1.lifetime, 4.1, delta=0.1)
        f2 = flr._collection_flr_ref_measurement_lifetime['2']
        self.assertEqual(f2.species_name, 'species2')
        self.assertAlmostEqual(f2.species_fraction, 0.7, delta=0.1)
        self.assertAlmostEqual(f2.lifetime, 2.1, delta=0.1)
        f3 = flr._collection_flr_ref_measurement_lifetime['3']
        self.assertEqual(f3.species_name, 'species1')
        self.assertAlmostEqual(f3.species_fraction, 1.0, delta=0.1)
        self.assertAlmostEqual(f3.lifetime, 3.8, delta=0.1)
        # And check the respective reference measurement objects
        r1 = flr._collection_flr_ref_measurement['15']
        self.assertIsInstance(r1.list_of_lifetimes[0],
                              ihm.flr.RefMeasurementLifetime)
        self.assertEqual(r1.list_of_lifetimes[0].species_name, 'species1')
        self.assertAlmostEqual(r1.list_of_lifetimes[0].species_fraction,
                               0.3, delta=0.1)
        self.assertAlmostEqual(r1.list_of_lifetimes[0].lifetime, 4.1,
                               delta=0.1)
        self.assertIsInstance(r1.list_of_lifetimes[1],
                              ihm.flr.RefMeasurementLifetime)
        self.assertEqual(r1.list_of_lifetimes[1].species_name, 'species2')
        self.assertAlmostEqual(r1.list_of_lifetimes[1].species_fraction,
                               0.7, delta=0.1)
        self.assertAlmostEqual(r1.list_of_lifetimes[1].lifetime, 2.1,
                               delta=0.1)
        r2 = flr._collection_flr_ref_measurement['12']
        self.assertIsInstance(r2.list_of_lifetimes[0],
                              ihm.flr.RefMeasurementLifetime)
        self.assertEqual(r2.list_of_lifetimes[0].species_name, 'species1')
        self.assertAlmostEqual(r2.list_of_lifetimes[0].species_fraction,
                               1.0, delta=0.1)
        self.assertAlmostEqual(r2.list_of_lifetimes[0].lifetime, 3.8,
                               delta=0.1)

    def test_flr_peak_assignment_handler(self):
        """Test FLRPeakAssignmentHandler"""
        fh = StringIO("""
loop_
_flr_peak_assignment.id
_flr_peak_assignment.method_name
_flr_peak_assignment.details
1 Population 'Test details'
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        a = flr._collection_flr_peak_assignment['1']
        self.assertEqual(a.method_name, 'Population')
        self.assertEqual(a.details, 'Test details')

    def test_flr_fret_distance_restraint_handler(self):
        """Test FLRFretDistanceRestraintHandler"""
        fh = StringIO("""
loop_
_flr_fret_distance_restraint.ordinal_id
_flr_fret_distance_restraint.id
_flr_fret_distance_restraint.group_id
_flr_fret_distance_restraint.sample_probe_id_1
_flr_fret_distance_restraint.sample_probe_id_2
_flr_fret_distance_restraint.state_id
_flr_fret_distance_restraint.analysis_id
_flr_fret_distance_restraint.distance
_flr_fret_distance_restraint.distance_error_plus
_flr_fret_distance_restraint.distance_error_minus
_flr_fret_distance_restraint.distance_type
_flr_fret_distance_restraint.population_fraction
_flr_fret_distance_restraint.peak_assignment_id
1 1 1 1 2 9 19 53.500 2.500 2.300 <R_DA>_E 0.800 42
2 2 1 3 4 8 18 49.000 2.000 2.100 <R_DA>_E 0.800 42
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_fret_distance_restraint_group.keys()),
            ['1'])
        self.assertEqual(
            sorted(flr._collection_flr_fret_distance_restraint.keys()),
            ['1', '2'])
        rg1, = flr.distance_restraint_groups
        r1, r2 = rg1.get_info()
        self.assertIsInstance(r1.sample_probe_1, ihm.flr.SampleProbeDetails)
        self.assertEqual(r1.sample_probe_1._id, '1')
        self.assertIsInstance(r1.sample_probe_2, ihm.flr.SampleProbeDetails)
        self.assertEqual(r1.sample_probe_2._id, '2')
        self.assertIsInstance(r1.state, ihm.model.State)
        self.assertEqual(r1.state._id, '9')
        self.assertIsInstance(r1.analysis, ihm.flr.FRETAnalysis)
        self.assertEqual(r1.analysis._id, '19')
        self.assertAlmostEqual(r1.distance, 53.500, delta=0.1)
        self.assertAlmostEqual(r1.distance_error_plus, 2.500, delta=0.1)
        self.assertAlmostEqual(r1.distance_error_minus, 2.300, delta=0.1)
        self.assertEqual(r1.distance_type, "<R_DA>_E")
        self.assertAlmostEqual(r1.population_fraction, 0.800, delta=0.1)
        self.assertIsInstance(r1.peak_assignment, ihm.flr.PeakAssignment)
        self.assertEqual(r1.peak_assignment._id, '42')

        self.assertEqual(rg1.distance_restraint_list, [r1, r2])

    def test_flr_fret_model_quality_handler(self):
        """Test FLRFretModelQualityHandler"""
        fh = StringIO("""
loop_
_flr_fret_model_quality.model_id
_flr_fret_model_quality.chi_square_reduced
_flr_fret_model_quality.dataset_group_id
_flr_fret_model_quality.method
_flr_fret_model_quality.details
1 1.300 42 foo bar
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_fret_model_quality.keys()),
                         ['1'])
        q1, = flr.fret_model_qualities
        self.assertIsInstance(q1.model, ihm.model.Model)
        self.assertEqual(q1.model._id, '1')
        self.assertAlmostEqual(q1.chi_square_reduced, 1.300, delta=0.1)
        self.assertIsInstance(q1.dataset_group, ihm.dataset.DatasetGroup)
        self.assertEqual(q1.dataset_group._id, '42')
        self.assertEqual(q1.method, 'foo')
        self.assertEqual(q1.details, 'bar')

    def test_flr_fret_model_distance_handler(self):
        """Test FLRFretModelDistanceHandler"""
        fh = StringIO("""
loop_
_flr_fret_model_distance.id
_flr_fret_model_distance.restraint_id
_flr_fret_model_distance.model_id
_flr_fret_model_distance.distance
_flr_fret_model_distance.distance_deviation
1 42 34 52.000 1.500
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_fret_model_distance.keys()), ['1'])
        d1, = flr.fret_model_distances
        self.assertIsInstance(d1.restraint, ihm.flr.FRETDistanceRestraint)
        self.assertEqual(d1.restraint._id, '42')
        self.assertIsInstance(d1.model, ihm.model.Model)
        self.assertEqual(d1.model._id, '34')
        self.assertAlmostEqual(d1.distance, 52.000, delta=0.1)
        self.assertAlmostEqual(d1.distance_deviation, 1.500, delta=0.1)

    def test_flr_fps_global_parameter_handler(self):
        """Test FLRFPSGlobalParameterHandler"""
        fh = StringIO("""
loop_
_flr_FPS_global_parameter.id
_flr_FPS_global_parameter.forster_radius_value
_flr_FPS_global_parameter.conversion_function_polynom_order
_flr_FPS_global_parameter.repetition
_flr_FPS_global_parameter.AV_grid_rel
_flr_FPS_global_parameter.AV_min_grid_A
_flr_FPS_global_parameter.AV_allowed_sphere
_flr_FPS_global_parameter.AV_search_nodes
_flr_FPS_global_parameter.AV_E_samples_k
_flr_FPS_global_parameter.sim_viscosity_adjustment
_flr_FPS_global_parameter.sim_dt_adjustment
_flr_FPS_global_parameter.sim_max_iter_k
_flr_FPS_global_parameter.sim_max_force
_flr_FPS_global_parameter.sim_clash_tolerance_A
_flr_FPS_global_parameter.sim_reciprocal_kT
_flr_FPS_global_parameter.sim_clash_potential
_flr_FPS_global_parameter.convergence_E
_flr_FPS_global_parameter.convergence_K
_flr_FPS_global_parameter.convergence_F
_flr_FPS_global_parameter.convergence_T
1 52 3 1000 0.200 0.400 0.500 3 200 1 1 200 400 1 10 ^2 100 0.001 0.001 0.002
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_fps_global_parameters.keys()), ['1'])
        p1 = flr._collection_flr_fps_global_parameters['1']
        self.assertAlmostEqual(p1.forster_radius, 52.000, delta=0.1)
        self.assertEqual(p1.conversion_function_polynom_order, 3)
        self.assertEqual(p1.repetition, 1000)
        self.assertAlmostEqual(p1.av_grid_rel, 0.200, delta=0.1)
        self.assertAlmostEqual(p1.av_min_grid_a, 0.400, delta=0.1)
        self.assertAlmostEqual(p1.av_allowed_sphere, 0.500, delta=0.1)
        self.assertEqual(p1.av_search_nodes, 3)
        self.assertAlmostEqual(p1.av_e_samples_k, 200, delta=0.1)
        self.assertAlmostEqual(p1.sim_viscosity_adjustment, 1, delta=0.1)
        self.assertAlmostEqual(p1.sim_dt_adjustment, 1, delta=0.1)
        self.assertEqual(p1.sim_max_iter_k, 200)
        self.assertAlmostEqual(p1.sim_max_force, 400, delta=0.1)
        self.assertAlmostEqual(p1.sim_clash_tolerance_a, 1, delta=0.1)
        self.assertAlmostEqual(p1.sim_reciprocal_kt, 10, delta=0.1)
        self.assertEqual(p1.sim_clash_potential, "^2")
        self.assertAlmostEqual(p1.convergence_e, 100, delta=0.1)
        self.assertAlmostEqual(p1.convergence_k, 0.001, delta=0.001)
        self.assertAlmostEqual(p1.convergence_f, 0.001, delta=0.001)
        self.assertAlmostEqual(p1.convergence_t, 0.002, delta=0.001)

    def test_flr_fps_modeling_handler(self):
        """Test FLRFPSModelingHandler"""
        fh = StringIO("""
loop_
_flr_FPS_modeling.id
_flr_FPS_modeling.ihm_modeling_protocol_ordinal_id
_flr_FPS_modeling.restraint_group_id
_flr_FPS_modeling.global_parameter_id
_flr_FPS_modeling.probe_modeling_method
_flr_FPS_modeling.details
1 8 9 10 AV3 "test details"
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_fps_modeling.keys()),
                         ['1'])
        m1 = flr._collection_flr_fps_modeling['1']
        self.assertIsInstance(m1.protocol, ihm.protocol.Protocol)
        self.assertEqual(m1.protocol._id, '8')
        self.assertIsInstance(m1.restraint_group,
                              ihm.flr.FRETDistanceRestraintGroup)
        self.assertEqual(m1.restraint_group._id, '9')
        self.assertIsInstance(m1.global_parameter, ihm.flr.FPSGlobalParameters)
        self.assertEqual(m1.global_parameter._id, '10')
        self.assertEqual(m1.probe_modeling_method, 'AV3')
        self.assertEqual(m1.details, 'test details')

    def test_flr_fps_av_parameter_handler(self):
        """Test FLRFPSAVParameterHandler"""
        fh = StringIO("""
loop_
_flr_FPS_AV_parameter.id
_flr_FPS_AV_parameter.num_linker_atoms
_flr_FPS_AV_parameter.linker_length
_flr_FPS_AV_parameter.linker_width
_flr_FPS_AV_parameter.probe_radius_1
_flr_FPS_AV_parameter.probe_radius_2
_flr_FPS_AV_parameter.probe_radius_3
1 15 20.000 3.500 10.000 5.000 4.000
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_fps_av_parameter.keys()),
                         ['1'])
        p = flr._collection_flr_fps_av_parameter['1']
        self.assertEqual(p.num_linker_atoms, 15)
        self.assertAlmostEqual(p.linker_length, 20.000, delta=0.1)
        self.assertAlmostEqual(p.linker_width, 3.500, delta=0.1)
        self.assertAlmostEqual(p.probe_radius_1, 10.000, delta=0.1)
        self.assertAlmostEqual(p.probe_radius_2, 5.000, delta=0.1)
        self.assertAlmostEqual(p.probe_radius_3, 4.000, delta=0.1)

    def test_flr_fps_av_modeling_handler(self):
        """Test FLRFPSAVModelingHandler"""
        fh = StringIO("""
loop_
_flr_FPS_modeling.id
_flr_FPS_modeling.ihm_modeling_protocol_ordinal_id
_flr_FPS_modeling.restraint_group_id
_flr_FPS_modeling.global_parameter_id
_flr_FPS_modeling.probe_modeling_method
_flr_FPS_modeling.details
3 4 5 6 AV3 .
#
loop_
_flr_FPS_AV_modeling.id
_flr_FPS_AV_modeling.sample_probe_id
_flr_FPS_AV_modeling.FPS_modeling_id
_flr_FPS_AV_modeling.parameter_id
1 2 3 4
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_fps_av_modeling.keys()),
                         ['1'])
        m = flr._collection_flr_fps_av_modeling['1']
        self.assertIsInstance(m.sample_probe, ihm.flr.SampleProbeDetails)
        self.assertEqual(m.sample_probe._id, '2')
        self.assertIsInstance(m.fps_modeling, ihm.flr.FPSModeling)
        self.assertEqual(m.fps_modeling._id, '3')
        self.assertIsInstance(m.parameter, ihm.flr.FPSAVParameter)
        self.assertEqual(m.parameter._id, '4')

    def test_flr_fps_mean_probe_position_handler(self):
        """Test FLRFPSMPPHandler"""
        fh = StringIO("""
loop_
_flr_FPS_mean_probe_position.id
_flr_FPS_mean_probe_position.sample_probe_id
_flr_FPS_mean_probe_position.mpp_xcoord
_flr_FPS_mean_probe_position.mpp_ycoord
_flr_FPS_mean_probe_position.mpp_zcoord
1 2 1.000 2.000 3.000
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(
            flr._collection_flr_fps_mean_probe_position.keys()), ['1'])
        p = flr._collection_flr_fps_mean_probe_position['1']
        self.assertIsInstance(p.sample_probe, ihm.flr.SampleProbeDetails)
        self.assertEqual(p.sample_probe._id, '2')
        self.assertAlmostEqual(p.x, 1.0, delta=0.1)
        self.assertAlmostEqual(p.y, 2.0, delta=0.1)
        self.assertAlmostEqual(p.z, 3.0, delta=0.1)

    def test_flr_fps_mpp_atom_position_handler(self):
        """Test FLRFPSMPPAtomPositionHandler"""
        fh = StringIO("""
loop_
_flr_FPS_MPP_atom_position.id
_flr_FPS_MPP_atom_position.entity_id
_flr_FPS_MPP_atom_position.seq_id
_flr_FPS_MPP_atom_position.comp_id
_flr_FPS_MPP_atom_position.atom_id
_flr_FPS_MPP_atom_position.asym_id
_flr_FPS_MPP_atom_position.xcoord
_flr_FPS_MPP_atom_position.ycoord
_flr_FPS_MPP_atom_position.zcoord
_flr_FPS_MPP_atom_position.group_id
1 1 4 ALA CA A 1.000 2.000 3.000 1
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(
            sorted(flr._collection_flr_fps_mpp_atom_position.keys()), ['1'])
        p = flr._collection_flr_fps_mpp_atom_position['1']
        self.assertIsInstance(p.atom, ihm.Atom)
        self.assertEqual(p.atom.id, 'CA')
        self.assertEqual(p.atom.seq_id, 4)
        self.assertEqual(p.atom.asym._id, 'A')
        self.assertAlmostEqual(p.x, 1.0, delta=0.1)
        self.assertAlmostEqual(p.y, 2.0, delta=0.1)
        self.assertAlmostEqual(p.z, 3.0, delta=0.1)

    def test_flr_fps_mpp_modeling_handler(self):
        """Test FLRFPSMPPModelingHandler"""
        fh = StringIO("""
loop_
_flr_FPS_modeling.id
_flr_FPS_modeling.ihm_modeling_protocol_ordinal_id
_flr_FPS_modeling.restraint_group_id
_flr_FPS_modeling.global_parameter_id
_flr_FPS_modeling.probe_modeling_method
_flr_FPS_modeling.details
3 4 5 6 AV3 .
#
loop_
_flr_FPS_MPP_modeling.ordinal_id
_flr_FPS_MPP_modeling.FPS_modeling_id
_flr_FPS_MPP_modeling.mpp_id
_flr_FPS_MPP_modeling.mpp_atom_position_group_id
1 3 4 5
""")
        s, = ihm.reader.read(fh)
        flr, = s.flr_data
        self.assertEqual(sorted(flr._collection_flr_fps_mpp_modeling.keys()),
                         ['1'])
        m = flr._collection_flr_fps_mpp_modeling['1']
        self.assertIsInstance(m.fps_modeling, ihm.flr.FPSModeling)
        self.assertEqual(m.fps_modeling._id, '3')
        self.assertIsInstance(m.mpp, ihm.flr.FPSMeanProbePosition)
        self.assertEqual(m.mpp._id, '4')
        self.assertIsInstance(m.mpp_atom_position_group,
                              ihm.flr.FPSMPPAtomPositionGroup)
        self.assertEqual(m.mpp_atom_position_group._id, '5')

    def test_flr_kinetic_rate_fret_analysis_connection_handler(self):
        """Test FLRKineticRateFretAnalysisConnectionHandler"""
        mss_cif = """
loop_
_ihm_multi_state_scheme.id
_ihm_multi_state_scheme.name
_ihm_multi_state_scheme.details
1 'scheme1' 'details1'
2 'scheme2' 'details2'
#
#
loop_
_ihm_multi_state_scheme_connectivity.id
_ihm_multi_state_scheme_connectivity.scheme_id
_ihm_multi_state_scheme_connectivity.begin_state_id
_ihm_multi_state_scheme_connectivity.end_state_id
_ihm_multi_state_scheme_connectivity.dataset_group_id
_ihm_multi_state_scheme_connectivity.details
1 1 1 2 10 'connectivity1'
2 1 2 1 11 'connectivity2'
3 2 1 2 10 'connectivity1'
#
"""
        rate_cif = """
#
loop_
_ihm_kinetic_rate.id
_ihm_kinetic_rate.transition_rate_constant
_ihm_kinetic_rate.equilibrium_constant
_ihm_kinetic_rate.equilibrium_constant_determination_method
_ihm_kinetic_rate.equilibrium_constant_unit
_ihm_kinetic_rate.details
_ihm_kinetic_rate.scheme_connectivity_id
_ihm_kinetic_rate.dataset_group_id
_ihm_kinetic_rate.external_file_id
51 3.0 . . . 'rate1' 1 4 5
52 . 6.5 'equilibrium constant is determined from population' . 'rate2' 2  . .
53 7.0 . . . 'rate3' 3 8 9
#
"""
        flr_cif = """
#
loop_
_flr_fret_analysis.id
_flr_fret_analysis.experiment_id
_flr_fret_analysis.type
_flr_fret_analysis.sample_probe_id_1
_flr_fret_analysis.sample_probe_id_2
_flr_fret_analysis.forster_radius_id
_flr_fret_analysis.dataset_list_id
_flr_fret_analysis.external_file_id
_flr_fret_analysis.software_id
1 108 intensity-based 9 2 11 18 42 99
5 113 lifetime-based 24 5 19 32 81 98
#
#
loop_
_flr_kinetic_rate_analysis.id
_flr_kinetic_rate_analysis.fret_analysis_id
_flr_kinetic_rate_analysis.kinetic_rate_id
_flr_kinetic_rate_analysis.details
1 1 51 details1
2 1 52 details2
3 5 51 details3
4 8 54 details4
"""
        # Order of categories should not matter
        for cif in (
                mss_cif + rate_cif + flr_cif,
                mss_cif + flr_cif + rate_cif,
                rate_cif + mss_cif + flr_cif,
                rate_cif + flr_cif + mss_cif,
                flr_cif + mss_cif + rate_cif,
                flr_cif + rate_cif + mss_cif):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                flr, = s.flr_data
                con = flr.kinetic_rate_fret_analysis_connections
                self.assertEqual(len(con), 4)
                self.assertEqual(con[0].fret_analysis._id, '1')
                self.assertEqual(con[0].kinetic_rate._id, '51')
                self.assertEqual(con[0].details, 'details1')
                self.assertEqual(con[1].fret_analysis._id, '1')
                self.assertEqual(con[1].kinetic_rate._id, '52')
                self.assertEqual(con[1].details, 'details2')
                self.assertEqual(con[2].fret_analysis._id, '5')
                self.assertEqual(con[2].kinetic_rate._id, '51')
                self.assertEqual(con[2].details, 'details3')
                # The last one is auto generated
                self.assertEqual(con[3].fret_analysis._id, '8')
                self.assertEqual(con[3].kinetic_rate._id, '54')
                self.assertEqual(con[3].details, 'details4')

                # Test the _all_relaxation_times() function
                self.assertEqual([x._id for x in list(s._all_kinetic_rates())],
                                 ['51', '52', '53', '54'])

    def test_flr_relaxation_time_fret_analysis_connection_handler(self):
        """Test FLRRelaxationTimeFretAnalysisConnectionHandler"""
        mss_cif = """
loop_
_ihm_multi_state_scheme.id
_ihm_multi_state_scheme.name
_ihm_multi_state_scheme.details
1 'scheme1' 'details1'
2 'scheme2' 'details2'
#
#
loop_
_ihm_multi_state_scheme_connectivity.id
_ihm_multi_state_scheme_connectivity.scheme_id
_ihm_multi_state_scheme_connectivity.begin_state_id
_ihm_multi_state_scheme_connectivity.end_state_id
_ihm_multi_state_scheme_connectivity.dataset_group_id
_ihm_multi_state_scheme_connectivity.details
1 1 1 2 10 'connectivity1'
2 1 2 1 11 'connectivity2'
3 2 1 2 10 'connectivity1'
#
"""
        relaxation_time_cif = """
#
loop_
_ihm_relaxation_time.id
_ihm_relaxation_time.value
_ihm_relaxation_time.unit
_ihm_relaxation_time.amplitude
_ihm_relaxation_time.dataset_group_id
_ihm_relaxation_time.external_file_id
_ihm_relaxation_time.details
101 10.0 seconds 0.5 20 21 'relaxation_time1'
102 11.5 milliseconds . 22 23 'relaxation_time2'
103 12.0 seconds 0.4 24 25 'relaxation_time3'
104 16.0 seconds 0.6 25 25 'relaxation_time4'
#
#
loop_
_ihm_relaxation_time_multi_state_scheme.id
_ihm_relaxation_time_multi_state_scheme.relaxation_time_id
_ihm_relaxation_time_multi_state_scheme.scheme_id
_ihm_relaxation_time_multi_state_scheme.scheme_connectivity_id
_ihm_relaxation_time_multi_state_scheme.details
1 101 1 1 .
2 102 1 2 .
3 103 1 . .
4 104 1 . .
#
"""
        flr_cif = """
#
loop_
_flr_fret_analysis.id
_flr_fret_analysis.experiment_id
_flr_fret_analysis.type
_flr_fret_analysis.sample_probe_id_1
_flr_fret_analysis.sample_probe_id_2
_flr_fret_analysis.forster_radius_id
_flr_fret_analysis.dataset_list_id
_flr_fret_analysis.external_file_id
_flr_fret_analysis.software_id
1 108 intensity-based 9 2 11 18 42 99
5 113 lifetime-based 24 5 19 32 81 98
#
#
loop_
_flr_relaxation_time_analysis.id
_flr_relaxation_time_analysis.fret_analysis_id
_flr_relaxation_time_analysis.relaxation_time_id
_flr_relaxation_time_analysis.details
1 1 101 details1
2 1 102 details2
3 5 101 details3
4 8 103 details4
"""

        # Order of categories should not matter
        for cif in (
                mss_cif + relaxation_time_cif + flr_cif,
                mss_cif + flr_cif + relaxation_time_cif,
                relaxation_time_cif + mss_cif + flr_cif,
                relaxation_time_cif + flr_cif + mss_cif,
                flr_cif + mss_cif + relaxation_time_cif,
                flr_cif + relaxation_time_cif + mss_cif):
            for fh in cif_file_handles(cif):
                s, = ihm.reader.read(fh)
                flr, = s.flr_data
                con = flr.relaxation_time_fret_analysis_connections
                self.assertEqual(len(con), 4)
                self.assertEqual(con[0].fret_analysis._id, '1')
                self.assertEqual(con[0].relaxation_time._id, '101')
                self.assertEqual(con[0].details, 'details1')
                self.assertEqual(con[1].fret_analysis._id, '1')
                self.assertEqual(con[1].relaxation_time._id, '102')
                self.assertEqual(con[1].details, 'details2')
                self.assertEqual(con[2].fret_analysis._id, '5')
                self.assertEqual(con[2].relaxation_time._id, '101')
                self.assertEqual(con[2].details, 'details3')
                # The last one is auto generated
                self.assertEqual(con[3].fret_analysis._id, '8')
                self.assertEqual(con[3].relaxation_time._id, '103')
                self.assertEqual(con[3].details, 'details4')

                # Test the _all_relaxation_times() function
                self.assertEqual([x._id for x in
                                  list(s._all_relaxation_times())],
                                 ['103', '104', '101', '102'])

    def test_variant_base(self):
        """Test Variant base class"""
        v = ihm.reader.Variant()
        self.assertIsNone(v.get_handlers(None))
        self.assertIsNone(v.get_audit_conform_handler(None))

    def test_write_variant(self):
        """Test write() function with Variant object"""
        cif = "data_model\n_struct.entry_id testid\n"
        for fh in cif_file_handles(cif):
            s, = ihm.reader.read(fh, variant=ihm.reader.IHMVariant())
            self.assertEqual(s.id, 'testid')

    def test_branch_scheme_handler(self):
        """Test BranchSchemeHandler"""
        fh = StringIO("""
loop_
_chem_comp.id
_chem_comp.type
_chem_comp.name
_chem_comp.formula
_chem_comp.formula_weight
BGC 'D-saccharide, beta linking' beta-D-glucopyranose 'C6 H12 O6' 180.156
#
loop_
_pdbx_entity_branch_list.entity_id
_pdbx_entity_branch_list.num
_pdbx_entity_branch_list.comp_id
_pdbx_entity_branch_list.hetero
1 1 BGC .
1 2 BGC .
1 3 BGC .
1 4 BGC .
#
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 1 foo
B 1 bar
C 1 baz
#
loop_
_pdbx_branch_scheme.asym_id
_pdbx_branch_scheme.entity_id
_pdbx_branch_scheme.mon_id
_pdbx_branch_scheme.num
_pdbx_branch_scheme.pdb_seq_num
_pdbx_branch_scheme.auth_seq_num
_pdbx_branch_scheme.auth_mon_id
_pdbx_branch_scheme.pdb_asym_id
A 1 BGC 1 5 5 BGC 0
A 1 BGC 2 6 6 BGC 0
A 1 BGC 3 7 7 BGC 0
A 1 BGC 4 8 8 BGC 0
B 1 BGC 1 1 11 BGC .
B 1 BGC 2 2 12 BGC .
B 1 BGC 3 3 13 BGC .
B 1 BGC 4 4 14 BGC .
C 1 BGC 1 2 . BGC .
C 1 BGC 2 4 . BGC .
C 1 BGC 3 6 . BGC .
C 1 BGC 4 8 . BGC .
""")
        s, = ihm.reader.read(fh)
        asym_a, asym_b, asym_c = s.asym_units
        self.assertEqual(asym_a.auth_seq_id_map,
                         {1: (5, None), 2: (6, None), 3: (7, None),
                          4: (8, None)})
        self.assertEqual(asym_a._strand_id, '0')
        self.assertEqual(asym_a.residue(1).auth_seq_id, 5)
        self.assertIsNone(asym_a.orig_auth_seq_id_map)
        self.assertIsNone(asym_a.num_map)

        self.assertEqual(asym_b.auth_seq_id_map,
                         {1: (1, None), 2: (2, None), 3: (3, None),
                          4: (4, None)})
        self.assertIsNone(asym_b._strand_id)
        self.assertEqual(asym_b.residue(1).auth_seq_id, 1)
        self.assertEqual(asym_b.orig_auth_seq_id_map,
                         {1: 11, 2: 12, 3: 13, 4: 14})
        self.assertIsNone(asym_b.num_map)

        self.assertEqual(asym_c.auth_seq_id_map,
                         {1: (2, None), 2: (4, None), 3: (6, None),
                          4: (8, None)})
        self.assertIsNone(asym_c._strand_id)
        self.assertEqual(asym_c.residue(1).auth_seq_id, 2)
        self.assertEqual(asym_c.orig_auth_seq_id_map,
                         {1: None, 2: None, 3: None, 4: None})
        self.assertIsNone(asym_c.num_map)

    def test_entity_branch_list_handler(self):
        """Test EntityBranchListHandler"""
        fh = StringIO("""
loop_
_pdbx_entity_branch_list.entity_id
_pdbx_entity_branch_list.num
_pdbx_entity_branch_list.comp_id
_pdbx_entity_branch_list.hetero
1 1 BGC .
1 2 BGC .
1 3 BGC .
1 4 BGC .
""")
        s, = ihm.reader.read(fh)
        e1, = s.entities
        c1, c2, c3, c4 = e1.sequence
        self.assertEqual([c.id for c in e1.sequence], ['BGC'] * 4)

    def test_entity_branch_descriptor_handler(self):
        """Test EntityBranchDescriptorHandler"""
        fh = StringIO("""
loop_
_pdbx_entity_branch_descriptor.ordinal
_pdbx_entity_branch_descriptor.entity_id
_pdbx_entity_branch_descriptor.descriptor
_pdbx_entity_branch_descriptor.type
_pdbx_entity_branch_descriptor.program
_pdbx_entity_branch_descriptor.program_version
1 1 foo typ1 prog 1.0
2 1 bar typ2 . .
""")
        s, = ihm.reader.read(fh)
        e1, = s.entities
        bd1, bd2 = e1.branch_descriptors
        self.assertEqual(bd1.text, 'foo')
        self.assertEqual(bd1.type, 'typ1')
        self.assertEqual(bd1.program, 'prog')
        self.assertEqual(bd1.program_version, '1.0')
        self.assertEqual(bd2.text, 'bar')
        self.assertEqual(bd2.type, 'typ2')
        self.assertIsNone(bd2.program)
        self.assertIsNone(bd2.program_version)

    def test_entity_branch_link_handler(self):
        """Test EntityBranchLinkHandler"""
        fh = StringIO("""
loop_
_pdbx_entity_branch_link.link_id
_pdbx_entity_branch_link.entity_id
_pdbx_entity_branch_link.entity_branch_list_num_1
_pdbx_entity_branch_link.comp_id_1
_pdbx_entity_branch_link.atom_id_1
_pdbx_entity_branch_link.leaving_atom_id_1
_pdbx_entity_branch_link.entity_branch_list_num_2
_pdbx_entity_branch_link.comp_id_2
_pdbx_entity_branch_link.atom_id_2
_pdbx_entity_branch_link.leaving_atom_id_2
_pdbx_entity_branch_link.value_order
_pdbx_entity_branch_link.details
1 1 1 NAG CA H1 2 BMC N H2 sing foo
2 1 2 BMC CA H1 3 FUC N H2 . .
""")
        s, = ihm.reader.read(fh)
        e1, = s.entities
        lnk1, lnk2 = e1.branch_links
        self.assertEqual(lnk1.num1, 1)
        self.assertEqual(lnk1.atom_id1, 'CA')
        self.assertEqual(lnk1.leaving_atom_id1, 'H1')
        self.assertEqual(lnk1.num2, 2)
        self.assertEqual(lnk1.atom_id2, 'N')
        self.assertEqual(lnk1.leaving_atom_id2, 'H2')
        self.assertEqual(lnk1.order, 'sing')
        self.assertEqual(lnk1.details, 'foo')
        self.assertEqual(lnk2.num1, 2)
        self.assertEqual(lnk2.atom_id1, 'CA')
        self.assertEqual(lnk2.leaving_atom_id1, 'H1')
        self.assertEqual(lnk2.num2, 3)
        self.assertEqual(lnk2.atom_id2, 'N')
        self.assertEqual(lnk2.leaving_atom_id2, 'H2')
        self.assertIsNone(lnk2.order)
        self.assertIsNone(lnk2.details)

    def test_database_handler(self):
        """Test DatabaseHandler"""
        fh = StringIO("""
loop_
_database_2.database_id
_database_2.database_code
_database_2.pdbx_database_accession
_database_2.pdbx_DOI
foo bar . ?
baz 1abc 1abcxyz 1.2.3.4
""")
        s, = ihm.reader.read(fh)
        d1, d2 = s.databases
        self.assertEqual(d1.id, 'foo')
        self.assertEqual(d1.code, 'bar')
        self.assertIsNone(d1.accession)
        self.assertIs(d1.doi, ihm.unknown)
        self.assertEqual(d2.id, 'baz')
        self.assertEqual(d2.code, '1abc')
        self.assertEqual(d2.accession, '1abcxyz')
        self.assertEqual(d2.doi, '1.2.3.4')

    def test_database_status_handler(self):
        """Test DatabaseStatusHandler"""
        fh = StringIO("""
_pdbx_database_status.status_code                     REL
_pdbx_database_status.entry_id                        5FD1
_pdbx_database_status.recvd_initial_deposition_date   1993-06-29
_pdbx_database_status.deposit_site                    ?
_pdbx_database_status.process_site                    BNL
_pdbx_database_status.SG_entry                        .
""")
        s, = ihm.reader.read(fh)
        # Should pass through to a dict
        self.assertEqual(s._database_status,
                         {'status_code': 'REL',
                          'entry_id': '5FD1',
                          'recvd_initial_deposition_date': '1993-06-29',
                          'deposit_site': ihm.unknown,
                          'process_site': 'BNL',
                          'sg_entry': None})
        # Also test public interface for selected data items
        self.assertEqual(s.database_status.status_code, 'REL')
        self.assertIs(s.database_status.deposit_site, ihm.unknown)
        self.assertEqual(s.database_status.process_site, 'BNL')
        self.assertEqual(s.database_status.recvd_initial_deposition_date,
                         datetime.date(1993, 6, 29))

    def test_add_to_system(self):
        """Test adding new mmCIF input to existing System"""
        s = ihm.System()
        e = ihm.Entity('AHC')
        e._id = '42'
        s.entities.append(e)
        fh = StringIO("""
loop_
_struct_asym.id
_struct_asym.entity_id
_struct_asym.details
A 42 foo
B 99 bar
""")
        s2, = ihm.reader.read(fh, add_to_system=s)
        self.assertIs(s2, s)
        self.assertEqual(len(s.asym_units), 2)
        # asym A should point to existing entity
        self.assertEqual(s.asym_units[0].id, 'A')
        self.assertIs(s.asym_units[0].entity, e)


if __name__ == '__main__':
    unittest.main()