biotite 0.41.2__cp310-cp310-macosx_11_0_arm64.whl → 1.0.0__cp310-cp310-macosx_11_0_arm64.whl

biotite/database/entrez/download.py

@@ -6,22 +6,28 @@ __name__ = "biotite.database.entrez"
 __author__ = "Patrick Kunzmann"
 __all__ = ["fetch", "fetch_single_file"]
 
-from os.path import isdir, isfile, join, getsize
-import os
-import glob
 import io
+import os
+from os.path import getsize, isdir, isfile, join
 import requests
-from .check import check_for_errors
-from .dbnames import sanitize_database_name
-from .key import get_api_key
-from ..error import RequestError
-
+from biotite.database.entrez.check import check_for_errors
+from biotite.database.entrez.dbnames import sanitize_database_name
+from biotite.database.entrez.key import get_api_key
+from biotite.database.error import RequestError
 
 _fetch_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi"
 
 
-def fetch(uids, target_path, suffix, db_name, ret_type,
-          ret_mode="text", overwrite=False, verbose=False):
+def fetch(
+    uids,
+    target_path,
+    suffix,
+    db_name,
+    ret_type,
+    ret_mode="text",
+    overwrite=False,
+    verbose=False,
+):
     """
     Download files from the NCBI Entrez database in various formats.
 
@@ -111,31 +117,28 @@ def fetch(uids, target_path, suffix, db_name, ret_type,
             file = join(target_path, id + "." + suffix)
         else:
             file = None
-        if file is None \
-           or not isfile(file) \
-           or getsize(file) == 0 \
-           or overwrite:
-                param_dict = {
-                    "db" : sanitize_database_name(db_name),
-                    "id" : id,
-                    "rettype" : ret_type,
-                    "retmode" : ret_mode,
-                    "tool" : "Biotite",
-                    "mail" : "padix.key@gmail.com"
-                }
-                api_key = get_api_key()
-                if api_key is not None:
-                    param_dict["api_key"] = api_key
-                r = requests.get(_fetch_url, params=param_dict)
-                content = r.text
-                check_for_errors(content)
-                if content.startswith(" Error"):
-                    raise RequestError(content[8:])
-                if file is None:
-                    file = io.StringIO(content)
-                else:
-                    with open(file, "w+") as f:
-                        f.write(content)
+        if file is None or not isfile(file) or getsize(file) == 0 or overwrite:
+            param_dict = {
+                "db": sanitize_database_name(db_name),
+                "id": id,
+                "rettype": ret_type,
+                "retmode": ret_mode,
+                "tool": "Biotite",
+                "mail": "padix.key@gmail.com",
+            }
+            api_key = get_api_key()
+            if api_key is not None:
+                param_dict["api_key"] = api_key
+            r = requests.get(_fetch_url, params=param_dict)
+            content = r.text
+            check_for_errors(content)
+            if content.startswith(" Error"):
+                raise RequestError(content[8:])
+            if file is None:
+                file = io.StringIO(content)
+            else:
+                with open(file, "w+") as f:
+                    f.write(content)
         files.append(file)
     if verbose:
         print("\nDone")
@@ -146,8 +149,9 @@ def fetch(uids, target_path, suffix, db_name, ret_type,
         return files
 
 
-def fetch_single_file(uids, file_name, db_name, ret_type, ret_mode="text",
-                      overwrite=False):
+def fetch_single_file(
+    uids, file_name, db_name, ret_type, ret_mode="text", overwrite=False
+):
     """
     Almost the same as :func:`fetch()`, but the data for the given UIDs
     will be stored in a single file.
