uniprotpy 0.0.1__tar.gz

uniprotpy-0.0.1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: uniprotpy
+Version: 0.0.1
+Summary: A Python library that interfaces with UniProt data.
+Home-page: https://github.com/danielmarrama/uniprotpy
+Author: Daniel Marrama
+Author-email: danielmarrama@gmail.com
+Description-Content-Type: text/markdown
+
+# UniProtPy
+
+Python library that interfaces with UniProt API.
+
+For something like [openvax/pyensembl](https://github.com/openvax/pyensembl) with UniProt.
+
+The REST API has changed as of 2022. Many of the ways to extract data from UniProt is now different and there isn't a clean way to interface with it.
+
+
+### Goals
+1. Allow users to pull any kind of data from UniProt.
+2. Store and query large data using a local database.
+3. Manipulate and output data in many standard formats.
+
+### Installation
+
+```bash
+pip install uniprotpy
+```
+
+### Getting a proteome for a species
+```bash
+uniprotpy get-best-proteome --taxon-id 9606
+```
+
+### TODO
+
+- Retrieve individual entries in all supported formats.
+- Get metadata (protein ID, name, gene, # of isoforms, etc.) for entries.
+- Retrieve proteomes via proteome ID or select "best" proteome based on taxon ID.
+- Query proteomes for a protein by ID, name, seq, or peptide unit.

uniprotpy-0.0.1/README.md

@@ -0,0 +1,31 @@
+# UniProtPy
+
+Python library that interfaces with UniProt API.
+
+For something like [openvax/pyensembl](https://github.com/openvax/pyensembl) with UniProt.
+
+The REST API has changed as of 2022. Many of the ways to extract data from UniProt is now different and there isn't a clean way to interface with it.
+
+
+### Goals
+1. Allow users to pull any kind of data from UniProt.
+2. Store and query large data using a local database.
+3. Manipulate and output data in many standard formats.
+
+### Installation
+
+```bash
+pip install uniprotpy
+```
+
+### Getting a proteome for a species
+```bash
+uniprotpy get-best-proteome --taxon-id 9606
+```
+
+### TODO
+
+- Retrieve individual entries in all supported formats.
+- Get metadata (protein ID, name, gene, # of isoforms, etc.) for entries.
+- Retrieve proteomes via proteome ID or select "best" proteome based on taxon ID.
+- Query proteomes for a protein by ID, name, seq, or peptide unit.

uniprotpy-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

uniprotpy-0.0.1/setup.py

@@ -0,0 +1,33 @@
+from setuptools import setup
+import re
+import os
+
+
+with open('uniprotpy/version.py', 'r') as f:
+    version = re.search(
+        r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]',
+        f.read(),
+        re.MULTILINE).group(1)
+
+with open('README.md', 'r', encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name='uniprotpy',
+    version=version,
+    description='A Python library that interfaces with UniProt data.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/danielmarrama/uniprotpy',
+    author='Daniel Marrama',
+    author_email='danielmarrama@gmail.com',
+    packages=['uniprotpy'],
+    install_requires=['pandas>=1.1',
+                      'biopython>=1.5'],
+    zip_safe=False,
+    entry_points={
+        'console_scripts': [
+            'uniprotpy = uniprotpy.shell:run'
+        ],
+    },
+)

uniprotpy-0.0.1/uniprotpy/__init__.py

@@ -0,0 +1,3 @@
+from .select_best_proteome import ProteomeSelector
+
+from .version import __version__

uniprotpy-0.0.1/uniprotpy/extract_proteomes.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+
+import pandas as pd
+import json
+import requests
+import gzip
+
+directory = ''
+
+def get_proteomes(taxon_dict):
+    '''
+    Extracts taxons with proteomes from the UniProt FTP site.
+    If get_canonical: get 1 protein per gene proteome as well as total proteome.
+    '''
+
+    url = 'https://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/reference_proteomes'
+
+    for taxon_id, proteome_id in taxon_dict.items():
+
+        # if file exists in directory already, skip it
+        if taxon_id + '.fasta' in os.listdir(directory):
+            continue
+
+        # check Eukaryota first
+        r = requests.get(url + '/Eukaryota/' + proteome_id + '/' + proteome_id + '_' + taxon_id + '.fasta.gz', stream=True)
+        
+        # then Archaea
+        if r.status_code == 404:
+            r = requests.get(url + '/Archaea/' + proteome_id + '/' + proteome_id + '_' + taxon_id + '.fasta.gz', stream=True)
+            
+            # then Bacteria
+            if r.status_code == 404:
+                r = requests.get(url + '/Bacteria/' + proteome_id + '/' + proteome_id + '_' + taxon_id + '.fasta.gz', stream=True)
+                
+                # then Viruses
+                if r.status_code == 404:
+                    r = requests.get(url + '/Viruses/' + proteome_id + '/' + proteome_id + '_' + taxon_id + '.fasta.gz', stream=True)
+                    
+                    # if found nowhere, move on
+                    if r.status_code == 404:
+                        get_protein_entries([taxon_id])
+        
+            try:
+                with open(directory + taxon_id + '.fasta', 'wb') as f1:
+                    f1.write(gzip.open(r.raw, 'rb').read())
+            except gzip.BadGzipFile:
+                get_protein_entries([taxon_id])
+
+    return 0
+
+
+def get_protein_entries(taxons):
+    '''
+    Get collection of proteins for taxons with no proteome in UniProt.
+    '''
+    for taxon in taxons:
+        
+        # if file exists in directory already, skip it
+        if taxon + '.fasta' in os.listdir(directory):
+            continue
+        
+        r = requests.get('https://rest.uniprot.org/uniprotkb/stream?format=fasta&query=%28taxonomy_id%3A' + taxon + '%29')
+        with open(directory + taxon + '.fasta', 'w') as f2:
+            f2.write(r.text)
+
+
+if __name__ == '__main__':
+
+    # list taxons you want to retrieve from UniProt in text file
+    with open('taxons.txt', 'r') as f:
+        lines = f.readlines()
+        taxons = [i.rstrip() for i in lines]
+        taxons = pd.Series(taxons)
+
+    # read in the table from UniProt (https://www.uniprot.org/proteomes?query=*)
+    df = pd.read_csv('proteome_ids.tsv', sep='\t')
+
+    # get taxons with proteomes (those that have IDs)
+    taxons_with_proteomes = list(taxons[taxons.isin(df['Organism Id'].astype(str))])
+    
+    # get collection of proteins for taxons that have no proteome
+    taxons_without_proteomes = list(taxons[~taxons.isin(df['Organism Id'].astype(str))])
+    get_protein_entries(taxons_without_proteomes)
+
+    # get proteome ID with most proteins
+    df.drop_duplicates(subset=['Organism Id'], inplace=True)
+    df = df[df['Organism Id'].astype(str).isin(taxons_with_proteomes)]
+    taxons_with_proteomes_dict = dict(zip(df['Organism Id'].astype(str), df['Proteome Id'].astype(str)))
+
+    # now get those proteomes from UniProt FTP server
+    get_proteomes(taxons_with_proteomes_dict)
+    
+

uniprotpy-0.0.1/uniprotpy/protein_tree.py

@@ -0,0 +1,55 @@
+import re
+import pandas as pd
+
+from Bio import SeqIO
+from anytree import Node, RenderTree
+
+
+def add_nodes(nodes, parent, child):
+  if parent not in nodes:
+    nodes[parent] = Node(parent)
+  if child not in nodes:
+    nodes[child] = Node(child)
+  nodes[child].parent = nodes[parent]
+
+def create_protein_tree(proteome):
+  proteins = list(SeqIO.parse(proteome, 'fasta'))
+
+  # get UniProt IDs for one protein per gene proteome
+  gp_ids = [str(x.id.split('|')[1]) for x in list(SeqIO.parse(gp_proteome, 'fasta'))]
+
+  data = []
+  for protein in proteins:
+
+    # get gene symbol from FASTA file
+    try:
+      gene = re.search('GN=(.*?) ', protein.description).group(1)
+    except AttributeError:
+
+      # sometimes the gene symbol is at the end of the FASTA description
+      try:
+        gene = re.search('GN=(.*?)$', protein.description).group(1)
+      except AttributeError:
+        gene = ''
+
+    data.append([protein.id.split('|')[0], gene, protein.id.split('|')[1], str(protein.seq)])
+
+  # put protein tree data into dataframe
+  df = pd.DataFrame(data, columns=['db', 'gene', 'id', 'seq'])
+
+  # start tree with nodes - genes as root and UniProt IDs as children
+  nodes = {}
+  for parent, child in zip(df['gene'],df['id']):
+    add_nodes(nodes, parent, child)
+
+  # write the tree into a text file
+  with open('protein_tree.txt', 'w') as f:
+    roots = list(df[~df['gene'].isin(df['id'])]['gene'].unique())
+    for root in roots:         # you can skip this for roots[0], if there is no forest and just 1 tree
+      for pre, _, node in RenderTree(nodes[root]):
+        if node.name in gp_ids:
+          f.write("%s%s*" % (pre, node.name))
+          f.write('\n')
+        else:
+          f.write("%s%s" % (pre, node.name))
+          f.write('\n')

uniprotpy-0.0.1/uniprotpy/select_best_proteome.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+
+import warnings
+warnings.filterwarnings('ignore')
+
+import re
+import os
+import pandas as pd
+import requests
+
+
+class ProteomeSelector:
+  def __init__(self, taxon_id):
+    self.taxon_id = taxon_id
+    
+    # get proteome list for species and count number of proteomes
+    self.proteome_list = self._get_proteome_list()
+    self.num_of_proteomes = len(self.proteome_list) + 1 # +1 because "all proteins" is also a candidate proteome
+
+  def select_proteome(self):
+    """
+    Select the best proteome to use for a species. Return the proteome ID, 
+    proteome taxon, and proteome type.
+    
+    Check UniProt for all candidate proteomes associated with that
+    taxon. Then do the following checks:
+
+    1. Are there any representative proteomes?
+    2. Are there any reference proteomes?
+    3. Are there any non-redudant proteomes?
+    4. Are there any other proteomes?
+
+    If yes to any of the above, check if there are ties. If there are ties,
+    then select the proteome with the most proteins.
+
+    If no to all of the above, then get every protein associated with
+    the taxon ID using the get_all_proteins method.
+    """
+    # if species_dir already exists then return the already selected proteome, else create dir
+    if os.path.exists(f'./data/{self.taxon_id}'):
+      print(f'Proteome already selected for {self.taxon_id}.')
+      return []
+    else:
+      os.makedirs(f'./data/{self.taxon_id}')
+
+    # if there is no proteome_list, get all proteins associated with that taxon ID
+    if self.proteome_list.empty:
+      self._get_all_proteins()
+      return 'None', self.taxon_id, 'All-proteins'
+
+    if self.proteome_list['isRepresentativeProteome'].any():
+      proteome_type = 'Representative'
+      self.proteome_list = self.proteome_list[self.proteome_list['isRepresentativeProteome']]
+      proteome_id, proteome_taxon = self._get_proteome_with_most_proteins()
+      # self._get_gp_proteome_to_fasta(proteome_id, proteome_taxon)
+    
+    elif self.proteome_list['isReferenceProteome'].any():
+      proteome_type = 'Reference'
+      self.proteome_list = self.proteome_list[self.proteome_list['isReferenceProteome']]
+      proteome_id, proteome_taxon = self._get_proteome_with_most_proteins()
+      # self._get_gp_proteome_to_fasta(proteome_id, proteome_taxon)
+
+    elif 'redundantTo' not in self.proteome_list.columns:
+      proteome_type = 'Other'
+      proteome_id, proteome_taxon = self._get_proteome_with_most_proteins()
+    
+    elif self.proteome_list['redundantTo'].isna().any():
+      proteome_type = 'Non-redundant'
+      self.proteome_list = self.proteome_list[self.proteome_list['redundantTo'].isna()]
+      proteome_id, proteome_taxon = self._get_proteome_with_most_proteins()
+    
+    else:
+      proteome_type = 'Other'
+      proteome_id, proteome_taxon = self._get_proteome_with_most_proteins()
+    
+    # sanity check to make sure proteome.fasta is not empty
+    if os.stat(f'./data/{self.taxon_id}/proteome.fasta').st_size == 0:
+      proteome_id = 'None'
+      proteome_taxon = self.taxon_id
+      proteome_type = 'All-proteins'
+      self._get_all_proteins()
+
+    proteome_data = [proteome_id, proteome_taxon, proteome_type]
+    return proteome_data
+
+  def proteome_to_csv(self):
+    """
+    Write the proteome data for a species to a CSV file for later use.
+    """
+    from Bio import SeqIO
+
+    # read in the FASTA file and then get the gene priority IDs if they exist
+    proteins = list(SeqIO.parse(f'data/{self.taxon_id}/proteome.fasta', 'fasta'))
+
+    gp_proteome_path = f'data/{self.taxon_id}/gp_proteome.fasta'
+    if os.path.isfile(gp_proteome_path):
+      gp_ids = [str(protein.id.split('|')[1]) for protein in list(SeqIO.parse(gp_proteome_path, 'fasta'))]
+    else:
+      gp_ids = []
+
+    # start collecting proteome data
+    proteome_data = []
+    for protein in proteins:
+      uniprot_id = protein.id.split('|')[1]
+      gp = 1 if uniprot_id in gp_ids else 0
+
+      # TODO: look into using HUGO to map old gene names to new ones
+
+      try:
+        gene = re.search('GN=(.*?) ', protein.description).group(1)
+      except AttributeError:
+        try: # some gene names are at the end of the header
+          gene = re.search('GN=(.*?)$', protein.description).group(1)
+        except AttributeError:
+          gene = ''
+      try: # protein existence level
+        pe_level = int(re.search('PE=(.*?) ', protein.description).group(1))
+      except AttributeError:
+        pe_level = 0
+      
+      proteome_data.append([protein.id.split('|')[0], gene, uniprot_id, gp, pe_level, str(protein.seq)])
+    
+    columns = ['Database', 'Gene Symbol', 'UniProt ID', 'Gene Priority', 'Protein Existence Level', 'Sequence']
+    pd.DataFrame(proteome_data, columns=columns).to_csv(f'data/{self.taxon_id}/proteome.csv', index=False)
+
+  def _get_proteome_list(self):
+    """
+    Get a list of proteomes for a species from the UniProt API.
+    Check for proteome_type:1 first, which are the representative or
+    reference proteomes.
+
+    If there are no proteomes, return empty DataFrame.
+    """
+    # URL to get proteome list for a species - use proteome_type:1 first
+    url = f'https://rest.uniprot.org/proteomes/stream?format=xml&query=(proteome_type:1)AND(taxonomy_id:{self.taxon_id})'
+    
+    try:
+      proteome_list = pd.read_xml(requests.get(url).text)
+    except ValueError:
+      try: # delete proteome_type:1 from URL and try again
+        url = url.replace('(proteome_type:1)AND', '')
+        proteome_list = pd.read_xml(requests.get(url).text)
+      except ValueError: # if there are no proteomes, return empty DataFrame
+        return pd.DataFrame()
+
+    # remove the namespace from the columns
+    proteome_list.columns = [x.replace('{http://uniprot.org/proteome}', '') for x in proteome_list.columns]
+    return proteome_list
+
+  def _get_all_proteins(self):
+    """
+    Get every protein associated with a taxon ID on UniProt.
+    Species on UniProt will have a proteome, but not every protein is
+    stored within those proteomes. There is a way to get every protein
+    using the taxonomy part of UniProt. 
+    """
+    # URL link to all proteins for a species - size = 500 proteins at a time
+    url = f'https://rest.uniprot.org/uniprotkb/search?format=fasta&'\
+          f'query=taxonomy_id:{self.taxon_id}&size=500' 
+
+    # loop through all protein batches and write proteins to FASTA file
+    for batch in self._get_protein_batches(url):
+      with open(f'data/{self.taxon_id}/proteome.fasta', 'a') as f:
+        f.write(batch.text)
+
+  def _get_protein_batches(self, batch_url):
+    """
+    Get a batch of proteins from UniProt API because it limits the
+    number of proteins you can get at once. Yield each batch until the 
+    URL link is empty.
+    
+    Args:
+      batch_url (str): URL to get all proteins for a species.
+    """
+    while batch_url:
+      r = requests.get(batch_url)
+      r.raise_for_status()
+      yield r
+      batch_url = self._get_next_link(r.headers)
+
+  def _get_next_link(self, headers):
+    """
+    UniProt will provide a link to the next batch of proteins when getting
+    all proteins for a species' taxon ID.
+    We can use a regular expression to extract the URL from the header.
+
+    Args:
+      headers (dict): Headers from UniProt API response.
+    """
+    re_next_link = re.compile(r'<(.+)>; rel="next"') # regex to extract URL
+    if 'Link' in headers:
+      match = re_next_link.match(headers['Link'])
+      if match:
+        return match.group(1)
+
+  def _get_gp_proteome_to_fasta(self, proteome_id, proteome_taxon):
+    """
+    Write the gene priority proteome to a file. 
+    This is only for representative and reference proteomes.
+    Depending on the species group, the FTP URL will be different.
+
+    Args:
+      proteome_id (str): Proteome ID.
+      proteome_taxon (str): Taxon ID for the proteome.
+    """
+    import gzip
+    
+    group = self.species_df[self.species_df['Taxon ID'].astype(str) == self.taxon_id]['Group'].iloc[0]
+    ftp_url = f'https://ftp.uniprot.org/pub/databases/uniprot/knowledgebase/reference_proteomes/'
+    
+    if group == 'archeobacterium':
+      ftp_url += f'Archaea/{proteome_id}/{proteome_id}_{proteome_taxon}.fasta.gz'
+    elif group == 'bacterium':
+      ftp_url += f'Bacteria/{proteome_id}/{proteome_id}_{proteome_taxon}.fasta.gz'
+    elif group in ['vertebrate', 'other-eukaryote']:
+      ftp_url += f'Eukaryota/{proteome_id}/{proteome_id}_{proteome_taxon}.fasta.gz'
+    elif group in ['virus', 'small-virus', 'large-virus']:
+      ftp_url += f'Viruses/{proteome_id}/{proteome_id}_{proteome_taxon}.fasta.gz'
+    
+    r = requests.get(ftp_url, stream=True)
+    try:
+      r.raise_for_status()
+    except:
+      return
+
+    # unzip the request and write the gene priority proteome to a file
+    with open(f'data/{self.taxon_id}/gp_proteome.fasta', 'wb') as f:
+      f.write(gzip.open(r.raw, 'rb').read())
+
+  def _get_proteome_to_fasta(self, proteome_id):
+    """
+    Get the FASTA file for a proteome from UniProt API.
+    Include all isoforms and do not compress the file.
+    """
+    url = f'https://rest.uniprot.org/uniprotkb/stream?compressed=false&format=fasta&includeIsoform=true&query=(proteome:{proteome_id})'
+    r = requests.get(url)
+    r.raise_for_status()
+    with open(f'data/{self.taxon_id}/proteome.fasta', 'w') as f:
+      f.write(r.text)
+
+  def _get_proteome_with_most_proteins(self):
+    """
+    Between UniProt proteome ties, get the proteome with the most proteins.
+    """
+    # get the index of the row with the most proteins using proteinCount
+    proteome_id = self.proteome_list.iloc[self.proteome_list['proteinCount'].idxmax()]['upid']
+    proteome_taxon = self.proteome_list.iloc[self.proteome_list['proteinCount'].idxmax()]['taxonomy']
+
+    # write the proteome to a file
+    self._get_proteome_to_fasta(proteome_id)
+
+    return proteome_id, proteome_taxon
+
+
+def main():
+  import argparse
+
+  parser = argparse.ArgumentParser()
+
+  parser.add_argument('-t', '--taxon_id', required=True, help='Taxon ID for the species to pull data for.')
+  
+  args = parser.parse_args()
+  taxon_id = args.taxon_id
+
+  Selector = ProteomeSelector(taxon_id)
+  print(f'Number of candidate proteomes: {Selector.num_of_proteomes}')
+  proteome_data = Selector.select_proteome()
+  Selector.proteome_to_csv()
+
+  print(f'Proteome ID: {proteome_data[0]}')
+  print(f'Proteome taxon: {int(proteome_data[1])}')
+  print(f'Proteome type: {proteome_data[2]}')
+
+if __name__ == '__main__':
+  main()

uniprotpy-0.0.1/uniprotpy/shell.py

@@ -0,0 +1,26 @@
+import argparse
+
+from .select_best_proteome import ProteomeSelector
+
+def parse_arguments():
+  parser = argparse.ArgumentParser(description='UniProtPy')
+  parser.add_argument('-t', '--taxon_id', required=True)
+  parser.add_argument(
+    'action',
+    choices=(
+      'get-best-proteome',
+    ),
+    help='\"get-best-proteome\" will download the best proteome from UniProt for a given '
+         'taxon ID of a species.'
+  )
+  args = parser.parse_args()
+
+  return args
+
+def run():
+  args = parse_arguments()
+  taxon_id = args.taxon_id
+  if args.action == 'get-best-proteome':
+    ProteomeSelector(taxon_id).select_proteome()
+  else:
+    raise ValueError('Invalid action.')

uniprotpy-0.0.1/uniprotpy/taxon_tree.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+
+import requests
+import pandas as pd
+import io
+
+BASE_URL = 'https://rest.uniprot.org/taxonomy/stream'
+
+
+def get_taxon_children(taxon_id):
+  """Retrives all children taxa for a given taxon ID."""
+  url = f'{BASE_URL}?fields=id%2Cscientific_name&format=tsv&query=%28parent%3A{taxon_id}%29'
+  response = requests.get(url)
+
+  try:
+    taxon_children_df = pd.read_csv(io.StringIO(response.text), sep='\t')
+    children = taxon_children_df.to_dict(orient='records')
+  except ValueError:
+    children = []
+
+  return children
+
+def traverse_tree(taxon_id):
+  """
+  Recursively traverse the taxonomy tree for a given taxon ID.
+
+  It goes down to each leaf node and returns a dict of the form:
+  {taxon_id: [child1, {child2: subchild1}, ...]}
+  
+  Taxon IDs that have no children are standalone integers; anything
+  else is a list of dicts.
+  """
+  children = get_taxon_children(taxon_id)
+
+  if not children:
+    return taxon_id
+
+  child_results = []
+  for child in children:
+    child_id = child['Taxon Id']
+    child_result = traverse_tree(child_id)
+
+    if isinstance(child_result, int):
+      child_results.append(child_result)
+    else:
+      child_results.append(child_result)
+
+  return {taxon_id: child_results}
+
+def create_taxon_tree(tree, prefix="", file=None):
+  """
+  Create a taxonomy tree structure from the output of traverse_tree. 
+
+  It looks like this for the homo genus (9605):
+  └──9605
+      ├──9606
+      │   ├──63221
+      │   └──741158
+      ├──1425170
+      ├──2665952
+      │   └──2665953
+      └──2813598
+          └──2813599
+  """
+  if isinstance(tree, list):
+    for i, item in enumerate(tree):
+      is_last = i == len(tree) - 1
+      if isinstance(item, dict):
+        for k, v in item.items():
+          print(f"{prefix}{'└──' if is_last else '├──'}{k}", file=file)
+          create_taxon_tree(v, f"{prefix}{'    ' if is_last else '│   '}", file)
+      else:
+        print(f"{prefix}{'└──' if is_last else '├──'}{item}", file=file)
+  
+  elif isinstance(tree, dict):
+    for i, (key, value) in enumerate(tree.items()):
+      is_last = i == len(tree) - 1
+      print(f"{prefix}{'└──' if is_last else '├──'}{key}", file=file)
+      create_taxon_tree(value, f"{prefix}{'    ' if is_last else '│   '}", file)
+
+def main():
+  import argparse
+
+  parser = argparse.ArgumentParser()
+  parser.add_argument('-t', '--taxon_id', required=True, type=int, help='Taxon ID')
+  parser.add_argument('-p', '--pickle', action='store_true', help='Pickle tree output.')
+  parser.add_argument('-o', '--output', action='store_true', help='Output tree file.')
+
+  args = parser.parse_args()
+  taxon_id = args.taxon_id
+
+  taxonomy_tree = traverse_tree(taxon_id)
+
+  if args.pickle:
+    import pickle
+    with open('taxonomy_tree.pkl', 'wb') as f:
+      pickle.dump(taxonomy_tree, f)
+  
+  if args.output:
+    with open(f'{taxon_id}_taxonomy_tree.txt', 'w') as f:
+      create_taxon_tree(taxonomy_tree, file=f)
+
+  print(f'Taxon tree for {taxon_id}:')
+  create_taxon_tree(taxonomy_tree)
+
+if __name__ == '__main__':
+  main()

uniprotpy-0.0.1/uniprotpy/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

uniprotpy-0.0.1/uniprotpy.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: uniprotpy
+Version: 0.0.1
+Summary: A Python library that interfaces with UniProt data.
+Home-page: https://github.com/danielmarrama/uniprotpy
+Author: Daniel Marrama
+Author-email: danielmarrama@gmail.com
+Description-Content-Type: text/markdown
+
+# UniProtPy
+
+Python library that interfaces with UniProt API.
+
+For something like [openvax/pyensembl](https://github.com/openvax/pyensembl) with UniProt.
+
+The REST API has changed as of 2022. Many of the ways to extract data from UniProt is now different and there isn't a clean way to interface with it.
+
+
+### Goals
+1. Allow users to pull any kind of data from UniProt.
+2. Store and query large data using a local database.
+3. Manipulate and output data in many standard formats.
+
+### Installation
+
+```bash
+pip install uniprotpy
+```
+
+### Getting a proteome for a species
+```bash
+uniprotpy get-best-proteome --taxon-id 9606
+```
+
+### TODO
+
+- Retrieve individual entries in all supported formats.
+- Get metadata (protein ID, name, gene, # of isoforms, etc.) for entries.
+- Retrieve proteomes via proteome ID or select "best" proteome based on taxon ID.
+- Query proteomes for a protein by ID, name, seq, or peptide unit.

uniprotpy-0.0.1/uniprotpy.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+setup.py
+uniprotpy/__init__.py
+uniprotpy/extract_proteomes.py
+uniprotpy/protein_tree.py
+uniprotpy/select_best_proteome.py
+uniprotpy/shell.py
+uniprotpy/taxon_tree.py
+uniprotpy/version.py
+uniprotpy.egg-info/PKG-INFO
+uniprotpy.egg-info/SOURCES.txt
+uniprotpy.egg-info/dependency_links.txt
+uniprotpy.egg-info/entry_points.txt
+uniprotpy.egg-info/not-zip-safe
+uniprotpy.egg-info/requires.txt
+uniprotpy.egg-info/top_level.txt

uniprotpy-0.0.1/uniprotpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

uniprotpy-0.0.1/uniprotpy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uniprotpy = uniprotpy.shell:run

uniprotpy-0.0.1/uniprotpy.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

uniprotpy-0.0.1/uniprotpy.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pandas>=1.1
+biopython>=1.5

uniprotpy-0.0.1/uniprotpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+uniprotpy