Uniprot

Uniprot és una base de dades de seqüències de proteïnes de lliure accés amb moltes entrades derivades de projectes de seqüenciació de genomes.

Introducció
Descarrega per URL
Format fasta.
Tractament amb Python
Exemple vida real.
Accés JSON (TODO)

Introducció

UniProt (Universal Protein Resource) és una base de dades de seqüències de proteïnes i la seva corresponent informació funcional. És de lliure accés i conté moltes entrades derivades de projectes de seqüenciació de genomes.

Conté al voltant de 60 milions de seqüències de proteïnes, derivada de la literatura científica, sobre la funció biològica de les proteïnes, la qual s’actualitza a mesura que es genera més coneixement

Uniprot neix del consorci UniProt que està format per EBI (European Bioinformatic Institute), SIB (Swiss Institute of Bioinformatics, que té una base de dades anomenada Swiss-prot), organitzacions bioinformàtiques europees i PIR (Protein Information Resource) organització americana de dades de proteïnes.

UniProt ofereix accés a quatre bases de dades de proteïnes:

The UniProt Knowledgebase (UniProtKB),
The UniProt Reference Clusters (UniRef),
The UniProt Metagenomics
Environmental Sequences database

Ves a la pàgina web i mira tota la informació que tens disponible: https://www.uniprot.org/

Descarrega per URL

Obtenir la cadena d’aminoàcids d’una proteïna amb Uniprot és molt fàcil:

Pots fer consultes d’un o més resultats a la pàgina o bé cercar una proteïna pel seu codi (propi d’Uniprot).

Per exemple, anem a consultar la Hemoglobina Beta en els humans, que s’encarrega de transportar oxigen a la sang.

https://www.uniprot.org/uniprotkb/P68871/entry

Format fasta

Si vols descarregar-la per treballar amb ella el més habitual és refer la url per a que et retorni el format textual .fasta

https://rest.uniprot.org/uniprotkb/P12345.fasta

La URL et retornarà aquest fitxer:

>sp|P12345|AATM_RABIT Aspartate aminotransferase, mitochondrial OS=Oryctolagus cuniculus OX=9986 GN=GOT2 PE=1 SV=2
MALLHSARVLSGVASAFHPGLAAAASARASSWWAHVEMGPPDPILGVTEAYKRDTNSKKM
NLGVGAYRDDNGKPYVLPSVRKAEAQIAAKGLDKEYLPIGGLAEFCRASAELALGENSEV
VKSGRFVTVQTISGTGALRIGASFLQRFFKFSRDVFLPKPSWGNHTPIFRDAGMQLQSYR
YYDPKTCGFDFTGALEDISKIPEQSVLLLHACAHNPTGVDPRPEQWKEIATVVKKRNLFA
FFDMAYQGFASGDGDKDAWAVRHFIEQGINVCLCQSYAKNMGLYGERVGAFTVICKDADE
AKRVESQLKILIRPMYSNPPIHGARIASTILTSPDLRKQWLQEVKGMADRIIGMRTQLVS
NLKKEGSTHSWQHITDQIGMFCFTGLKPEQVERLTKEFSIYMTKDGRISVAGVTSGNVGY
LAHAIHQVTK

Format fasta.

El format que veus s’anomena fasta i és dels més comuns en el món bioinformàtic, ja que ens proporciona molta informació de forma compacta i senzilla de tractar.

Qualsevol mena de seqüència o conjunt de seqüències es pot posar en un fitxer FASTA: els 3.000 milions de parells de bases del genoma humà complet, la seqüència d’aminoàcids completa d’un virus o la seqüència d’ADN del promotor del gen del teu ratolí favorit són exemples vàlids.

La primera linia, la que comença per > conté una descripció breu de la cadena.

A partir de la segona línia tenim la seqüència d’aminoàcids, normalment separada per espais \n per facilitar la lectura.

Hi ha fitxers fasta que poden tenir moltes cadenes >, anomenats multifasta. Tractar-los se surt del proposit de l’activitat.

Tractament amb Python

La web ja informa de quants AA (aminoàcids) tenen les cadenes, però podem obtenir molta més informació amb un programa Python.

