pypdb 2.2__tar.gz → 2.4__tar.gz

pypdb-2.4/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: pypdb
+Version: 2.4
+Summary: A Python wrapper for the RCSB Protein Data Bank (PDB) API
+Home-page: https://github.com/williamgilpin/pypdb
+Download-URL: https://github.com/williamgilpin/pypdb/tarball/0.6
+Author: William Gilpin
+Author-email: firstnamelastname@gmail.com
+Keywords: protein,data,RESTful,api
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+
+# PyPDB
+
+A Python 3 toolkit for performing searches with the RCSB Protein Data Bank (PDB). This can be used to perform advanced searches for PDB IDs matching various criteria, as well as to look up information associated with specific PDB IDs. This tool allows standard operations that can be perfomed from within the PDB website (BLAST, PFAM lookup, etc.) to be performed from within Python scripts.
+
+If you use this module for any published work, please consider citing the accompanying paper
+
+      Gilpin, W. "PyPDB: A Python API for the Protein Data Bank."
+      Bioinformatics, Oxford Journals, 2016.
+
+## Installation
+
+Install using pip:
+
+    $ pip install pypdb
+
+To install the development version, which contains the latest features and fixes, install directly from GitHub using
+
+    $ pip install git+https://github.com/williamgilpin/pypdb
+
+If you need to  install directly from setup.py,
+
+    $ python setup.py install
+
+Test the installation, and check that the code successfully connects to the PDB, navigate to the root directory and run
+
+    $ pytest
+
+This code has been designed and tested for Python 3.
+
+## Usage
+
+### PDB Text Search
+This package can be used to get lists of PDB IDs associated with specific search terms, experiment types, structures, and other common criteria. To use the simple API, see the examples in [`demos/demos.ipynb`](demos/demos.ipynb). For advanced search and query logic, see the examples in [`search/EXAMPLES.md`](pypdb/clients/search/EXAMPLES.md).
+
+### PDB Data Fetch
+Given a list of PDBs, this package can be used to fetch data associated with those PDBs, including their dates of deposition, lists of authors and associated publications, their sequences or structures, their top BLAST matches, and other query-specific attributes like lists of a ligands or chemical structure.  To use the simple API, see the examples in [`demos/demos.ipynb`](demos/demos.ipynb). For advanced search and query logic, see the examples in [`data/EXAMPLES.md`](pypdb/clients/data/EXAMPLES.md).
+
+## Issues and Feature Requests
+
+If you run into an issue, or if you find a workaround for an existing issue, we would very much appreciate it if you could post your question or code as a GitHub issue.
+
+If posting a feature request, please check that your request is possible using [the current GUI on current RCSB website](https://www.rcsb.org/search/advanced). If so, please perform your search, and then click the link that says `JSON` in the upper right hand corner of the Advanced Search box. Please post that JSON code with your feature request.
+
+
+
+

{pypdb-2.2 → pypdb-2.4}/README.md

@@ -2,24 +2,20 @@
 
 A Python 3 toolkit for performing searches with the RCSB Protein Data Bank (PDB). This can be used to perform advanced searches for PDB IDs matching various criteria, as well as to look up information associated with specific PDB IDs. This tool allows standard operations that can be perfomed from within the PDB website (BLAST, PFAM lookup, etc.) to be performed from within Python scripts.
 
-Examples of each function and its associated output can be found in [`demos/demos.ipynb`](demos/demos.ipynb).
-
 If you use this module for any published work, please consider citing the accompanying paper
 
-      Gilpin, W. "PyPDB: A Python API for the Protein Data Bank." 
+      Gilpin, W. "PyPDB: A Python API for the Protein Data Bank."
       Bioinformatics, Oxford Journals, 2016.
 
-**We very much welcome contributors and pull requests**
-
 ## Installation
 
 Install using pip:
 
-	$ pip install pypdb
+    $ pip install pypdb
 
 To install the development version, which contains the latest features and fixes, install directly from GitHub using
 
-   	$ pip install git+git://github.com/williamgilpin/pypdb
+    $ pip install git+https://github.com/williamgilpin/pypdb
 
 If you need to  install directly from setup.py,
 
@@ -27,17 +23,17 @@ If you need to  install directly from setup.py,
 
 Test the installation, and check that the code successfully connects to the PDB, navigate to the root directory and run
 
-	$ pytest 
+    $ pytest
 
 This code has been designed and tested for Python 3.
 
 ## Usage
 
-This package can be used to get lists of PDB IDs associated with specific search terms, experiment types, structures, and other common criteria.
-
-Given a list of PDBs, this package can be used to fetch any data associated with those PDBs, including their dates of deposition, lists of authors and associated publications, their sequences or structures, their top BLAST matches, and other query-specific attributes like lists of a ligands or chemical structure.
+### PDB Text Search
+This package can be used to get lists of PDB IDs associated with specific search terms, experiment types, structures, and other common criteria. To use the simple API, see the examples in [`demos/demos.ipynb`](demos/demos.ipynb). For advanced search and query logic, see the examples in [`search/EXAMPLES.md`](pypdb/clients/search/EXAMPLES.md).
 
-A set of demos is included in the iPython notebook **demos.ipynb**. A static version of this notebook (for viewing) is available as **demos.html**
+### PDB Data Fetch
+Given a list of PDBs, this package can be used to fetch data associated with those PDBs, including their dates of deposition, lists of authors and associated publications, their sequences or structures, their top BLAST matches, and other query-specific attributes like lists of a ligands or chemical structure.  To use the simple API, see the examples in [`demos/demos.ipynb`](demos/demos.ipynb). For advanced search and query logic, see the examples in [`data/EXAMPLES.md`](pypdb/clients/data/EXAMPLES.md).
 
 ## Issues and Feature Requests
 

pypdb-2.4/pypdb/clients/data/data_types.py

@@ -0,0 +1,192 @@
+"""
+Class for data types that can be accessed in the PDB DATA-API
+https://data.rcsb.org/#data-organization
+
+Namely:
+- entry
+- polymer entity
+- branched entity
+- non-polymer entity
+- polymer instance
+- branched instance
+- non-polymer instance
+- assembly
+- chemical component
+(currently not implemented:)
+- PubMed integrated data
+- UniProt integrated data
+- DrugBank integrated data
+"""
+from dataclasses import dataclass, field
+from enum import Enum
+
+#TODO: handle batch requests
+
+from pypdb.clients.data.graphql.graphql import search_graphql
+
+class DataType(Enum):
+    ENTRY = "entries"
+    POLYMER_ENTITY = "polymer_entities"
+    BRANCHED_ENTITY = "branched_entities"
+    NONPOLYMER_ENTITY = "nonpolymer_entities"
+    POLYMER_ENTITY_INSTANCE = "polymer_entity_instances"
+    BRANCHED_ENTITY_INSTANCE = "branched_entity_instances"
+    NONPOLYMER_ENTITY_INSTANCE = "nonpolymer_entity_instances"
+    ASSEMBLY = "assemblies"
+    CHEMICAL_COMPONENT = "chem_comps"
+
+@dataclass
+class DataFetcher:
+    """
+    General class that will host various data types, as detailed above.
+    """
+
+    id: str | list
+    data_type: DataType
+
+    properties: dict = field(default_factory=dict)
+    json_query: dict = field(default_factory=dict)
+    response: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        """
+        Check types of IDs given, format accordingly.
+        """
+
+        if isinstance(self.id, str):
+            self.id = [self.id]
+
+        if "entit" in self.data_type.value and "instance" not in self.data_type.value:
+            for id in self.id:
+                if '_' not in id:
+                    print(f"WARNING: {id} not valid for {self.data_type.value}.")
+        elif "instance" in self.data_type.value:
+            for id in self.id:
+                if '.' not in id:
+                    print(f"WARNING: {id} not valid for {self.data_type.value}.")
+        elif self.data_type == DataType.ASSEMBLY:
+            for id in self.id:
+                if '-' not in id:
+                    print(f"WARNING: {id} not valid for {self.data_type.value}.")
+
+    def add_property(self, property):
+        """
+        Add property to the list of data to fetch from the PDB.
+
+        property is a python dict, with keys as properties, and
+        values as subproperties.
+
+        e.g.:
+
+        {"cell": ["volume", "angle_beta"], "exptl": ["method"]}
+
+        If the user is trying to add a property that already exists,
+        the subproperties are merged.
+        """
+        # check input data type
+        if not isinstance(property, dict):
+            raise TypeError
+        # check data types of keys in dict
+        if not all([isinstance(key, str) for key in property.keys()]):
+            raise TypeError
+        # check that values are lists of strings
+        for key, value in property.items():
+            if isinstance(value, str):
+                property[key] = [value]
+            elif not isinstance(value, list):
+                raise TypeError
+            else:
+                if not all([isinstance(val, str) for val in value]):
+                    raise TypeError
+
+        # add properties to the dict
+        for key, value in property.items():
+            if key not in self.properties:
+                self.properties[key] = value
+            else:
+                self.properties[key] += value
+                self.properties[key] = list(set(self.properties[key]))
+
+    def generate_json_query(self):
+        """
+        Given IDs, data type, and properties to fetch, create JSON query that
+        will utilize graphql.
+        """
+        if not self.properties:
+            print("ERROR: no properties given to generate JSON query.")
+            raise ValueError
+
+        if self.data_type == DataType.ENTRY:
+            q_str = "entry_ids"
+        elif "entit" in self.data_type.value:
+            if "instance" in self.data_type.value:
+                q_str = "instance_ids"
+            else:
+                q_str = "entity_ids"
+        elif self.data_type == DataType.ASSEMBLY:
+            q_str = "assembly_ids"
+        elif self.data_type == DataType.CHEMICAL_COMPONENT:
+            q_str = "comp_ids"
+
+        data_str = f"{self.data_type.value}({q_str}: [" + ",".join(f"\"{w}\"" for w in self.id) + "])"
+
+        props_string = ""
+        for key, val in self.properties.items():
+            if len(val) == 0:
+                props_string += f"{key},"
+            else:
+                props_string += f"{key} {{" + ",".join(val) + "}"
+
+        self.json_query = {'query': "{" + data_str + "{" + props_string + "}}"}
+
+
+    def fetch_data(self):
+        """
+        Once the JSON query is created, fetch data from the PDB, using graphql.
+        """
+        if not self.json_query:
+            self.generate_json_query()
+
+        response = search_graphql(self.json_query)
+
+        if "errors" in response:
+            print("ERROR encountered in fetch_data().")
+            for error in response['errors']:
+                print(error['message'])
+
+            return
+
+        self.response = response
+
+        if len(self.response['data'][self.data_type.value]) != len(self.id):
+            print("WARNING: one or more IDs not found in the PDB.")
+
+    def return_data_as_df_dict(self):
+        """
+        Return the fetched data as a dict usable by pandas or polars.
+        """
+        if not self.response:
+            return None
+
+        data = self.response['data'][self.data_type.value]
+
+        # flatten data dictionary by joining property and subproperty names
+        data_flat = {}
+        for i, entry in enumerate(data):
+            id = self.id[i]
+            curr_dict = {}
+            for key, values in entry.items():
+                if isinstance(values, list):
+                    v = values[0]
+                else:
+                    v = values
+                if isinstance(v, str):
+                    new_key = f"{key}"
+                    curr_dict[new_key] = v
+                else:
+                    for subprop, val in v.items():
+                        new_key = f"{key}.{subprop}"
+                        curr_dict[new_key] = val
+            data_flat[id] = curr_dict
+
+        return data_flat

pypdb-2.4/pypdb/clients/data/graphql/graphql.py

@@ -0,0 +1,35 @@
+"""Contains logic to perform arbitrary GraphQL searches against RCSB.
+
+For the differences between the GraphQL and RESTful searches, see:
+https://data.rcsb.org/index.html#gql-vs-rest
+"""
+import requests
+import  warnings
+from typing import Any  # DO NOT APPROVE: fix this to actual type
+
+RSCB_GRAPHQL_URL = "https://data.rcsb.org/graphql?query="
+
+
+def search_graphql(graphql_json_query: str) -> Any:
+    """Performs RCSB search with JSON query using GraphQL.
+
+    For details on what the RCSB GraphQL interface is, see:
+        https://data.rcsb.org/index.html#gql-api
+
+    This function should return the equivalent information as this site:
+        https://data.rcsb.org/graphql/index.html
+
+    Args:
+        graphql_json_query: GraphQL JSON query, as a string. Whitespace doesn't
+            matter. e.g. "{entry(entry_id:"4HHB"){exptl{method}}}"
+    """
+
+    response = requests.post(url=RSCB_GRAPHQL_URL,
+                             json=graphql_json_query)
+
+    if not response.ok:
+        warnings.warn(f"It appears request failed with: {response.text}")
+        response.raise_for_status()
+
+
+    return response.json()

pypdb-2.4/pypdb/clients/data/graphql/test_graphql.py

@@ -0,0 +1,25 @@
+"""Unit tests for RCSB DATA API Python wrapper."""
+import unittest
+from unittest import mock
+import requests
+
+from pypdb.clients.data.graphql import graphql
+
+class TestGraphQL(unittest.TestCase):
+    @mock.patch.object(requests, "post")
+    def test_simple_search(self, mock_post):
+        json_query = {'query': '{ entry(entry_id: "4HHB"){struct {title}} }'}
+        expected_return_json_as_dict = {'data': {'entry': {'struct': {'title': 'THE CRYSTAL STRUCTURE OF HUMAN DEOXYHAEMOGLOBIN AT 1.74 ANGSTROMS RESOLUTION'}}}}
+
+        mock_response = mock.create_autospec(requests.Response, instance=True)
+        mock_response.json.return_value = expected_return_json_as_dict
+        mock_post.return_value = mock_response
+
+        results = graphql.search_graphql(json_query)
+
+        mock_post.assert_called_once_with(url=graphql.RSCB_GRAPHQL_URL, json=json_query)
+        self.assertEqual(results, expected_return_json_as_dict)
+
+
+if __name__ == '__main__':
+    unittest.main()

pypdb-2.4/pypdb/clients/data/test_data_types.py

@@ -0,0 +1,122 @@
+"""
+Unit tests for the data_types classes.
+"""
+import unittest
+from unittest import mock
+import requests
+from pypdb.clients.data.graphql.graphql import RSCB_GRAPHQL_URL
+
+from pypdb.clients.data.data_types import DataFetcher, DataType
+
+class TestEntry(unittest.TestCase):
+    def test_create(self):
+        entry = DataFetcher("4HHB", DataType.ENTRY)
+
+        self.assertTrue(isinstance(entry.properties, dict))
+        self.assertTrue(not entry.properties)
+
+        self.assertTrue(isinstance(entry.json_query, dict))
+        self.assertTrue(not entry.json_query)
+
+        self.assertTrue(isinstance(entry.response, dict))
+        self.assertTrue(not entry.response)
+
+        self.assertEqual(entry.id, ["4HHB"])
+
+    def test_generate_json_query(self):
+        entry = DataFetcher("4HHB", DataType.ENTRY)
+
+        property = {"exptl":["method", "details"]}
+
+        entry.add_property(property)
+
+        self.assertIsNotNone(entry.properties)
+
+        entry.generate_json_query()
+
+        self.assertTrue(isinstance(entry.json_query, dict))
+        self.assertTrue("query" in entry.json_query)
+
+    def test_fetch_entry(self):
+        entry = DataFetcher("4HHB", DataType.ENTRY)
+        property = {"exptl":["method", "details"]}
+
+        entry.add_property(property)
+
+        entry.fetch_data()
+
+        self.assertTrue(entry.response)
+
+    def test_return_data_as_pandas_df(self):
+        entry = DataFetcher(["4HHB", "12CA", "3PQR"], DataType.ENTRY)
+        property = {"exptl":["method", "details"]}
+
+        entry.add_property(property)
+
+        entry.fetch_data()
+        df = entry.return_data_as_pandas_df()
+
+        self.assertTrue(df is not None)
+
+    def test_assembly_fetch(self):
+        assembly = DataFetcher(["4HHB-1", "12CA-1", "3PQR-1"], DataType.ASSEMBLY)
+        property = {"rcsb_assembly_info": ["entry_id", "assembly_id", "polymer_entity_instance_count"]}
+
+        assembly.add_property(property)
+        assembly.fetch_data()
+
+        self.assertFalse(not assembly.response)
+
+    def test_polymer_entity_fetch(self):
+        fetcher = DataFetcher(["2CPK_1","3WHM_1","2D5Z_1"], DataType.POLYMER_ENTITY)
+
+        property = {"rcsb_id": [], 
+                    "rcsb_entity_source_organism": ["ncbi_taxonomy_id", "ncbi_scientific_name"],
+                    "rcsb_cluster_membership": ["cluster_id", "identity"]}
+
+        fetcher.add_property(property)
+        fetcher.fetch_data()
+
+        self.assertFalse(not fetcher.response)
+
+        df = fetcher.return_data_as_pandas_df()
+        self.assertFalse(df is None)
+
+    def test_polymer_instance_fetch(self):
+        fetcher = DataFetcher(["4HHB.A", "12CA.A", "3PQR.A"], DataType.POLYMER_ENTITY_INSTANCE)
+        property = {"rcsb_id": [],
+                    "rcsb_polymer_instance_annotation": ["annotation_id", "name", "type"]}
+        fetcher.add_property(property)
+        fetcher.fetch_data()
+
+        self.assertFalse(not fetcher.response)
+
+        df = fetcher.return_data_as_pandas_df()
+        self.assertFalse(df is None)
+
+    def test_branched_entity_fetch(self):
+        fetcher = DataFetcher(["5FMB_2", "6L63_3"], DataType.BRANCHED_ENTITY)
+        property = {"pdbx_entity_branch": ["type"],
+                    "pdbx_entity_branch_descriptor": ["type", "descriptor"]}
+
+        fetcher.add_property(property)
+        fetcher.fetch_data()
+
+        self.assertFalse(not fetcher.response)
+
+        df = fetcher.return_data_as_pandas_df()
+        self.assertFalse(df is None)
+
+    def test_chem_comps_fetch(self):
+        fetcher = DataFetcher(["NAG","EBW"], DataType.CHEMICAL_COMPONENT)
+        property = {"rcsb_id":[], "chem_comp": ["type", "formula_weight","name","formula"],
+                    "rcsb_chem_comp_info":["initial_release_date"]}
+        fetcher.add_property(property)
+        fetcher.fetch_data()
+        self.assertFalse(not fetcher.response)
+
+        df = fetcher.return_data_as_pandas_df()
+        self.assertFalse(df is None)
+
+if __name__ == '__main__':
+    unittest.main()

{pypdb-2.2 → pypdb-2.4}/pypdb/clients/fasta/fasta_client.py

@@ -51,18 +51,22 @@ def _parse_fasta_text_to_list(raw_fasta_text: str) -> List[FastaSequence]:
     return fasta_list
 
 
-def get_fasta_from_rcsb_entry(rcsb_id: str) -> List[FastaSequence]:
+def get_fasta_from_rcsb_entry(rcsb_id: str,
+                              verbosity: bool = True,
+                              ) -> List[FastaSequence]:
     """Fetches FASTA sequence associated with PDB structure from RCSB.
 
     Args:
       rcsb_id: RCSB accession code of the structure of interest. E.g. `"5RU3"`
+      verbosity: Print out the search query to the console (default: True)
 
     Returns:
       Dictionary containing FASTA result, from polymer entity id to the
       `FastaSequence` object associated with that entity.
     """
 
-    print("Querying RCSB for the '{}' FASTA file.".format(rcsb_id))
+    if verbosity:
+        print("Querying RCSB for the '{}' FASTA file.".format(rcsb_id))
     response = requests.get(FASTA_BASE_URL + rcsb_id)
 
     if not response.ok:

{pypdb-2.2 → pypdb-2.4}/pypdb/clients/fasta/fasta_client_test.py

@@ -16,7 +16,7 @@ class TestFastaLogic(unittest.TestCase):
         mock_response.text = "fake_fasta_response"
         mock_get.return_value = mock_response
 
-        fasta_client.get_fasta_from_rcsb_entry("6TML")
+        fasta_client.get_fasta_from_rcsb_entry("6TML", verbosity=True)
         mock_get.assert_called_once_with(
             "https://www.rcsb.org/fasta/entry/6TML")
         mock_parse_fasta.assert_called_once_with("fake_fasta_response")

{pypdb-2.2 → pypdb-2.4}/pypdb/clients/search/operators/text_operators.py

@@ -169,7 +169,8 @@ class RangeOperator:
             "operator": "range",
             "attribute": self.attribute,
             "negation": self.negation,
-            "value": [self.from_value, self.to_value]
+            "value": {"from": self.from_value,
+                      "to": self.to_value},
         }
 
 

