pidibble 1.4.2__tar.gz → 1.5.1__tar.gz

{pidibble-1.4.2 → pidibble-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pidibble
-Version: 1.4.2
+Version: 1.5.1
 Summary: A complete Protein Data Bank (PDB) file parser
 Project-URL: Source, https://github.com/cameronabrams/pidibble
 Project-URL: Documentation, https://pidibble.readthedocs.io/en/latest/
@@ -91,6 +91,8 @@ ATOM
 ```
 
 ## Release History
+* 1.5.1
+   * added capability to download from OPM
 * 1.4.2
    * updated alphafold interface
 * 1.4.1

{pidibble-1.4.2 → pidibble-1.5.1}/README.md

@@ -73,6 +73,8 @@ ATOM
 ```
 
 ## Release History
+* 1.5.1
+   * added capability to download from OPM
 * 1.4.2
    * updated alphafold interface
 * 1.4.1

{pidibble-1.4.2 → pidibble-1.5.1}/docs/source/usage.rst

@@ -7,16 +7,22 @@ Usage Example
 Let's parse the PDB entry '4ZMJ', which is a trimeric ectodomain construct of the HIV-1 envelope glycoprotein:
 
 >>> from pidibble.pdbparse import PDBParser
->>> p=PDBParser(PDBcode='4zmj').parse()
+>>> p = PDBParser(source_db='rcsb', source_id='4zmj').parse()
 
 The ``PDBParser()`` call creates a new ``PDBParser`` object, and the member function ``parse()`` executes (optionally) downloading the PDB file of the code entered with the ``PDBcode`` keyword argument to ``PDBParser()``, followed by parsing into a member dictionary ``parsed``.  (The file is downloaded from the RSCB only if it is not found in the current working directory.)
 
 Alternatively, a ``PDBParser()`` invocation can fetch from the AlphaFold model database by providing the accession code with the ``alphafold`` keyword:
 
->>> p=PDBParser(alphafold='O46077').parse()
+>>> p = PDBParser(source_db='alphafold', sourced_id='O46077').parse()
 
 (Note that this fetches a model for the odor receptor OR2a from *D. melanogaster*.  For the rest of this example, we'll work with the HIV-1 Env trimer 4zmj above.)
 
+Finally, one can also retrieve entries from OPM:
+
+>>> p = PDBParser(source_db='opm', source_id='7f1r').parse()
+
+(Note that this fetches the sweet receptor with dummy atoms that denote locations of lipid headgroups.)
+
 >>> type(p.parsed)
 <class 'dict'>
 

{pidibble-1.4.2 → pidibble-1.5.1}/pidibble/baseparsers.py

@@ -87,7 +87,7 @@ class StringParser:
         self.fields={k:v for k,v in fmtdict.items()}
         self.allowed=allowed
 
-    def parse(self,record):
+    def parse(self, record):
         """
         Parse a fixed-width string record into a dictionary of fields.
         
@@ -104,7 +104,10 @@ class StringParser:
         if len(record)>80:
             logger.warning('The following record exceeds 80 bytes in length:')
             self.report_record_error(record)
-        assert len(record)<=80,f'Record is too long; something wrong with your PDB file?'
+            logger.warning('Stripping...')
+            record = record.strip()
+            if len(record)>80:
+               raise ValueError(f'Record is too long; something wrong with your PDB file?')
         input_dict={}
         record+=' '*(80-len(record)) # pad
         for k,v in self.fields.items():
@@ -141,7 +144,7 @@ class StringParser:
         """
         if byte_range:
             record=record[:byte_range[0]-1]+'\033[91m'+record[byte_range[0]:byte_range[1]+1]+'\033[0m'+record[byte_range[1]+1:]
-        repstr=_cols+'\n'+record
+        repstr=_cols+'\n'+record+'|'
         logger.warning(repstr)
         
     def report_field_error(self,record,k):

{pidibble-1.4.2 → pidibble-1.5.1}/pidibble/pdbparse.py

@@ -7,24 +7,27 @@
 .. moduleauthor: Cameron F. Abrams, <cfa22@drexel.edu>
 
 """
-import urllib.request
-import os
+import importlib.metadata
+import json
 import logging
+import os
+import urllib.request
 import yaml
+from typing import Callable
+
 import numpy as np
-from pathlib import Path
+
 from mmcif.io.IoAdapterCore import IoAdapterCore
+from pathlib import Path
+
 from . import resources
 from .baseparsers import ListParsers, ListParser, str2int_sig, safe_float
 from .baserecord import BaseRecordParser
 from .pdbrecord import PDBRecord, PDBRecordDict, PDBRecordList
 from .mmcif_parse import MMCIF_Parser
-from pidibble import resources
-logger=logging.getLogger(__name__)
-import importlib.metadata
-import json
 from .hex import str2atomSerial, hex_reset
 
+logger = logging.getLogger(__name__)
 __version__ = importlib.metadata.version("pidibble")
 
 class PDBParser:
@@ -50,46 +53,42 @@ class PDBParser:
         A dictionary containing the parsed mmCIF data. Empty if no input file is provided.
     """
     def __init__(self,
-                 input_format='PDB',
-                 overwrite=False,
-                 alphafold='',
-                 filepath: Path = None,
-                 mappers={'HxInteger':str2atomSerial,'Integer':str2int_sig,'String':str,'Float':safe_float},
-                 pdbcode_synonyms=['PDBcode','pdb_code','pdbCode','pdbcode','pdbID','pdb_id','pdbid','PDBID','PDBId','PDBid'],
-                 comment_chars=['#'],
-                 pdb_format_file='pdb_format.yaml',
-                 mmcif_format_file='mmcif_format.yaml',
+                 input_format: str = 'PDB',
+                 overwrite: bool = False,
+                 source_db: str = None,
+                 source_id: str = None,
+                 filepath: str | Path = None,
+                 mappers: dict[str, Callable] = {'HxInteger':str2atomSerial, 'Integer':str2int_sig, 'String':str, 'Float':safe_float},
+                 comment_chars: list[str] = ['#'],
+                 pdb_format_file: str ='pdb_format.yaml',
+                 mmcif_format_file: str = 'mmcif_format.yaml',
                  **kwargs):
         logger.debug(f'Pidibble v. {__version__}')
-        self.input_format=input_format
-        self.overwrite=overwrite
-        self.alphafold=alphafold
-        self.filepath=filepath
-        self.mappers=mappers
+        self.input_format = input_format
+        self.overwrite = overwrite
+        self.source_db = source_db
+        self.source_id = source_id
+        self.filepath = Path(filepath) if filepath else None
+        self.mappers = mappers
         self.mappers.update(ListParsers)
-        self.pdb_code=''
-        for k in pdbcode_synonyms:
-            if k in kwargs:
-                self.pdb_code=kwargs[k]
-                break
-        self.comment_chars=comment_chars
-        self.pdb_lines=[]
-        self.cif_data={}
+        self.comment_chars = comment_chars
+        self.pdb_lines = []
+        self.cif_data = {}
 
-        self.parsed=PDBRecordDict()
-        self.pdb_format_file=pdb_format_file
+        self.parsed = PDBRecordDict()
+        self.pdb_format_file = pdb_format_file
         if not os.path.isfile(self.pdb_format_file):
             # if pdb_format_file is not a file in the CWD, assume it is a relative path to the resources directory
             # this is useful for testing
-            self.pdb_format_file=os.path.join(os.path.dirname(resources.__file__),pdb_format_file)
-        self.mmcif_format_file=mmcif_format_file
+            self.pdb_format_file = os.path.join(os.path.dirname(resources.__file__), pdb_format_file)
+        self.mmcif_format_file = mmcif_format_file
         if not os.path.isfile(self.mmcif_format_file):
             # if mmcif_format_file is not a file in the CWD, assume it is a relative path to the resources directory
             # this is useful for testing
-            self.mmcif_format_file=os.path.join(os.path.dirname(resources.__file__),mmcif_format_file)
+            self.mmcif_format_file = os.path.join(os.path.dirname(resources.__file__), mmcif_format_file)
         if os.path.exists(self.pdb_format_file):
-            with open(self.pdb_format_file,'r') as f:
-                self.pdb_format_dict=yaml.safe_load(f)
+            with open(self.pdb_format_file, 'r') as f:
+                self.pdb_format_dict = yaml.safe_load(f)
                 logger.debug(f'Pidibble uses the installed config file {self.pdb_format_file}')
         else:
             raise FileNotFoundError(f'{self.pdb_format_file} not found, either locally ({os.getcwd()}) or in resources ({os.path.dirname(resources.__file__)})')
@@ -101,14 +100,14 @@ class PDBParser:
             raise FileNotFoundError(f'{self.mmcif_format_file} not found, either locally ({os.getcwd()}) or in resources ({os.path.dirname(resources.__file__)})')
 
         # update mappers with delimiters and custom formats
-        delimiter_dict=self.pdb_format_dict.get('delimiters',{})
+        delimiter_dict = self.pdb_format_dict.get('delimiters', {})
         for map,d in delimiter_dict.items():
             if not map in self.mappers:
-                self.mappers[map]=ListParser(d).parse
-        cformat_dict=self.pdb_format_dict.get('custom_formats',{})
+                self.mappers[map] = ListParser(d).parse
+        cformat_dict = self.pdb_format_dict.get('custom_formats', {})
         for cname,cformat in cformat_dict.items():
             if not cname in self.mappers:
-                self.mappers[cname]=BaseRecordParser(cformat,self.mappers).parse
+                self.mappers[cname] = BaseRecordParser(cformat, self.mappers).parse
             
     def fetch(self):
         """
@@ -121,60 +120,84 @@ class PDBParser:
         bool
             True if the file was successfully fetched, False otherwise.
         """
-        assert self.pdb_code!='' or self.alphafold!='' or self.filepath is not None, "PDB code or AlphaFold ID must be provided, or a path to a PDB file must be specified."
-        if self.pdb_code!='':
-            if self.input_format=='PDB':
-                self.filepath=f'{self.pdb_code}.pdb'
-            elif self.input_format=='mmCIF':
-                self.filepath=f'{self.pdb_code}.cif'
-            else:
-                logger.warning(f'Input format {self.input_format} not recognized; using PDB')
-                self.filepath=f'{self.pdb_code}.pdb'
-            BASE_URL=self.pdb_format_dict['BASE_URL']
-            target_url=os.path.join(BASE_URL,self.filepath)
-            if not os.path.exists(self.filepath) or self.overwrite:
+        assert self.source_db is not None or self.filepath is not None, f'source_db {self.source_db} or filepath {self.filepath} must be specified for fetch()'
+        if self.source_db is not None and self.source_id is None:
+            raise ValueError(f'You must specify a source ID code for source_db {self.source_db}')
+        if self.source_db is not None and self.source_db not in ['rcsb', 'alphafold', 'opm']:
+            raise ValueError(f'Source db {self.source_db} is not recognized.')
+        
+        if self.filepath is not None:
+            if not self.filepath.exists():
+                raise FileNotFoundError(f'{self.filepath.name} not found.')
+            return True
+        
+        match self.source_db:
+            case 'rcsb':
+                if self.input_format == 'PDB':
+                    self.filepath = Path(f'{self.source_id}.pdb')
+                elif self.input_format == 'mmCIF':
+                    self.filepath = Path(f'{self.source_id}.cif')
+                else:
+                    logger.warning(f'Input format {self.input_format} not recognized; using PDB')
+                    self.filepath = Path(f'{self.source_id}.pdb')
+                BASE_URL = self.pdb_format_dict['BASE_URL']
+                target_url = os.path.join(BASE_URL, self.filepath.name)
+                if not self.filepath.exists() or self.overwrite:
+                    try:
+                        urllib.request.urlretrieve(target_url, self.filepath.name)
+                    except:
+                        logger.warning(f'Could not fetch {self.filepath.name} from {self.source_db}')
+                        return False
+                return True
+            case 'alphafold':
+                self.filepath = Path(f'{self.source_id}.pdb')
+                BASE_URL = self.pdb_format_dict['ALPHAFOLD_API_URL']
+                target_url = os.path.join(BASE_URL, self.source_id)
                 try:
-                    urllib.request.urlretrieve(target_url,self.filepath)
+                    urllib.request.urlretrieve(target_url + r'?key=' + self.pdb_format_dict['ALPHAFOLD_API_KEY'], f'{self.source_id}.json')
                 except:
-                    logger.warning(f'Could not fetch {self.filepath}')
+                    logger.warning(f'Could not fetch metadata for entry with accession code {self.source_id} from AlphaFold')
                     return False
-            return True
-        elif self.alphafold!='':
-            self.filepath=f'{self.alphafold}.pdb'
-            BASE_URL=self.pdb_format_dict['ALPHAFOLD_API_URL']
-            target_url=os.path.join(BASE_URL,self.alphafold)
-            logger.debug(f'target url {target_url}')
-            try:
-                urllib.request.urlretrieve(target_url+r'?key='+self.pdb_format_dict['ALPHAFOLD_API_KEY'],f'{self.alphafold}.json')
-            except:
-                logger.warning(f'Could not fetch metadata for entry with accession code {self.alphafold} from AlphaFold')
-                return False
-            with open(f'{self.alphafold}.json') as f:
-                result=json.load(f)
-            try:
-                urllib.request.urlretrieve(result[0]['pdbUrl'],self.filepath)
-            except:
-                logger.warning(f'Could not retrieve {result[0]["pdbUrl"]}')
-                return False
-            return True
-        elif self.filepath is not None:
-            if not os.path.exists(self.filepath):
-                logger.warning(f'File {self.filepath} does not exist.')
+                with open(f'{self.source_id}.json') as f:
+                    result = json.load(f)
+                try:
+                    urllib.request.urlretrieve(result[0]['pdbUrl'], self.filepath.name)
+                except:
+                    logger.warning(f'Could not retrieve {result[0]["pdbUrl"]}')
+                    return False
+                return True
+            case 'opm':
+                self.filepath = Path(f'{self.source_id}.pdb')
+                BASE_URL = self.pdb_format_dict['OPM_URL']
+                target_url = os.path.join(BASE_URL, self.filepath.name)
+                if not self.filepath.exists() or self.overwrite:
+                    try:
+                        urllib.request.urlretrieve(target_url, self.filepath.name)
+                    except:
+                        logger.warning(f'Could not fetch {self.filepath.name} from {self.source_db}')
+                        return False
+                    logger.warning(f'Stripping blanks and END lines from OPM pdb')
+                    badlines = self.filepath.read_text().split('\n')
+                    with open(self.filepath.name, 'w') as f:
+                        for line in badlines:
+                            sline = line.strip()
+                            if not sline.startswith('END') and len(sline) > 0:
+                                f.write(sline+'\n')
+                return True
+            case '_':
+                logger.debug(f'Source db {self.source_db} is not recognized.')
                 return False
-            return True
-        else:
-            pass # assert statement at top of method body should suppress this branch
-
+            
     def read_PDB(self):
         """
         Read the PDB file and store its lines in :attr:`PDBParser.pdb_lines`.
         This method opens the PDB file, reads its contents, and splits it into lines.
         If the last line is empty, it removes it from the list of lines.
         """
-        with open(self.filepath,'r') as f:
-            self.pdb_lines=f.read().split('\n')
-            if self.pdb_lines[-1]=='':
-                self.pdb_lines=self.pdb_lines[:-1]
+        with open(self.filepath, 'r') as f:
+            self.pdb_lines = f.read().split('\n')
+            if self.pdb_lines[-1] == '':
+                self.pdb_lines = self.pdb_lines[:-1]
 
     def read_mmCIF(self):
         """
@@ -182,16 +205,16 @@ class PDBParser:
         This method uses the :class:`mmcif.io.IoAdapterCore.IoAdapterCore` to read the
         mmCIF file and store the data in :attr:`PDBParser.cif_data`.
         """
-        io=IoAdapterCore()
-        l_dc=io.readFile(self.filepath)
-        self.cif_data=l_dc[0]
+        io = IoAdapterCore()
+        l_dc = io.readFile(self.filepath)
+        self.cif_data = l_dc[0]
 
     def read(self):
         """
         Read the PDB or mmCIF file based on the input format.
         This method checks the input format and calls the appropriate read method.
         """
-        if self.input_format=='mmCIF':
+        if self.input_format == 'mmCIF':
             self.read_mmCIF()
         else:
             self.read_PDB()
@@ -203,7 +226,7 @@ class PDBParser:
         If the input format is mmCIF, it uses the :class:`.mmcif_parse.MMCIF_Parser` to parse the mmCIF data.
         If the input format is PDB, it uses the :class:`.pdbrecord.PDBRecord` class to parse the PDB lines.
         """
-        if self.input_format=='mmCIF':
+        if self.input_format == 'mmCIF':
             self.parse_mmCIF()
         else:
             self.parse_PDB()
@@ -214,8 +237,8 @@ class PDBParser:
         This method uses the :class:`.mmcif_parse.MMCIF_Parser` to parse the mmCIF data and store the parsed records
         in :attr:`PDBParser.parsed`.
         """
-        mmcif_parser=MMCIF_Parser(self.mmcif_format_dict,self.pdb_format_dict['record_formats'],self.cif_data)
-        self.parsed=mmcif_parser.parse()
+        mmcif_parser = MMCIF_Parser(self.mmcif_format_dict,self.pdb_format_dict['record_formats'],self.cif_data)
+        self.parsed = mmcif_parser.parse()
 
     def parse_PDB(self):
         """

{pidibble-1.4.2 → pidibble-1.5.1}/pidibble/resources/pdb_format.yaml

@@ -13,6 +13,7 @@
 BASE_URL: https://files.rcsb.org/download
 ALPHAFOLD_API_URL: https://alphafold.ebi.ac.uk/api/prediction
 ALPHAFOLD_API_KEY: AIzaSyCeurAJz7ZGjPQUtEaerUkBZ3TaBkXrY94
+OPM_URL: https://biomembhub.org/shared/opm-assets/pdb
 record_types:
   1: one-time-single-line
   2: one-time-multiple-line

{pidibble-1.4.2 → pidibble-1.5.1}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 [project]
 name = "pidibble"
-version = "1.4.2"
+version = "1.5.1"
 authors = [
   { name="Cameron F Abrams", email="cfa22@drexel.edu" },
 ]