Crea un projecte en Python.

Recorda com crear-lo amb uv i editar-lo amb Pycharm.

uv init dnfuniprot
uv add httpx
cd dnfuniprot
pycharm .

Crea i executa aquest codi en un script python, es pot dir uniprotdemo.py:

import os
import httpx

uniprot_id = "P12345"  # substitueix pel teu codi UniProt
url = f"https://rest.uniprot.org/uniprotkb/{uniprot_id}.fasta"
fasta_file = f"{uniprot_id}.fasta"

# Descarreguem el fasta en cas de no existir.
if not os.path.exists(fasta_file):
    with httpx.Client(verify=False) as client:
        response = client.get(url)
        with open(fasta_file, "w") as f:
            f.write(response.text)
            print(f"Descarrega completada: {fasta_file}")


# Obrim el fitxer fasta en mode lectura.
with open(fasta_file, "r") as f:
    fasta_text = f.read()

# Separem les línies
lines = fasta_text.splitlines()

# La primera línia és la capçalera
header = lines[0]

# La resta són la seqüència, la concatenem sense espais ni salts de línia.
sequence = "".join(lines[1:])

# Comptar la longitud és molt senzill.
longitud = len(sequence)

# Mostrem resultats
print(f"Capçalera: {header}")
print(f"Seqüència: {sequence}")
print(f"Longitud: {len(sequence)}")

El que fa el programa ho pots llegir als comentaris.

Bàsicament:

Descarrega la fitxer amb la seqüència en format .fasta al web d’Uniprot si no existeix
Llegeix el fitxer .fasta que conté la seqüència.
Separa la capçalera (que està a la primera línia) de la seqüència.
Mostra la capçalera, la seqüencia i la longitud per pantalla.

Obtindrás el següent resultat:

Capçalera: >sp|P12345|AATM_RABIT Aspartate aminotransferase, mitochondrial OS=Oryctolagus cuniculus OX=9986 GN=GOT2 PE=1 SV=2
Seqüència: MALLHSARVLSGVASAFHPGLAAAASARASSWWAHVEMGPPDPILGVTEAYKRDTNSKKMNLGVGAYRDDNGKPYVLPSVRKAEAQIAAKGLDKEYLPIGGLAEFCRASAELALGENSEVVKSGRFVTVQTISGTGALRIGASFLQRFFKFSRDVFLPKPSWGNHTPIFRDAGMQLQSYRYYDPKTCGFDFTGALEDISKIPEQSVLLLHACAHNPTGVDPRPEQWKEIATVVKKRNLFAFFDMAYQGFASGDGDKDAWAVRHFIEQGINVCLCQSYAKNMGLYGERVGAFTVICKDADEAKRVESQLKILIRPMYSNPPIHGARIASTILTSPDLRKQWLQEVKGMADRIIGMRTQLVSNLKKEGSTHSWQHITDQIGMFCFTGLKPEQVERLTKEFSIYMTKDGRISVAGVTSGNVGYLAHAIHQVTK
Longitud: 430

Exercicis cadenes en Python

Amb els fonaments de programació de Python podem obtenir molta més informació de la cadena.

Per exemple, volem veure quins són els 10 primers caràcters de la seqüència.

Podem fer servir slicing, la mateixa tècnica que feiem servir per seleccionar elements de seqüències (llistes) en Python.

Repassem alguns exemples:

text = "Bon dia!"
print(text[0:3])  #Bon!

Expressió	Resultat
`text[0]`	`'B'`
`text[4:]`	`'dia!'`
`text[4:7]`	`'dia'`
`text[1:5]`	`'on d'`
`text[-1]`	`'!'`
`text[:-1]`	`'Bon dia'`

Ara, veiem com aplicar-ho en els nostres fitxers .fasta

Aquest programa llegeix el P12345.fasta (ja descarregat) i mostra els 10 primers caràcters de la seqüència.

fasta_file = "P12345.fasta"

# Obrim el fitxer fasta en mode lectura.
with open(fasta_file, "r") as f:
    fasta_text = f.read()