{pypdb-2.2 → pypdb-2.4}/pypdb/clients/search/search_client.py

@@ -132,7 +132,8 @@ def perform_search(
     return_type: ReturnType = ReturnType.ENTRY,
     request_options: Optional[RequestOptions] = None,
     return_with_scores: bool = False,
-    return_raw_json_dict: bool = False
+    return_raw_json_dict: bool = False,
+    verbosity: bool = True,
 ) -> Union[List[str], List[ScoredResult], RawJSONDictResponse]:
     """Performs search specified by `search_operator`.
     Returns entity strings of type `return_type` that match the resulting hits.
@@ -156,6 +157,7 @@ def perform_search(
             (if this is true, returns List[ScoredResult] instead of List[str])
         return_raw_json_dict: If True, this function returns the raw JSON
             response from RCSB, instead of a
+        verbosity: Print out the search query to the console (default: True)
 
     Returns:
         List of entity ids, corresponding to entities that match the given
@@ -184,7 +186,8 @@ def perform_search(
                                      return_type=return_type,
                                      request_options=request_options,
                                      return_with_scores=return_with_scores,
-                                     return_raw_json_dict=return_raw_json_dict)
+                                     return_raw_json_dict=return_raw_json_dict,
+                                     verbosity=verbosity)
 
 
 _SEARCH_OPERATORS = text_operators.TEXT_SEARCH_OPERATORS + [
@@ -197,7 +200,8 @@ def perform_search_with_graph(
     return_type: ReturnType = ReturnType.ENTRY,
     request_options: Optional[RequestOptions] = None,
     return_with_scores: bool = False,
-    return_raw_json_dict: bool = False
+    return_raw_json_dict: bool = False,
+    verbosity: bool = True,
 ) -> Union[List[str], RawJSONDictResponse, List[ScoredResult]]:
     """Performs specified search using RCSB's search node logic.
 
