Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

# Copyright 2007 by Michiel de Hoon.  All rights reserved. 

# This code is part of the Biopython distribution and governed by its 

# license.  Please see the LICENSE file that should have been included 

# as part of this package. 

"""Code to work with the sprotXX.dat file from SwissProt. 

 

http://www.expasy.ch/sprot/sprot-top.html 

 

Tested with: 

Release 56.9, 03-March-2009. 

 

 

Classes: 

Record             Holds SwissProt data. 

Reference          Holds reference data from a SwissProt record. 

 

Functions: 

read               Read one SwissProt record 

parse              Read multiple SwissProt records 

 

""" 

 

from __future__ import print_function 

 

from Bio._py3k import _as_string 

 

 

class Record(object): 

    """Holds information from a SwissProt record. 

 

    Members: 

    entry_name        Name of this entry, e.g. RL1_ECOLI. 

    data_class        Either 'STANDARD' or 'PRELIMINARY'. 

    molecule_type     Type of molecule, 'PRT', 

    sequence_length   Number of residues. 

 

    accessions        List of the accession numbers, e.g. ['P00321'] 

    created           A tuple of (date, release). 

    sequence_update   A tuple of (date, release). 

    annotation_update A tuple of (date, release). 

 

    description       Free-format description. 

    gene_name         Gene name.  See userman.txt for description. 

    organism          The source of the sequence. 

    organelle         The origin of the sequence. 

    organism_classification  The taxonomy classification.  List of strings. 

                             (http://www.ncbi.nlm.nih.gov/Taxonomy/) 

    taxonomy_id       A list of NCBI taxonomy id's. 

    host_organism     A list of names of the hosts of a virus, if any. 

    host_taxonomy_id  A list of NCBI taxonomy id's of the hosts, if any. 

    references        List of Reference objects. 

    comments          List of strings. 

    cross_references  List of tuples (db, id1[, id2][, id3]).  See the docs. 

    keywords          List of the keywords. 

    features          List of tuples (key name, from, to, description). 

                      from and to can be either integers for the residue 

                      numbers, '<', '>', or '?' 

 

    seqinfo           tuple of (length, molecular weight, CRC32 value) 

    sequence          The sequence. 

 

    """ 

    def __init__(self): 

        self.entry_name = None 

        self.data_class = None 

        self.molecule_type = None 

        self.sequence_length = None 

 

        self.accessions = [] 

        self.created = None 

        self.sequence_update = None 

        self.annotation_update = None 

 

        self.description = [] 

        self.gene_name = '' 

        self.organism = [] 

        self.organelle = '' 

        self.organism_classification = [] 

        self.taxonomy_id = [] 

        self.host_organism = [] 

        self.host_taxonomy_id = [] 

        self.references = [] 

        self.comments = [] 

        self.cross_references = [] 

        self.keywords = [] 

        self.features = [] 

 

        self.seqinfo = None 

        self.sequence = '' 

 

 

class Reference(object): 

    """Holds information from one reference in a SwissProt entry. 

 

    Members: 

    number      Number of reference in an entry. 

    positions   Describes extent of work.  List of strings. 

    comments    Comments.  List of (token, text). 

    references  References.  List of (dbname, identifier). 

    authors     The authors of the work. 

    title       Title of the work. 

    location    A citation for the work. 

 

    """ 

    def __init__(self): 

        self.number = None 

        self.positions = [] 

        self.comments = [] 

        self.references = [] 

        self.authors = [] 

        self.title = [] 

        self.location = [] 

 

 

def parse(handle): 

    while True: 

        record = _read(handle) 

        if not record: 

            return 

        yield record 

 

 

def read(handle): 

    record = _read(handle) 

    if not record: 

        raise ValueError("No SwissProt record found") 

    # We should have reached the end of the record by now 

    remainder = handle.read() 

    if remainder: 

        raise ValueError("More than one SwissProt record found") 

    return record 

 

 

# Everything below is considered private 

 

 