@@ -188,24 +192,26 @@ def fetch_single_file(uids, file_name, db_name, ret_type, ret_mode="text",
     --------
     fetch
     """
-    if file_name is not None \
-       and os.path.isfile(file_name) \
-       and getsize(file_name) > 0 \
-       and not overwrite:
-            # Do no redownload the already existing file
-            return file_name
+    if (
+        file_name is not None
+        and os.path.isfile(file_name)
+        and getsize(file_name) > 0
+        and not overwrite
+    ):
+        # Do no redownload the already existing file
+        return file_name
     uid_list_str = ""
     for id in uids:
         uid_list_str += id + ","
     # Remove terminal comma
     uid_list_str = uid_list_str[:-1]
     param_dict = {
-        "db" : sanitize_database_name(db_name),
-        "id" : uid_list_str,
-        "rettype" : ret_type,
-        "retmode" : ret_mode,
-        "tool" : "Biotite",
-        "mail" : "padix.key@gmail.com"
+        "db": sanitize_database_name(db_name),
+        "id": uid_list_str,
+        "rettype": ret_type,
+        "retmode": ret_mode,
+        "tool": "Biotite",
+        "mail": "padix.key@gmail.com",
     }
     api_key = get_api_key()
     if api_key is not None:

biotite/database/entrez/key.py

@@ -41,4 +41,4 @@ def set_api_key(key):
         The API key.
     """
     global _API_KEY
-    _API_KEY = key
+    _API_KEY = key

biotite/database/entrez/query.py

@@ -6,22 +6,23 @@ __name__ = "biotite.database.entrez"
 __author__ = "Patrick Kunzmann"
 __all__ = ["Query", "SimpleQuery", "CompositeQuery", "search"]
 
-import requests
 import abc
 from xml.etree import ElementTree
-from .check import check_for_errors
-from .dbnames import sanitize_database_name
-from ..error import RequestError
-from .key import get_api_key
-
+import requests
+from biotite.database.entrez.check import check_for_errors
+from biotite.database.entrez.dbnames import sanitize_database_name
+from biotite.database.entrez.key import get_api_key
+from biotite.database.error import RequestError
 
 _search_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
 
+
 class Query(metaclass=abc.ABCMeta):
     """
     Base class for a wrapper around a search term
     for the NCBI Entrez search service.
     """
+
     def __init__(self):
         pass
 
@@ -85,7 +86,6 @@ class CompositeQuery(Query):
         return "({:}) {:} ({:})".format(str(self._q1), self._op, self._q2)
 
 
-
 class SimpleQuery(Query):
     """
     A simple query for the NCBI Entrez search service without
@@ -121,17 +121,59 @@ class SimpleQuery(Query):
     # Field identifiers are taken from
     # https://www.ncbi.nlm.nih.gov/books/NBK49540/
     _fields = [
-        "Accession", "All Fields", "Author", "EC/RN Number", "Feature Key",
-        "Filter", "Gene Name", "Genome Project", "Issue", "Journal", "Keyword",
-        "Modification Date", "Molecular Weight", "Organism", "Page Number",
-        "Primary Accession", "Properties", "Protein Name", "Publication Date",
-        "SeqID String", "Sequence Length", "Substance Name", "Text Word",
-        "Title", "Volume",
+        "Accession",
+        "All Fields",
+        "Author",
+        "EC/RN Number",
+        "Feature Key",
+        "Filter",
+        "Gene Name",
+        "Genome Project",
+        "Issue",
+        "Journal",
+        "Keyword",
+        "Modification Date",
+        "Molecular Weight",
+        "Organism",
+        "Page Number",
+        "Primary Accession",
+        "Properties",
+        "Protein Name",
+        "Publication Date",
+        "SeqID String",
+        "Sequence Length",
+        "Substance Name",
+        "Text Word",
+        "Title",
+        "Volume",
         # Abbreviations
-        "ACCN", "ALL", "AU", "AUTH", "ECNO", "FKEY", "FILT", "SB", "GENE",
-        "ISS", "JOUR", "KYWD", "MDAT", "MOLWT", "ORGN", "PAGE", "PACC",
-        "PORGN", "PROP", "PROT", "PDAT", "SQID", "SLEN", "SUBS", "WORD",  "TI",
-        "TITL" "VOL"
+        "ACCN",
+        "ALL",
+        "AU",
+        "AUTH",
+        "ECNO",
+        "FKEY",
+        "FILT",
+        "SB",
+        "GENE",
+        "ISS",
+        "JOUR",
+        "KYWD",
+        "MDAT",
+        "MOLWT",
+        "ORGN",
+        "PAGE",
+        "PACC",
+        "PORGN",
+        "PROP",
+        "PROT",
+        "PDAT",
+        "SQID",
+        "SLEN",
+        "SUBS",
+        "WORD",
+        "TI",
+        "TITL" "VOL",
     ]
 
     def __init__(self, term, field=None):
@@ -139,12 +181,9 @@ class SimpleQuery(Query):
         if field is not None:
             if field not in SimpleQuery._fields:
                 raise ValueError(f"Unknown field identifier '{field}'")
-        for invalid_string in \
-            ['"', "AND", "OR", "NOT", "[", "]", "(", ")", "\t", "\n"]:
-                if invalid_string in term:
-                    raise ValueError(
-                        f"Query contains illegal term {invalid_string}"
-                    )
+        for invalid_string in ['"', "AND", "OR", "NOT", "[", "]", "(", ")", "\t", "\n"]:
+            if invalid_string in term:
+                raise ValueError(f"Query contains illegal term {invalid_string}")
         if " " in term:
             # Encapsulate in quotes if spaces are in search term
             term = f'"{term}"'

biotite/database/error.py

@@ -12,4 +12,5 @@ class RequestError(Exception):
     Indicates that the database returned a response with an error
     message or other malformed content.
     """
-    pass
+
+    pass

biotite/database/pubchem/__init__.py

@@ -18,4 +18,4 @@ __author__ = "Patrick Kunzmann"
 
 from .download import *
 from .query import *
-from .throttle import *
+from .throttle import *

biotite/database/pubchem/download.py

@@ -6,24 +6,29 @@ __name__ = "biotite.database.pubchem"
 __author__ = "Patrick Kunzmann"
 __all__ = ["fetch", "fetch_property"]
 
+import io
 import numbers
-import requests
-from os.path import isdir, isfile, join, getsize
 import os
-import io
-import numpy as np
-from .throttle import ThrottleStatus
-from .error import parse_error_details
-from ..error import RequestError
-
+from os.path import getsize, isdir, isfile, join
+import requests
+from biotite.database.error import RequestError
+from biotite.database.pubchem.error import parse_error_details
+from biotite.database.pubchem.throttle import ThrottleStatus
 
 _base_url = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/"
 _binary_formats = ["png", "asnb"]
 
 
-def fetch(cids, format="sdf", target_path=None, as_structural_formula=False,
-          overwrite=False, verbose=False,
-          throttle_threshold=0.5, return_throttle_status=False):
+def fetch(
+    cids,
+    format="sdf",
+    target_path=None,
+    as_structural_formula=False,
+    overwrite=False,
+    verbose=False,
+    throttle_threshold=0.5,
+    return_throttle_status=False,
+):
     """
     Download structure files from *PubChem* in various formats.
 
@@ -109,8 +114,7 @@ def fetch(cids, format="sdf", target_path=None, as_structural_formula=False,
             raise TypeError("CIDs must be given as integers, not as string")
         # Verbose output
         if verbose:
-            print(f"Fetching file {i+1:d} / {len(cids):d} ({cid})...",
-                  end="\r")
+            print(f"Fetching file {i+1:d} / {len(cids):d} ({cid})...", end="\r")
 
         # Fetch file from database
         if target_path is not None:
@@ -119,36 +123,33 @@ def fetch(cids, format="sdf", target_path=None, as_structural_formula=False,
             # 'file = None' -> store content in a file-like object
             file = None
 
-        if file is None \
-           or not isfile(file) \
-           or getsize(file) == 0 \
-           or overwrite:
-                record_type = "2d" if as_structural_formula else "3d"
-                r = requests.get(
-                    _base_url + f"compound/cid/{cid}/{format.upper()}",
-                    params={"record_type": record_type}
-                )
-                if not r.ok:
-                    raise RequestError(parse_error_details(r.text))
+        if file is None or not isfile(file) or getsize(file) == 0 or overwrite:
+            record_type = "2d" if as_structural_formula else "3d"
+            r = requests.get(
+                _base_url + f"compound/cid/{cid}/{format.upper()}",
+                params={"record_type": record_type},
+            )
+            if not r.ok:
+                raise RequestError(parse_error_details(r.text))
 
-                if format.lower() in _binary_formats:
-                    content = r.content
-                else:
-                    content = r.text
+            if format.lower() in _binary_formats:
+                content = r.content
+            else:
+                content = r.text
 
-                if file is None:
-                    if format in _binary_formats:
-                        file = io.BytesIO(content)
-                    else:
-                        file = io.StringIO(content)
+            if file is None:
+                if format in _binary_formats:
+                    file = io.BytesIO(content)
                 else:
-                    mode = "wb+" if format in _binary_formats else "w+"
-                    with open(file, mode) as f:
-                        f.write(content)
+                    file = io.StringIO(content)
+            else:
+                mode = "wb+" if format in _binary_formats else "w+"
+                with open(file, mode) as f:
+                    f.write(content)
 
-                throttle_status = ThrottleStatus.from_response(r)
-                if throttle_threshold is not None:
-                    throttle_status.wait_if_busy(throttle_threshold)
+            throttle_status = ThrottleStatus.from_response(r)
+            if throttle_threshold is not None:
+                throttle_status.wait_if_busy(throttle_threshold)
 
         files.append(file)
     if verbose:
@@ -164,8 +165,7 @@ def fetch(cids, format="sdf", target_path=None, as_structural_formula=False,
         return return_value
 
 
-def fetch_property(cids, name,
-                   throttle_threshold=0.5, return_throttle_status=False):
+def fetch_property(cids, name, throttle_threshold=0.5, return_throttle_status=False):
     """
     Download the given property for the given CID(s).
 
@@ -230,15 +230,13 @@ def fetch_property(cids, name,
 
     # Property names may only contain letters and numbers
     if not name.isalnum():
-        raise ValueError(
-            f"Property '{name}' contains invalid characters"
-        )
+        raise ValueError(f"Property '{name}' contains invalid characters")
 
     # Use TXT format instead of CSV to avoid issues with ',' characters
     # within table elements
     r = requests.post(
         _base_url + f"compound/cid/property/{name}/TXT",
-        data={"cid": ','.join([str(cid) for cid in cids])}
+        data={"cid": ",".join([str(cid) for cid in cids])},
     )
     if not r.ok:
         raise RequestError(parse_error_details(r.text))

biotite/database/pubchem/error.py

@@ -15,6 +15,6 @@ def parse_error_details(response_text):
     for message_line_indicator in ["Detail: ", "Message: "]:
         for line in response_text.splitlines():
             if line.startswith(message_line_indicator):
-                return line[len(message_line_indicator):]
+                return line[len(message_line_indicator) :]
     # No 'Detail: ...' or 'Message: ' line found
-    return "Unknown error"
+    return "Unknown error"

biotite/database/pubchem/query.py

@@ -4,20 +4,28 @@
 
 __name__ = "biotite.database.pubchem"
 __author__ = "Patrick Kunzmann"
-__all__ = ["Query", "NameQuery", "SmilesQuery", "InchiQuery", "InchiKeyQuery",
-           "FormulaQuery", "SuperstructureQuery", "SubstructureQuery",
-           "SimilarityQuery", "IdentityQuery",
-           "search"]
+__all__ = [
+    "Query",
+    "NameQuery",
+    "SmilesQuery",
+    "InchiQuery",
+    "InchiKeyQuery",
+    "FormulaQuery",
+    "SuperstructureQuery",
+    "SubstructureQuery",
+    "SimilarityQuery",
+    "IdentityQuery",
+    "search",
+]
 
-import copy
 import abc
 import collections
+import copy
 import requests
-from .error import parse_error_details
-from .throttle import ThrottleStatus
-from ..error import RequestError
-from ...structure.io.mol.mol import MOLFile
-
+from biotite.database.error import RequestError
+from biotite.database.pubchem.error import parse_error_details
+from biotite.database.pubchem.throttle import ThrottleStatus
+from biotite.structure.io.mol.mol import MOLFile
 
 _base_url = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/"
 
@@ -258,9 +266,10 @@ class FormulaQuery(Query):
         # Only set maximum number, if provided by the user
         # The PubChem default value for this might change over time
         if self._number is not None:
-           params["MaxRecords"] = self._number
+            params["MaxRecords"] = self._number
         return params
 
+
 def _format_element(element, count):
     if count == 1:
         return element.capitalize()
@@ -318,8 +327,8 @@ class StructureQuery(Query, metaclass=abc.ABCMeta):
                     )
         if not query_key_found:
             raise TypeError(
-                "Expected exactly one of 'smiles', 'smarts', 'inchi', 'sdf' "
-                "or 'cid'")
+                "Expected exactly one of 'smiles', 'smarts', 'inchi', 'sdf' " "or 'cid'"
+            )
         if "number" in kwargs:
             self._number = kwargs["number"]
             del kwargs["number"]