# Separem les línies
lines = fasta_text.splitlines()

# La primera línia és la capçalera (no ens interessa per ara)
# header = lines[0]

# Seleccionem únicament la seqüència sense espais ni salts de línia.
sequence = "".join(lines[1:])

# Exercici - Mostra els 10 primers caràcters.
print(sequence[:10])

O volem comptar quantes vegades apareix l’aminoàcid G (la Glicina), seguint el codi anterior.

Per aconseguir-ho usarem el mètode d’utilitat count. Aquí tens un exemple simple:

text = "Hola com va?"
print(text.count('a'))  #2

Ara, just a continuació d’inicialitzar la variable sequence, comptem les G.

# Seleccionem únicament la seqüència sense espais ni salts de línia.
sequence = "".join(lines[1:])

# Exercici - Mostra el número de vegades que apareix la G.
print(sequence.count('G'))  #37 dins del P12345.fasta

Task

1.- Completa l’exemple per tal que mostri: els últims 5 caràcters i els l’intèrval entre el 6 i el 10.

Task

2.- Completa l’exemple per tal que mostri el número de vegades que apareix la Valina (V). Fes que calculi el % d’aparició de la V respecte el total.

Exemple vida real.

Gràcies a aquest domini del llenguatge Python. ja podem identificar mutacions (una alteració de la seqüència d’un organisme que pot tenir efectes negatius en aquest) en cadenes d’aminoàcids.

Exemple: anèmia falciforme

L’hemoglobina (els glòbuls vermells) és la proteïna que transporta oxigen a la sang.

L’anèmia falciforme és una malaltia hereditària en que l’ADN que codifica la hemoglobina beta (HBB).

Té un únic error en la codificació del sisé aminoàcid de la cadena β de l’hemoglobina (un dels dos tipus de cadenes de proteïnes que conformen l’hemoglobina).

Ho vam veure amb detall a DNF - Estructura proteïnes.

La mutació consisteix en aquest canvi: Glu(E) → Val(V) dins de la posició 6 de la cadena d’hemoglobina.

Per tant, detectar amb Python si una cadena té la mutació o no és senzill:

Primer, baixa’t la cadena de referència:

https://rest.uniprot.org/uniprotkb/P69905.fasta

I executa el codi.

file_fasta = 'P69905.fasta'
with open(file_fasta, "r") as f:
    fasta_text = f.read()

lines = fasta_text.splitlines()
header = lines[0]
sequence = "".join(lines[1:])

print(f"\nCapçalera: {header}")
print(f"Longitud seqüència: {len(sequence)} AA")

# 5️⃣ Mutació anèmia falciforme: Glu -> Val en posició 6 (Hemoglobina)
if sequence[5] == "V":
    print("\nMutació detectada: Glu -> Val a la posició 6")
else:
    print("\nMutació no detectada")

Que retorna que, efectivament, la cadena original no està mutada.

Però ja veus com de fàcil és comprovar-ho.

Activitat amb terminal de Linux (optatiu)

Si no tens Python però et trobes a Linux pots aconseguir els mateixos resultats amb aquestes comandes:v

Descarrega el fitxer:

wget https://rest.uniprot.org/uniprotkb/P12345.fasta

Llegeix la capçalera:

grep "^>" P12345.fasta

Llegeix el que NO és la capçalera, la seqüència:

grep -v "^>" P12345.fasta | tr -d '\n'

Obtenir longitud:

grep -v "^>" P12345.fasta | tr -d '\n' | wc -c

Explicació de les comandes:

grep mostra únicament les línies del fitxer que segueixen un patró.
grep -v mostra les que NO segueixen el patró!
El patró grep conté la expressió regular ”^>”, que filtra les linies que comencen pel símbol >(la capçalera)
La comanda tr la úsem per eliminar els salts de línia.
wc - c serveix per comptar els caràcters.

Accés JSON (TODO)

Si accedim a la mateixa proteïna en format JSON podem obtenir molta més informació textual que amb l’antic fasta, i organitzada d’una forma més estendaritzada.

TODO: Volcar part del contingut de la activitat de DAWBIO2 de l’any passat.