def _read(handle): 

    record = None 

    unread = "" 

    for line in handle: 

        #This is for Python 3 to cope with a binary handle (byte strings), 

        #or a text handle (unicode strings): 

        line = _as_string(line) 

        key, value = line[:2], line[5:].rstrip() 

        if unread: 

            value = unread + " " + value 

            unread = "" 

        if key == '**': 

            #See Bug 2353, some files from the EBI have extra lines 

            #starting "**" (two asterisks/stars).  They appear 

            #to be unofficial automated annotations. e.g. 

            #** 

            #**   #################    INTERNAL SECTION    ################## 

            #**HA SAM; Annotated by PicoHamap 1.88; MF_01138.1; 09-NOV-2003. 

            pass 

        elif key == 'ID': 

            record = Record() 

            _read_id(record, line) 

            _sequence_lines = [] 

        elif key == 'AC': 

            accessions = [word for word in value.rstrip(";").split("; ")] 

            record.accessions.extend(accessions) 

        elif key == 'DT': 

            _read_dt(record, line) 

        elif key == 'DE': 

            record.description.append(value.strip()) 

        elif key == 'GN': 

            if record.gene_name: 

                record.gene_name += " " 

            record.gene_name += value 

        elif key == 'OS': 

            record.organism.append(value) 

        elif key == 'OG': 

            record.organelle += line[5:] 

        elif key == 'OC': 

            cols = [col for col in value.rstrip(";.").split("; ")] 

            record.organism_classification.extend(cols) 

        elif key == 'OX': 

            _read_ox(record, line) 

        elif key == 'OH': 

            _read_oh(record, line) 

        elif key == 'RN': 

            reference = Reference() 

            _read_rn(reference, value) 

            record.references.append(reference) 

        elif key == 'RP': 

            assert record.references, "RP: missing RN" 

            record.references[-1].positions.append(value) 

        elif key == 'RC': 

            assert record.references, "RC: missing RN" 

            reference = record.references[-1] 

            unread = _read_rc(reference, value) 

        elif key == 'RX': 

            assert record.references, "RX: missing RN" 

            reference = record.references[-1] 

            _read_rx(reference, value) 

        elif key == 'RL': 

            assert record.references, "RL: missing RN" 

            reference = record.references[-1] 

            reference.location.append(value) 

        # In UniProt release 1.12 of 6/21/04, there is a new RG 

        # (Reference Group) line, which references a group instead of 

        # an author.  Each block must have at least 1 RA or RG line. 

        elif key == 'RA': 

            assert record.references, "RA: missing RN" 

            reference = record.references[-1] 

            reference.authors.append(value) 

        elif key == 'RG': 

            assert record.references, "RG: missing RN" 

            reference = record.references[-1] 

            reference.authors.append(value) 

        elif key == "RT": 

            assert record.references, "RT: missing RN" 

            reference = record.references[-1] 

            reference.title.append(value) 

        elif key == 'CC': 

            _read_cc(record, line) 

        elif key == 'DR': 

            _read_dr(record, value) 

        elif key == 'PE': 

            #TODO - Record this information? 

            pass 

        elif key == 'KW': 

            cols = value.rstrip(";.").split('; ') 

            record.keywords.extend(cols) 

        elif key == 'FT': 

            _read_ft(record, line) 

        elif key == 'SQ': 

            cols = value.split() 

            assert len(cols) == 7, "I don't understand SQ line %s" % line 

            # Do more checking here? 

            record.seqinfo = int(cols[1]), int(cols[3]), cols[5] 

        elif key == '  ': 

            _sequence_lines.append(value.replace(" ", "").rstrip()) 

        elif key == '//': 

            # Join multiline data into one string 

            record.description = " ".join(record.description) 

            record.organism = " ".join(record.organism) 

            record.organelle = record.organelle.rstrip() 

            for reference in record.references: 

                reference.authors = " ".join(reference.authors).rstrip(";") 

                reference.title = " ".join(reference.title).rstrip(";") 

                if reference.title.startswith('"') and reference.title.endswith('"'): 

                    reference.title = reference.title[1:-1]  # remove quotes 

                reference.location = " ".join(reference.location) 

            record.sequence = "".join(_sequence_lines) 

            return record 

        else: 

            raise ValueError("Unknown keyword '%s' found" % key) 

    if record: 

        raise ValueError("Unexpected end of stream.") 

 

 