@@ -346,14 +355,10 @@ class StructureQuery(Query, metaclass=abc.ABCMeta):
         mol_file.set_structure(atoms)
         # Every MOL string with "$$$$" is a valid SDF string
         # Important: USE MS-style new lines
-        return cls(
-            *args,
-            sdf = "\r\n".join(mol_file.lines) + "\r\n$$$$\r\n",
-            **kwargs
-        )
+        return cls(*args, sdf="\r\n".join(mol_file.lines) + "\r\n$$$$\r\n", **kwargs)
 
     def get_input_url_path(self):
-        input_string =  f"compound/{self.search_type()}/{self._query_key}"
+        input_string = f"compound/{self.search_type()}/{self._query_key}"
         if self._query_key == "cid":
             # Put CID in URL and not in POST payload,
             # as PubChem is confused otherwise
@@ -370,7 +375,7 @@ class StructureQuery(Query, metaclass=abc.ABCMeta):
         # Only set maximum number, if provided by the user
         # The PubChem default value for this might change over time
         if self._number is not None:
-           params["MaxRecords"] = self._number
+            params["MaxRecords"] = self._number
         for key, val in self.search_options().items():
             # Convert 'snake case' Python parameters
             # to 'camel case' request parameters
@@ -472,13 +477,13 @@ class SuperOrSubstructureQuery(StructureQuery, metaclass=abc.ABCMeta):
     """
 
     _option_defaults = {
-        "match_charges" : False,
-        "match_tautomers" : False,
-        "rings_not_embedded" : False,
-        "single_double_bonds_match" : True,
-        "chains_match_rings" : True,
-        "strip_hydrogen" : False,
-        "stereo" : "ignore",
+        "match_charges": False,
+        "match_tautomers": False,
+        "rings_not_embedded": False,
+        "single_double_bonds_match": True,
+        "chains_match_rings": True,
+        "strip_hydrogen": False,
+        "stereo": "ignore",
     }
 
     def __init__(self, **kwargs):
@@ -706,7 +711,7 @@ class SimilarityQuery(StructureQuery):
         return f"fastsimilarity_{dim}"
 
     def search_options(self):
-        return {"threshold" : int(round(self._threshold * 100))}
+        return {"threshold": int(round(self._threshold * 100))}
 
 
 class IdentityQuery(StructureQuery):
@@ -766,8 +771,6 @@ class IdentityQuery(StructureQuery):
         return params
 
 
-
-
 def search(query, throttle_threshold=0.5, return_throttle_status=False):
     """
     Get all CIDs that meet the given query requirements,