@@ -222,6 +226,7 @@ def perform_search_with_graph(
             get the top X hits that are similar to a certain protein sequence.
         return_raw_json_dict: Whether to return raw JSON response.
             (for example, to analyze the scores of various matches)
+        verbosity: Print out the search query to the console (default: True)
 
     Returns:
         List of strings, corresponding to hits in the database. Will be of the
@@ -234,6 +239,7 @@ def perform_search_with_graph(
     if type(query_object) in _SEARCH_OPERATORS:
         cast_query_object = _QueryNode(query_object)  # type: ignore
     else:
+        # print(type(query_object))
         cast_query_object = query_object  # type: ignore
 
     if request_options is not None:
@@ -247,8 +253,9 @@ def perform_search_with_graph(
         "return_type": return_type.value
     }
 
-    print("Querying RCSB Search using the following parameters:\n %s \n" %
-          json.dumps(rcsb_query_dict))
+    if verbosity:
+        print("Querying RCSB Search using the following parameters:\n %s \n" %
+              json.dumps(rcsb_query_dict))
 
     response = requests.post(url=SEARCH_URL_ENDPOINT,
                              data=json.dumps(rcsb_query_dict))

{pypdb-2.2 → pypdb-2.4}/pypdb/pypdb.py

@@ -17,7 +17,6 @@ If you find this code useful, please consider citing the paper:
 '''
 from collections import OrderedDict, Counter
 from itertools import repeat, chain
-import requests
 import time
 import re
 import json
@@ -139,6 +138,9 @@ class Query(object):
         elif query_type == "pfam":
             query_type = "text"
             query_subtype = "pfam"
+        elif query_type == "uniprot":
+            query_type = "text"
+            query_subtype = "uniprot"
         else:
             query_subtype = None
 
@@ -258,6 +260,14 @@ class Query(object):
                         "attribute":
                         "rcsb_polymer_entity_annotation.annotation_id"
                     }
+                if query_subtype == "uniprot":
+                    query_params['parameters'] = {
+                        "operator": "exact_match",
+                        "negation": False,
+                        "value": str(search_term),
+                        "attribute": 
+                        "rcsb_polymer_entity_container_identifiers.reference_sequence_identifiers.database_accession"
+                        }
 
             self.scan_params = dict()
             self.scan_params["query"] = query_params
@@ -489,13 +499,13 @@ def get_pdb_file(pdb_id: str, filetype='pdb', compression=False):
         "See `pypdb/clients/pdb/pdb_client.py` for a near-identical "
         "function to use", DeprecationWarning)
 
-    if filetype is 'pdb':
+    if filetype == 'pdb':
         filetype_enum = pdb_client.PDBFileType.PDB
-    elif filetype is 'cif':
+    elif filetype == 'cif':
         filetype_enum = pdb_client.PDBFileType.CIF
-    elif filetype is 'xml':
+    elif filetype == 'xml':
         filetype_enum = pdb_client.PDBFileType.XML
-    elif filetype is 'structfact':
+    elif filetype == 'structfact':
         filetype_enum = pdb_client.PDBFileType.STRUCTFACT
     else:
         warnings.warn(
@@ -505,14 +515,14 @@ def get_pdb_file(pdb_id: str, filetype='pdb', compression=False):
 
 
 # https://data.rcsb.org/migration-guide.html#chem-comp-description
-# def describe_chemical(chem_id):
+def describe_chemical(chem_id):
 #     """
 
 #     Parameters
 #     ----------
 
 #     chem_id : string
-#         A 4 character string representing the full chemical sequence of interest (ie, NAG)
+#         A 3 character string representing the full chemical sequence of interest (ie, NAG)
 
 #     Returns
 #     -------
@@ -523,19 +533,13 @@ def get_pdb_file(pdb_id: str, filetype='pdb', compression=False):
 #     Examples
 #     --------
 #     >>> chem_desc = describe_chemical('NAG')
-#     >>> print(chem_desc)
-#     {'describeHet': {'ligandInfo': {'ligand': {'@molecularWeight': '221.208',
-#     'InChIKey': 'OVRNDRQMDRJTHS-FMDGEEDCSA-N', '@type': 'D-saccharide',
-#     'chemicalName': 'N-ACETYL-D-GLUCOSAMINE', '@chemicalID': 'NAG',
-#     'smiles': 'CC(=O)N[C@@H]1[C@H]([C@@H]([C@H](O[C@H]1O)CO)O)O', '
-#     InChI': 'InChI=1S/C8H15NO6/c1-3(11)9-5-7(13)6(12)4(2-10)15-8(5)14/
-#     h4-8,10,12-14H,2H2,1H3,(H,9,11)/t4-,5-,6-,7-,8-/m1/s1',
-#     'formula': 'C8 H15 N O6'}}}}
-
+#     >>> print(chem_desc["rcsb_chem_comp_descriptor"]["smiles"])
+#     'CC(=O)NC1C(C(C(OC1O)CO)O)O'
 #     """
-#     out = get_info(chem_id, url_root = 'http://www.rcsb.org/pdb/rest/describeHet?chemicalID=')
-#     out = to_dict(out)
-#     return out
+    if (len(chem_id) > 3):
+        raise Exception("Ligand id with more than 3 characters provided")
+
+    return get_info(chem_id, url_root = 'https://data.rcsb.org/rest/v1/core/chemcomp/')
 
 # def get_ligands(pdb_id):
 #     """Return ligands of given PDB ID
@@ -653,7 +657,7 @@ def get_pdb_file(pdb_id: str, filetype='pdb', compression=False):
 #     return remove_at_sign(out['sequenceCluster'])
 
 
-def get_blast(pdb_id, chain_id='A', identity_cutoff=0.99):
+def get_blast(pdb_id, chain_id='A', identity_cutoff=0.99, verbosity=True):
     """
     ---
     WARNING: this function is deprecated and slated to be deleted due to RCSB

pypdb-2.4/pypdb.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.1
+Name: pypdb
+Version: 2.4
+Summary: A Python wrapper for the RCSB Protein Data Bank (PDB) API
+Home-page: https://github.com/williamgilpin/pypdb
+Download-URL: https://github.com/williamgilpin/pypdb/tarball/0.6
+Author: William Gilpin
+Author-email: firstnamelastname@gmail.com
+Keywords: protein,data,RESTful,api
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+
+# PyPDB
+
+A Python 3 toolkit for performing searches with the RCSB Protein Data Bank (PDB). This can be used to perform advanced searches for PDB IDs matching various criteria, as well as to look up information associated with specific PDB IDs. This tool allows standard operations that can be perfomed from within the PDB website (BLAST, PFAM lookup, etc.) to be performed from within Python scripts.
+
+If you use this module for any published work, please consider citing the accompanying paper
+
+      Gilpin, W. "PyPDB: A Python API for the Protein Data Bank."
+      Bioinformatics, Oxford Journals, 2016.
+
+## Installation
+
+Install using pip:
+
+    $ pip install pypdb
+
+To install the development version, which contains the latest features and fixes, install directly from GitHub using
+
+    $ pip install git+https://github.com/williamgilpin/pypdb
+
+If you need to  install directly from setup.py,
+
+    $ python setup.py install
+
+Test the installation, and check that the code successfully connects to the PDB, navigate to the root directory and run
+
+    $ pytest
+
+This code has been designed and tested for Python 3.
+
+## Usage
+
+### PDB Text Search
+This package can be used to get lists of PDB IDs associated with specific search terms, experiment types, structures, and other common criteria. To use the simple API, see the examples in [`demos/demos.ipynb`](demos/demos.ipynb). For advanced search and query logic, see the examples in [`search/EXAMPLES.md`](pypdb/clients/search/EXAMPLES.md).
+
+### PDB Data Fetch
+Given a list of PDBs, this package can be used to fetch data associated with those PDBs, including their dates of deposition, lists of authors and associated publications, their sequences or structures, their top BLAST matches, and other query-specific attributes like lists of a ligands or chemical structure.  To use the simple API, see the examples in [`demos/demos.ipynb`](demos/demos.ipynb). For advanced search and query logic, see the examples in [`data/EXAMPLES.md`](pypdb/clients/data/EXAMPLES.md).
+
+## Issues and Feature Requests
+
+If you run into an issue, or if you find a workaround for an existing issue, we would very much appreciate it if you could post your question or code as a GitHub issue.
+
+If posting a feature request, please check that your request is possible using [the current GUI on current RCSB website](https://www.rcsb.org/search/advanced). If so, please perform your search, and then click the link that says `JSON` in the upper right hand corner of the Advanced Search box. Please post that JSON code with your feature request.
+
+
+
+

{pypdb-2.2 → pypdb-2.4}/pypdb.egg-info/SOURCES.txt

@@ -13,6 +13,11 @@ pypdb.egg-info/top_level.txt
 pypdb.egg-info/.ipynb_checkpoints/dependency_links-checkpoint.txt
 pypdb/clients/__init__.py
 pypdb/clients/data/__init__.py
+pypdb/clients/data/data_types.py
+pypdb/clients/data/test_data_types.py
+pypdb/clients/data/graphql/__init__.py
+pypdb/clients/data/graphql/graphql.py
+pypdb/clients/data/graphql/test_graphql.py
 pypdb/clients/fasta/__init__.py
 pypdb/clients/fasta/fasta_client.py
 pypdb/clients/fasta/fasta_client_test.py
@@ -22,6 +27,7 @@ pypdb/clients/pdb/pdb_client_test.py
 pypdb/clients/search/__init__.py
 pypdb/clients/search/search_client.py
 pypdb/clients/search/search_client_test.py
+pypdb/clients/search/operators/__init__.py
 pypdb/clients/search/operators/chemical_operators.py
 pypdb/clients/search/operators/chemical_operators_test.py
 pypdb/clients/search/operators/seqmotif_operators.py
@@ -34,4 +40,5 @@ pypdb/clients/search/operators/text_operators.py
 pypdb/clients/search/operators/text_operators_test.py
 pypdb/util/__init__.py
 pypdb/util/http_requests.py
-pypdb/util/test_http_requests.py
+pypdb/util/test_http_requests.py
+tests/test_pypdb.py

{pypdb-2.2 → pypdb-2.4}/setup.py

@@ -1,5 +1,10 @@
 from setuptools import setup
 
+# read the contents of the README file so that PyPI can use it as the long description                               
+from pathlib import Path
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text()
+
 modules_list = [
     "pypdb",
     "pypdb.util",
@@ -7,6 +12,7 @@ modules_list = [
     "pypdb.clients.search",
     "pypdb.clients.search.operators",
     "pypdb.clients.data",
+    "pypdb.clients.data.graphql",
     "pypdb.clients.fasta",
     "pypdb.clients.pdb",
 ]
@@ -15,7 +21,7 @@ setup(
     name='pypdb',
     packages=modules_list,  # same as 'name'
     py_modules=modules_list,
-    version='2.02',
+    version='2.04',
     install_requires=['requests'],
     description='A Python wrapper for the RCSB Protein Data Bank (PDB) API',
     author='William Gilpin',
@@ -24,4 +30,6 @@ setup(
     download_url='https://github.com/williamgilpin/pypdb/tarball/0.6',
     keywords=['protein', 'data', 'RESTful', 'api'],
     classifiers=[],
+    long_description=long_description,
+    long_description_content_type='text/markdown'
 )

pypdb-2.4/tests/test_pypdb.py

@@ -0,0 +1,67 @@
+import unittest
+
+## Import from local directory
+import sys
+sys.path.insert(0, '../pypdb')
+from pypdb import *
+
+# TODO(ejwilliams): Write generic logic, to execute `test_*.py` files
+# within the pypdb directory (removing need for sys.path hack)
+
+# aa_index[s] for s in seq_dict[k] if s in aa_index.keys()]
+
+class TestSearchFunctions(unittest.TestCase):
+
+    def test_searchterm(self):
+        found_pdbs = Query('ribosome').search()
+        self.assertTrue(len(found_pdbs) > 0)
+        self.assertTrue(type(found_pdbs[0]) == str)
+
+        # an error page would be a longer string
+        self.assertTrue(len(found_pdbs[0]) < 10)
+
+    def test_pubmed(self):
+        found_pdbs = Query(27499440, "PubmedIdQuery").search()
+        self.assertTrue(len(found_pdbs) > 0)
+
+    def test_treeentity(self):
+        found_pdbs = Query('6239', 'TreeEntityQuery').search()
+        self.assertTrue(len(found_pdbs) > 0)
+
+    def test_exptype(self):
+        found_pdbs = Query('SOLID-STATE NMR', 'ExpTypeQuery').search()
+        self.assertTrue(len(found_pdbs) > 0)
+
+    def test_structure(self):
+        found_pdbs = Query('2E8D', 'structure').search()
+        self.assertTrue(len(found_pdbs) > 0)
+
+    def test_advancedauthor(self):
+        found_pdbs = Query('Perutz, M.F.', 'AdvancedAuthorQuery').search()
+        self.assertTrue(len(found_pdbs) > 0)
+
+    def test_organism(self):
+        found_pdbs = Query('Dictyostelium', 'OrganismQuery').search()
+        self.assertTrue(len(found_pdbs) > 0)
+
+    
+
+    # def test_blast(self):
+    #     found_pdbs = blast_from_sequence(
+    #         'MTKIANKYEVIDNVEKLEKALKRLREAQSVYATYTQEQVDKIFFEAAMAANKMRIPLAKMAVE'
+    #         + 'ETGMGVVEDKVIKNHYASEYIYNAYKNTKTCGVIEEDPAFGIKKIAEPLGVIAAVIPTTNP'
+    #         + 'TSTAIFKTLIALKTRNAIIISPHPRAKNSTIEAAKIVLEAAVKAGAPEGIIGWIDVPSLEL'
+    #         + 'TNLVMREADVILATGGPGLVKAAYSSGKPAIGVGAGNTPAIIDDSADIVLAVNSIIHSKTF'
+    #         + 'DNGMICASEQSVIVLDGVYKEVKKEFEKRGCYFLNEDETEKVRKTIIINGALNAKIVGQKA'
+    #         + 'HTIANLAGFEVPETTKILIGEVTSVDISEEFAHEKLCPVLAMYRAKDFDDALDKAERLVAD'
+    #         + 'GGFGHTSSLYIDTVTQKEKLQKFSERMKTCRILVNTPSSQGGIGDLYNFKLAPSL',
+    #         1e-20)
+    #     self.assertTrue(len(found_pdbs) > 0)
+    #     self.assertTrue(type(found_pdbs[0][0]) == str)
+
+    #     # an error page would be a longer string
+    #     self.assertTrue(len(found_pdbs[0][0]) < 10)
+
+
+if __name__ == '__main__':
+    unittest.main()

pypdb-2.2/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: pypdb
-Version: 2.2
-Summary: A Python wrapper for the RCSB Protein Data Bank (PDB) API
-Home-page: https://github.com/williamgilpin/pypdb
-Download-URL: https://github.com/williamgilpin/pypdb/tarball/0.6
-Author: William Gilpin
-Author-email: firstnamelastname@gmail.com
-License: UNKNOWN
-Keywords: protein,data,RESTful,api
-Platform: UNKNOWN
-License-File: LICENSE
-
-UNKNOWN
-

pypdb-2.2/pypdb.egg-info/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: pypdb
-Version: 2.2
-Summary: A Python wrapper for the RCSB Protein Data Bank (PDB) API
-Home-page: https://github.com/williamgilpin/pypdb
-Download-URL: https://github.com/williamgilpin/pypdb/tarball/0.6
-Author: William Gilpin
-Author-email: firstnamelastname@gmail.com
-License: UNKNOWN
-Keywords: protein,data,RESTful,api
-Platform: UNKNOWN
-License-File: LICENSE
-
-UNKNOWN
-