def _read_id(record, line): 

    cols = line[5:].split() 

    #Prior to release 51, included with MoleculeType: 

    #ID   EntryName DataClass; MoleculeType; SequenceLength AA. 

    # 

    #Newer files lack the MoleculeType: 

    #ID   EntryName DataClass; SequenceLength AA. 

    if len(cols) == 5: 

        record.entry_name = cols[0] 

        record.data_class = cols[1].rstrip(";") 

        record.molecule_type = cols[2].rstrip(";") 

        record.sequence_length = int(cols[3]) 

    elif len(cols) == 4: 

        record.entry_name = cols[0] 

        record.data_class = cols[1].rstrip(";") 

        record.molecule_type = None 

        record.sequence_length = int(cols[2]) 

    else: 

        raise ValueError("ID line has unrecognised format:\n" + line) 

    # check if the data class is one of the allowed values 

    allowed = ('STANDARD', 'PRELIMINARY', 'IPI', 'Reviewed', 'Unreviewed') 

    if record.data_class not in allowed: 

        raise ValueError("Unrecognized data class %s in line\n%s" % 

              (record.data_class, line)) 

    # molecule_type should be 'PRT' for PRoTein 

    # Note that has been removed in recent releases (set to None) 

    if record.molecule_type not in (None, 'PRT'): 

        raise ValueError("Unrecognized molecule type %s in line\n%s" % 

              (record.molecule_type, line)) 

 

 

def _read_dt(record, line): 

    value = line[5:] 

    uprline = value.upper() 

    cols = value.rstrip().split() 

    if 'CREATED' in uprline \ 

    or 'LAST SEQUENCE UPDATE' in uprline \ 

    or 'LAST ANNOTATION UPDATE' in uprline: 

        # Old style DT line 

        # ================= 

        # e.g. 

        # DT   01-FEB-1995 (Rel. 31, Created) 

        # DT   01-FEB-1995 (Rel. 31, Last sequence update) 

        # DT   01-OCT-2000 (Rel. 40, Last annotation update) 

        # 

        # or: 

        # DT   08-JAN-2002 (IPI Human rel. 2.3, Created) 

        # ... 

 

        # find where the version information will be located 

        # This is needed for when you have cases like IPI where 

        # the release verison is in a different spot: 

        # DT   08-JAN-2002 (IPI Human rel. 2.3, Created) 

        uprcols = uprline.split() 

        rel_index = -1 

        for index in range(len(uprcols)): 

            if 'REL.' in uprcols[index]: 

                rel_index = index 

        assert rel_index >= 0, \ 

                "Could not find Rel. in DT line: %s" % line 

        version_index = rel_index + 1 

        # get the version information 

        str_version = cols[version_index].rstrip(",") 

        # no version number 

        if str_version == '': 

            version = 0 

        # dot versioned 

        elif '.' in str_version: 

            version = str_version 

        # integer versioned 

        else: 

            version = int(str_version) 

        date = cols[0] 

 

        if 'CREATED' in uprline: 

            record.created = date, version 

        elif 'LAST SEQUENCE UPDATE' in uprline: 

            record.sequence_update = date, version 

        elif 'LAST ANNOTATION UPDATE' in uprline: 

            record.annotation_update = date, version 

        else: 

            assert False, "Shouldn't reach this line!" 

    elif 'INTEGRATED INTO' in uprline \ 

    or 'SEQUENCE VERSION' in uprline \ 

    or 'ENTRY VERSION' in uprline: 

        # New style DT line 

        # ================= 

        # As of UniProt Knowledgebase release 7.0 (including 

        # Swiss-Prot release 49.0 and TrEMBL release 32.0) the 

        # format of the DT lines and the version information 

        # in them was changed - the release number was dropped. 

        # 

        # For more information see bug 1948 and 

        # http://ca.expasy.org/sprot/relnotes/sp_news.html#rel7.0 

        # 

        # e.g. 

        # DT   01-JAN-1998, integrated into UniProtKB/Swiss-Prot. 

        # DT   15-OCT-2001, sequence version 3. 

        # DT   01-APR-2004, entry version 14. 

        # 

        #This is a new style DT line... 

 

        # The date should be in string cols[1] 

        # Get the version number if there is one. 

        # For the three DT lines above: 0, 3, 14 

        try: 

            version = int(cols[-1]) 

        except ValueError: 

            version = 0 

        date = cols[0].rstrip(",") 

 

        # Re-use the historical property names, even though 

        # the meaning has changed slighty: 

        if "INTEGRATED" in uprline: 

            record.created = date, version 

        elif 'SEQUENCE VERSION' in uprline: 

            record.sequence_update = date, version 

        elif 'ENTRY VERSION' in uprline: 

            record.annotation_update = date, version 

        else: 

            assert False, "Shouldn't reach this line!" 

    else: 

        raise ValueError("I don't understand the date line %s" % line) 

 

 