@@ -812,7 +815,7 @@ def search(query, throttle_threshold=0.5, return_throttle_status=False):
     r = requests.post(
         _base_url + query.get_input_url_path() + "/cids/TXT",
         data=query.get_params(),
-        files=files
+        files=files,
     )
     if not r.ok:
         raise RequestError(parse_error_details(r.text))

biotite/database/pubchem/throttle.py

@@ -7,8 +7,8 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["ThrottleStatus"]
 
 
-from dataclasses import dataclass
 import time
+from dataclasses import dataclass
 
 
 @dataclass(frozen=True)
@@ -67,8 +67,7 @@ class ThrottleStatus:
         """
         throttle_control = response.headers["X-Throttling-Control"]
         throttle_status = [
-            substring.split(")")[0] for substring
-            in throttle_control.split("(")[1:]
+            substring.split(")")[0] for substring in throttle_control.split("(")[1:]
         ]
         # Remove '%' sign and convert to int
         count_status, time_status, service_status = [
@@ -96,4 +95,4 @@ class ThrottleStatus:
             threshold is exceeded.
         """
         if self.count > threshold or self.time > threshold:
-            time.sleep(wait_time)
+            time.sleep(wait_time)

biotite/database/rcsb/__init__.py

@@ -10,4 +10,4 @@ __name__ = "biotite.database.rcsb"
 __author__ = "Patrick Kunzmann"
 
 from .download import *
-from .query import *
+from .query import *