def _read_ox(record, line): 

    # The OX line is in the format: 

    # OX   DESCRIPTION=ID[, ID]...; 

    # If there are too many id's to fit onto a line, then the ID's 

    # continue directly onto the next line, e.g. 

    # OX   DESCRIPTION=ID[, ID]... 

    # OX   ID[, ID]...; 

    # Currently, the description is always "NCBI_TaxID". 

    # To parse this, I need to check to see whether I'm at the 

    # first line.  If I am, grab the description and make sure 

    # it's an NCBI ID.  Then, grab all the id's. 

    if record.taxonomy_id: 

        ids = line[5:].rstrip().rstrip(";") 

    else: 

        descr, ids = line[5:].rstrip().rstrip(";").split("=") 

        assert descr == "NCBI_TaxID", "Unexpected taxonomy type %s" % descr 

    record.taxonomy_id.extend(ids.split(', ')) 

 

 

def _read_oh(record, line): 

    # Line type OH (Organism Host) for viral hosts 

    assert line[5:].startswith("NCBI_TaxID="), "Unexpected %s" % line 

    line = line[16:].rstrip() 

    assert line[-1] == "." and line.count(";") == 1, line 

    taxid, name = line[:-1].split(";") 

    record.host_taxonomy_id.append(taxid.strip()) 

    record.host_organism.append(name.strip()) 

 

 

def _read_rn(reference, rn): 

    assert rn[0] == '[' and rn[-1] == ']', "Missing brackets %s" % rn 

    reference.number = int(rn[1:-1]) 

 

 

def _read_rc(reference, value): 

    cols = value.split(';') 

    if value[-1] == ';': 

        unread = "" 

    else: 

        cols, unread = cols[:-1], cols[-1] 

    for col in cols: 

        if not col:  # last column will be the empty string 

            return 

        # The token is everything before the first '=' character. 

        i = col.find("=") 

        if i >= 0: 

            token, text = col[:i], col[i+1:] 

            comment = token.lstrip(), text 

            reference.comments.append(comment) 

        else: 

            comment = reference.comments[-1] 

            comment = "%s %s" % (comment, col) 

            reference.comments[-1] = comment 

    return unread 

 

 

def _read_rx(reference, value): 

    # The basic (older?) RX line is of the form: 

    # RX   MEDLINE; 85132727. 

    # but there are variants of this that need to be dealt with (see below) 

 

    # CLD1_HUMAN in Release 39 and DADR_DIDMA in Release 33 

    # have extraneous information in the RX line.  Check for 

    # this and chop it out of the line. 

    # (noticed by katel@worldpath.net) 

    value = value.replace(' [NCBI, ExPASy, Israel, Japan]', '') 

 

    # RX lines can also be used of the form 

    # RX   PubMed=9603189; 

    # reported by edvard@farmasi.uit.no 

    # and these can be more complicated like: 

    # RX   MEDLINE=95385798; PubMed=7656980; 

    # RX   PubMed=15060122; DOI=10.1136/jmg 2003.012781; 

    # We look for these cases first and deal with them 

    warn = False 

    if "=" in value: 

        cols = value.split("; ") 

        cols = [x.strip() for x in cols] 

        cols = [x for x in cols if x] 

        for col in cols: 

            x = col.split("=") 

            if len(x) != 2 or x == ("DOI", "DOI"): 

                warn = True 

                break 

            assert len(x) == 2, "I don't understand RX line %s" % value 

            reference.references.append((x[0], x[1].rstrip(";"))) 

    # otherwise we assume we have the type 'RX   MEDLINE; 85132727.' 

    else: 

        cols = value.split("; ") 

        # normally we split into the three parts 

        if len(cols) != 2: 

            warn = True 

        else: 

            reference.references.append((cols[0].rstrip(";"), cols[1].rstrip("."))) 

    if warn: 

        import warnings 

        from Bio import BiopythonParserWarning 

        warnings.warn("Possibly corrupt RX line %r" % value, 

                      BiopythonParserWarning) 

 

 

def _read_cc(record, line): 

    key, value = line[5:8], line[9:].rstrip() 

    if key == '-!-':   # Make a new comment 

        record.comments.append(value) 

    elif key == '   ':  # add to the previous comment 

        if not record.comments: 

            # TCMO_STRGA in Release 37 has comment with no topic 

            record.comments.append(value) 

        else: 

            record.comments[-1] += " " + value 

 

 

def _read_dr(record, value): 

    cols = value.rstrip(".").split('; ') 

    record.cross_references.append(tuple(cols)) 

 

 

def _read_ft(record, line): 

    line = line[5:]    # get rid of junk in front 

    name = line[0:8].rstrip() 

    try: 

        from_res = int(line[9:15]) 

    except ValueError: 

        from_res = line[9:15].lstrip() 

    try: 

        to_res = int(line[16:22]) 

    except ValueError: 

        to_res = line[16:22].lstrip() 

    #if there is a feature_id (FTId), store it away 

    if line[29:35] == r"/FTId=": 

        ft_id = line[35:70].rstrip()[:-1] 

        description = "" 

    else: 

        ft_id = "" 

        description = line[29:70].rstrip() 

    if not name:  # is continuation of last one 

        assert not from_res and not to_res 

        name, from_res, to_res, old_description, old_ft_id = record.features[-1] 

        del record.features[-1] 

        description = ("%s %s" % (old_description, description)).strip() 

 

        # special case -- VARSPLIC, reported by edvard@farmasi.uit.no 

        if name == "VARSPLIC": 

            # Remove unwanted spaces in sequences. 

            # During line carryover, the sequences in VARSPLIC can get mangled 

            # with unwanted spaces like: 

            # 'DISSTKLQALPSHGLESIQT -> PCRATGWSPFRRSSPC LPTH' 

            # We want to check for this case and correct it as it happens. 

            descr_cols = description.split(" -> ") 

            if len(descr_cols) == 2: 

                first_seq, second_seq = descr_cols 

                extra_info = '' 

                # we might have more information at the end of the 

                # second sequence, which should be in parenthesis 

                extra_info_pos = second_seq.find(" (") 

                if extra_info_pos != -1: 

                    extra_info = second_seq[extra_info_pos:] 

                    second_seq = second_seq[:extra_info_pos] 

                # now clean spaces out of the first and second string 

                first_seq = first_seq.replace(" ", "") 

                second_seq = second_seq.replace(" ", "") 

                # reassemble the description 

                description = first_seq + " -> " + second_seq + extra_info 

    record.features.append((name, from_res, to_res, description, ft_id)) 

 

 

if __name__ == "__main__": 

    print("Quick self test...") 

 

    example_filename = "../../Tests/SwissProt/sp008" 

 

    import os 

    if not os.path.isfile(example_filename): 

        print("Missing test file %s" % example_filename) 

    else: 

        #Try parsing it! 

 

        with open(example_filename) as handle: 

            records = parse(handle) 

            for record in records: 

                print(record.entry_name) 

                print(",".join(record.accessions)) 

                print(record.keywords) 

                print(repr(record.organism)) 

                print(record.sequence[:20] + "...")