# -- Create a variable with the data,
# -- form the JSON received
response = json.loads(data1)
# Information of the gene
Description = response["desc"]
termcolor.cprint(f"Gene:", "green", end=" ")
print(gene_input)
termcolor.cprint(f"Description:", "green", end=" ")
print(Description)
# Introduce the sequence
seq = Seq(response["seq"])
s_length = seq.len()
counter_A = seq.count_base(all_bases[0])
counter_C = seq.count_base(all_bases[1])
counter_G = seq.count_base(all_bases[2])
counter_T = seq.count_base(all_bases[3])
per_A = "{:.1f}".format(100 * counter_A / s_length)
per_C = "{:.1f}".format(100 * counter_C / s_length)
per_G = "{:.1f}".format(100 * counter_G / s_length)
per_T = "{:.1f}".format(100 * counter_T / s_length)
# Print the length
termcolor.cprint(f"Total length:", "green", end=" ")
print(s_length)
termcolor.cprint(f"A", "blue", end=" ")
from Client0 import Client
from Seq1 import Seq
IP = "127.0.0.1"
PORT = 8080
FOLDER = "../Session-04/"
GENE = "FRAT1"
c = Client(IP, PORT)
print(c)
s = Seq("").read_fasta(FOLDER + GENE)
bases = str(s)
print(f"Gene {GENE}: {bases}")
LENGTH = 10
c.talk(f"Sending {GENE} gene to the server, in fragments of {LENGTH} bases")
for i in range(5):
frag = bases[i*LENGTH:(i+1)*LENGTH]
print(f"Fragment {i+1}: {frag}")
c.talk(f"Fragment {i+1}: {frag}")
def comp(seq):
s = Seq(seq)
result = str(Seq.complement(s))
context = {"seq": s, "op": "Comp", "res": result}
content = read_template("./html/operation.html").render(context=context)
return content
from Seq1 import Seq
print("-----| Practice 1, Exercise 3 |------")
s1 = Seq('NULL')
s2 = Seq("ACTGA")
s3 = Seq("ERROR")
print("Sequence 1: ", s1)
print("Sequence 2: ", s2)
print("Sequence 3: ", s3)
from Seq1 import Seq
def print_result(i, sequence):
print('Sequence ' + str(i) + ': (Length: ' + str(sequence.len()) + ') ' +
str(sequence))
print('Bases: ', sequence.count())
print('Rev: ', sequence.reverse())
print('----- Practice 1, Exercise 7 -----')
s1 = Seq()
s2 = Seq('ACTGA')
s3 = Seq('Invalid seq!')
list_seq = [s1, s2, s3]
for i in range(0, len(list_seq)):
print_result(i, list_seq[i])
def do_GET(self):
"""This method
is called whenever the client invokes the GET method
in the HTTP protocol request"""
# Print request line
print(self.requestline)
# Split request line by space and get the path
req_line = self.requestline.split(' ')
path = req_line[1]
# Split path
arguments = path.split('?')
# Action is the first argument
action = arguments[0]
# If there is no argument we will receive an error
contents = Path('error.html').read_text()
code = 404
# The main program composed by basic and medium levels starts at this point
try:
# First we open index.html if we don´t specify any action or it is /index we will be taken to the initial
# menu that returns us the index.html file
if action == "/" or action == "/index":
contents = Path('index.html').read_text()
# Once we are in the initial menu we have different options to perform, basic and medium levels.
# In the first option we are asked to introduce a limit value, once we have done it the program will take us
# to an html file in which we can see a list, whose is equal to the limit, of species stored in the ensembl
# data base
elif action == "/listSpecies":
# This is the basic structure of the html page that we will get, it is incomplete...
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8" >
<title>List of species in the browser</title >
</head >
<body>
<p>The total number of species in ensembl is: 286</p>"""
# We get the arguments that go after the ? in the path, Limit = "whatever input we introduce"
get_value = arguments[1]
limit_input = get_value.split('?')
# We have the couple of elements, split by = and get them separated, the value that will be used is
# limit value
limit_action, limit_value = limit_input[0].split("=")
# We try to convert it into an integer to return error page if there is a value error. Also if we leave
# it in blank we should get the full list
if limit_value == "":
limit_value = "286"
limit_value = int(limit_value)
if limit_value <= 0:
contents = Path('error.html').read_text()
if limit_value > 0:
# Just addition to html response...
contents += f"""<p>The number of species you selected are: {limit_value} </p>"""
# We set the main elements that will be used to get the list: ensembl server, endpoint that was
# previously searched for this function and parameters
server = 'rest.ensembl.org'
endpoint = 'info/species'
parameters = '?content-type=application/json'
request = endpoint + parameters
# Connect with the server
conn = http.client.HTTPConnection(server)
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the response message from the server
response = conn.getresponse()
# Read the response's body
body = response.read().decode()
# We create blank list where we will store the data received from JSON
limit_list = []
# Create a variable with the data, form the JSON received. We get the key that interest us, species.
body = json.loads(body)
species = body["species"]
# First we compare if our input of limit is higher than the available numbre of species. On that
# case we will be taken to an error page
if limit_value > len(species):
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8" >
<title>ERROR</title >
</head>
<body>
<p>ERROR LIMIT OUT OF RANGE. Introduce a valid limit value</p>
<a href="/">Main page</a></body></html>"""
# In case our input is valid, we iterate through all the species and get the key we are looking for,
# their names, which appears as display_name. We will introduce them to our blank list; once its
# lengthis equal to the limit value we introduce we stop iterating and get the final list of
# species
else:
for element in species:
limit_list.append(element["display_name"])
if len(limit_list) == limit_value:
contents += f"""<p>The species are: </p>"""
for specie in limit_list:
contents += f"""<p> - {specie} </p>"""
contents += f"""<a href="/">Main page</a></body></html>"""
code = 200
# We just add the final info to our html to be given us back, if we got here everything has
# gone correctly
# In this option we are asked to introduce the name of a specie of the ensembl data base, the program should
# give us back a list of the chromosomes of that specie
elif action == "/karyotype":
# This is the basic structure of the html page that we will get, it is incomplete...
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8">
<title> Karyotype </title >
</head >
<body>
<h2> The names of the chromosomes are:</h2>"""
# We get the arguments that go after the ? in the path, Specie = "whatever input we introduce"
get_value = arguments[1]
specie_input = get_value.split('?')
# We have the couple of elements, split by = and get them separated, the value that will be used is
# specie name. We introduce a change so if we write an specie compose by two names we
# will also get its info
specie_action, name = specie_input[0].split("=")
name_sp = name.replace("+", "_")
# We set the main elements that will be used to get the list: ensembl server, endpoint that was
# previously searched for this function and parameters
server = 'rest.ensembl.org'
endpoint = 'info/assembly/'
parameters = '?content-type=application/json'
request = endpoint + name_sp + parameters
# Connect with the server
conn = http.client.HTTPConnection(server)
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the response message from the server
response = conn.getresponse()
# Read the response's body
body = response.read().decode("utf-8")
# Create a variable with the data, form the JSON received. We get the key that interest us, karyotype.
body = json.loads(body)
karyotype_data = body["karyotype"]
if len(karyotype_data) == 0:
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8">
<title> Karyotype </title >
</head >
<body>
<h2> Ups...</h2>
<p> It seems that the karyotype of {name.replace("+"," ")} is not available in ensembl database <p>
<a href="/">Main page </a></body></html>"""
code = 200
else:
# This key has associated a list with the different chromosomes, we just get them and add to our
# html
for chromosome in karyotype_data:
contents += f"""<p> - {chromosome} </p>"""
# We just add an option to return to the index and our html is now completed,if we got here
# everything has gone correctly
contents += f"""<a href="/">Main page </a></body></html>"""
code = 200
# In this option we are asked to introduce the name of a specie of the ensembl data base and the name of one
# of its chromosomes, the program should give us back the length of the chromosome
elif action == "/chromosomeLength":
# We get the arguments that go after the ? in the path, Specie = "whatever input we introduce" and
# Chromosome = "whatever input we introduce"
pair = arguments[1]
pairs = pair.split('&')
# We have two couple of elements, split each by =. The values that will be used are specie and
# chromosome that we introduced. We introduce a change so if we write an specie compose by two names we
# will also get its info
specie_name, name = pairs[0].split("=")
chromosome_index, chromosome = pairs[1].split("=")
specie = name.replace("+", "%20")
chromosome = chromosome.capitalize()
# We set the main elements that will be used to get the list: ensembl server, endpoint that was
# previously searched for this function and parameters
server = 'rest.ensembl.org'
endpoint = f'info/assembly/'
parameters = '?content-type=application/json'
request = endpoint + specie + parameters
# Connect with the server
conn = http.client.HTTPConnection(server)
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the response message from the server
response = conn.getresponse()
# Read the response's body
body = response.read().decode()
# Create a variable with the data, form the JSON received. We get the key that interest us, chromosomic
# data
chromosomic_data = json.loads(body)
# As it was researched at the Api of ensembl this will give us a superdictionary, we are looking for
# specific elements that are inside key top_level_region, we will iterate through
for chromo in chromosomic_data["top_level_region"]:
# The "sub"key we are looking for is name, we compare with the chromosome we introduced and if we
# get a coincidence we will get the value of key length of that specific chromosome
if chromosome == chromo["name"]:
# Once we have the value we will directly create the html with the info, the aim of this is
# to deal with possible errors in an easy way
length = chromo["length"]
contents = f"""<!DOCTYPE html><html lang = "en">
<head>
<meta charset = "utf-8" >
<title> Length Chromosome</title >
</head>
<body>
<h2> Chromosome length</h2>
<meta charset = "utf-8" >
<title> Chromosome length </title >
<p>The lenght of the chromosome {chromosome} from {specie.replace("%20", " ")} is : </p>
<p> {length}</p>
<a href="/">Main page</a></body></html>"""
code = 200
# If we got here everything has gone correctly
# This is the start of the medium level. The first option asks us to introduce the name of a gen of the
# ensembl database and get back its genomic sequence
elif action == "/geneSeq":
# This is the basic structure of the html page that we will get, it is incomplete...
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8"
<title> Gene Sequence </title>
</head>"""
# We get the arguments that go after the ? in the path, Gen name = "whatever input we introduce"
get_value = arguments[1]
pair = get_value.split('?')
# We have a couple of elements, split each by =. The value that will be used is the name of the gen
gen, name_gene = pair[0].split("=")
# Just addition to html response...
contents += f"""<p> The sequence of gene {name_gene} is: </p>"""
# We set the main elements that will be used to get the list: ensembl server, endpoint that was
# previously searched for this function and parameters
server = 'rest.ensembl.org'
first_endpoint = "xrefs/symbol/homo_sapiens/"
parameters = '?content-type=application/json'
first_request = first_endpoint + name_gene + parameters
# Connect with the server
conn = http.client.HTTPConnection(server)
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", first_request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the response message from the server
response = conn.getresponse()
# -- Read the response's body
body = response.read().decode()
# Create a variable with the data, form the JSON received. We get the first element and the key of
# dictionary that interest us, id
body = json.loads(body)
id_gene = body[0]
id_gene = id_gene["id"]
# Once we have the id (how it appears in ensemble database) of the gen that we want we perform a second
# connection, now for getting the sequence that gene in concrete. We use the endpoint previously
# researched in the ensembl api
second_endpoint = "sequence/id/"
second_request = second_endpoint + id_gene + parameters
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", second_request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the second response message from the server
response2 = conn.getresponse()
# Read the second response's body
body2 = response2.read().decode()
# Create a variable with the data, form the second JSON received. We get the first element and the key
# of dictionary that interest us, seq
body2 = json.loads(body2)
# We get the value associated to that key, the sequence of the gen. We add it to our html page
sequence = body2["seq"]
contents += f"""<p>{sequence}</p><a href="/">Main page</a></body></html>"""
code = 200
# If we got here everything has gone correctly
# In this option we are asked to introduce a gene and get specific info about it
elif action == "/geneInfo":
# This is the basic structure of the html page that we will get, it is incomplete...
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8"
<title> Gene Information</title>
</head>"""
# We get the arguments that go after the ? in the path, Gen name = "whatever input we introduce"
get_value = arguments[1]
pair = get_value.split('?')
# We have a couple of elements, split each by =. The value that will be used is the name of the gen
gen, name_gene = pair[0].split("=")
# Just addition to html response...
contents += f"""<p> The information of gene {name_gene} is: </p>"""
# We set the main elements that will be used to get the list: ensembl server, endpoint that was
# previously searched for this function and parameters
server = 'rest.ensembl.org'
first_endpoint = "xrefs/symbol/homo_sapiens/"
parameters = '?content-type=application/json'
first_request = first_endpoint + name_gene + parameters
# Connect to server
conn = http.client.HTTPConnection(server)
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", first_request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the response message from the server
response = conn.getresponse()
# Read the response's body
body = response.read().decode()
# Create a variable with the data, form the JSON received. We get the first element and the key of
# dictionary that interest us, id
body = json.loads(body)
id_gene = body[0]
id_gene = id_gene["id"]
# Once we have the id (how it appears in ensemble database) of the gen that we want we perform a second
# connection, now for getting the info that gene in concrete. We use the endpoint previously researched
# in the ensembl api
second_endpoint = "lookup/id/"
second_request = second_endpoint + id_gene + parameters
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", second_request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the second response message from the server
response2 = conn.getresponse()
# Read the second response's body
body2 = response2.read().decode()
# Create a variable with the data, form the JSON received. We get diferent values associated to the
# keys that contain the info we are looking for
body2 = json.loads(body2)
length = int(body2["end"]) - int(body2["start"])
# Once we have all the info collected, just complete the html response
contents += f"""<p> The gene starts at: {body2["start"]} </p><p> The gene ends at: {body2["end"]} </p>
<p> The gene length is: {length}</p>
<p> The gene id is at: {id_gene} </p> <p> The gene is on chromosome: {body2["seq_region_name"]} </p>
<a href="/">Main page</a></body></html>"""
code = 200
# If we got here everything has gone correctly
# In this option we are asked to introduce a gene and perform some calculations with it, we will need Seq
# from Seq1
elif action == "/geneCalc":
# This is the basic structure of the html page that we will get, it is incomplete...
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8"
<title> Gene Calculations</title>
</head>"""
# We get the arguments that go after the ? in the path, Gen name = "whatever input we introduce"
get_value = arguments[1]
pair = get_value.split('?')
# We have a couple of elements, split each by =. The value that will be used is the name of the gen
seq_name, name_seq = pair[0].split("=")
# We set the main elements that will be used to get the list: ensembl server, endpoint that was
# previously searched for this function and parameters
server = 'rest.ensembl.org'
first_endpoint = "xrefs/symbol/homo_sapiens/"
parameters = '?content-type=application/json'
first_request = first_endpoint + name_seq + parameters
# Connect with the server
conn = http.client.HTTPConnection(server)
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", first_request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the response message from the server
response = conn.getresponse()
# Read the response's body
body = response.read().decode()
# Create a variable with the data, form the JSON received. We get the first element and the key of
# dictionary that interest us, id
body = json.loads(body)
id_gene = body[0]
id_gene = id_gene["id"]
# Once we have the id (how it appears in ensemble database) of the gen that we want we perform a second
# connection, now for getting the info that gene in concrete. We use the endpoint previously researched
# in the ensembl api
second_endpoint = "sequence/id/"
second_request = second_endpoint + id_gene + parameters
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", second_request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the second response message from the server
response2 = conn.getresponse()
# Read the second response's body
body2 = response2.read().decode()
body2 = json.loads(body2)
# Create a variable with the data, form the JSON received. We get value associated to the
# key that contain the info we are looking for, the gen sequence. We convert it into an object of our
# class Seq in order to perform the calculations with it
sequence = Seq(body2["seq"])
list_of_bases = ["A", "C", "G", "T"]
# Just addition to html response...
contents += f"""<p> The length of gene {name_seq} is: {sequence.len()} </p>"""
# We perform some calculations with the functions of Seq and add them to the html response to complete
for base in list_of_bases:
perc_base = round(
sequence.count_base(base) * 100 / sequence.len(), 2)
contents += f"""<p> {base} : {sequence.count_base(base)} ({perc_base}%) </p>"""
contents += f"""<a href="/">Main page</a></body></html>"""
code = 200
# If we got here everything has gone correctly
# In this last option we are asked to introduce a chromosome, an initial and final position within it and
# get the list of genes that compose it located within thi interval
elif action == "/geneList":
# This is the basic structure of the html page that we will get, it is incomplete...
contents = f"""<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8"
<title> Gene List</title>
</head>"""
# We get the arguments that go after the ? in the path, Chromosome name = "whatever input we introduce"
# Start = "whatever input we introduce" and End = "whatever input we introduce". We split this 3 couples
# by &
get_value = arguments[1]
pairs = get_value.split('&')
# We have a couple of elements, split each by =. The value that will be used is the name of the gen
chromosome_name, chromosome = pairs[0].split("=")
chromosome_start, start = pairs[1].split("=")
chromosome_end, end = pairs[2].split("=")
chromosome = chromosome.capitalize()
# Just in case we leave start at blank, it will start from 0
if start == "":
start = "0"
# Just addition to html response...
contents += f"""<p> List of genes of the chromosome {chromosome}, which goes from {start} to {end} </p>
"""
# We set the main elements that will be used to get the list: ensembl server, endpoint that was
# previously searched for this function and parameters
server = 'rest.ensembl.org'
parameters = "?feature=gene;content-type=application/json"
endpoint = "overlap/region/human/"
request = endpoint + chromosome + ":" + start + "-" + end + parameters
# Connect with the server
conn = http.client.HTTPConnection(server)
# Send the request message, using the GET method. We are
# requesting the main page (/)
try:
conn.request("GET", request)
except ConnectionRefusedError:
print("ERROR! Cannot connect to the Server")
exit()
# Read the response message from the server
response = conn.getresponse()
# Read the response's body
body = response.read().decode("utf-8")
# Read the response's body
body = json.loads(body)
# We iterate through the dictionary and get the values associated with the key we are interested in
for element in body:
# We add this info and our html response is now complete
contents += f"""<p>{element["external_name"]}</p>"""
contents += f"""<a href="/">Main page</a></body></html>"""
code = 200
# With except we will be able to deal with whatever possible error, such as introducing invalid inputs or inputs
# that don´t appear at the database, exceed the number of possible items of a list...
except (KeyError, ValueError, IndexError, TypeError):
contents = Path('error.html').read_text()
# Generating the response message
self.send_response(code) # -- Status line: OK!
# Define the content-type header:
self.send_header('Content-Type', 'text/html')
self.send_header('Content-Length', len(str.encode(contents)))
# The header is finished
self.end_headers()
# Send the response message
self.wfile.write(str.encode(contents))
return
from Seq1 import Seq
print("-----| Exercise 4 |------")
# -- Create a Null sequence
s1 = Seq('')
# -- Create a valid sequence
s2 = Seq("ACTGA")
# -- Create an invalid sequence
s3 = Seq("Invalid sequence")
print("Sequence", 1, ": (Length:", s1.len(), ")", s1)
print("Sequence", 2, ": (Length:", s2.len(), ")", s2)
print("Sequence", 3, ": (Length:", s3.len(), ")", s3)
def gene(cs,argument):
seq_gene = argument
response = ("Gene: " + "\n"+ argument + str(Seq.read_fasta(seq_gene)) + "\n")
print_colored(response, 'blue')
cs.send(str(response).encode())
from Seq1 import Seq
from P0 import sequences
print("-----|Practice1 ,Exercise 5|-----")
GENE_FOLDER = "./sequences2/"
gene_list = ["U5", "ADA", "FRAT1", "FXN", "RNU6_269P"]
for gene in gene_list:
s = Seq()
s.read_fasta(GENE_FOLDER + gene)
print("Gene", gene, ":", "Most frequent Base:", s.most_repeated_base())
def comp(cs,argument):
seq_comp = argument
response = ("Sequence: " + "\n" + str(seq_comp) + "\n" +
"Complement sequence: " + str(Seq.complement(seq_comp)))
print_colored(response, 'blue')
cs.send(str(response).encode())
def rev(cs,argument):
seq_rev = argument
response = ("Sequence: " + "\n" + str(seq_rev) + "\n" +
"Reverse sequence: " + str(Seq.reverse(seq_rev)))
print_colored(response,'yellow')
cs.send(str(response).encode())
elif command == "GET":
termcolor.cprint("GET command!", "green")
response = list_seq[int(argument)] + "\n"
print(response)
elif command == "INFO":
termcolor.cprint("INFO command!", "green")
response = info_seq(argument) + "\n"
print(response)
elif command == "COMP":
termcolor.cprint("COMP command!", "green")
seq = Seq(argument)
response = seq.complement() + "\n"
print(response)
elif command == "REV":
termcolor.cprint("REV command!", "green")
seq = Seq(argument)
response = seq.reverse() + "\n"
print(response)
elif command == "GENE":
termcolor.cprint("GENE command!", "green")
r1 = conn.getresponse()
print(f"Response received!: {r1.status} {r1.reason}\n")
data1 = r1.read().decode("utf-8")
response = json.loads(data1)
description = response["desc"]
bases = response["seq"]
termcolor.cprint(f"Gene: ", "green", end="")
print(gene)
termcolor.cprint(f"Description: ", "green", end="")
print(description)
sequence = Seq(bases)
termcolor.cprint(f"Total lenght: ", "green", end="")
print(sequence.len())
counter = 0
for base in list_bases:
termcolor.cprint(f"{base}: ", "blue", end="")
print(
f"{sequence.seq_count_base(base)[0]} ({sequence.seq_count_base(base)[1]}%)"
)
if sequence.seq_count_base(base)[0] > counter:
counter = sequence.seq_count_base(base)[0]
mostfrbase = base
from Seq1 import Seq
print("-----| Practice 1, Exercise 4 |------")
s1 = Seq()
s2 = Seq("ACTGA")
s3 = Seq("Invalid Sequence")
print("Sequence" + str(1) + ": (lenght:" + str(s1.len()) + ") " + str(s1))
print("Sequence" + str(2) + ": (lenght:" + str(s2.len()) + ") " + str(s2))
print("Sequence" + str(3) + ": (lenght:" + str(s3.len()) + ") " + str(s3))
from Seq1 import Seq
print('"-----| Exercise 1 |------"')
seq = Seq('ACTGA')
print('Sequence ' + str(1) + ': (Length: ' + str(seq.len()) + ")" + str(seq))
PORT1 = 8080
PORT2 = 8081
FOLDER = "../Session-04/"
EXT = ".txt"
GENE = "FRAT1"
c1 = Client(IP, PORT1)
c2 = Client(IP, PORT2)
# Print the IP and PORTs
print(c1)
print(c2)
# Read the Gene from a file
s = Seq().seq_read_fasta(FOLDER + GENE + EXT)
bases = str(s)
# Print the Gene
print(f"Gene {GENE}: {bases}")
LENGTH = 10
# initial message to both servers
initial_msg = f"Sending {GENE} Gene to the server, in fragments of {LENGTH} bases..."
c1.talk(initial_msg)
c2.talk(initial_msg)
# Create the fragments
from Seq1 import Seq
print('-----|Practice 1, Exercise 4|-----')
s1 = Seq()
s2 = Seq('ACTGA')
s3 = Seq('Invalid Sequence')
print('Sequence ' + str(1) + ': (Length:' + str(s1.len()) + ') '+ str(s1))
print('Sequence ' + str(2) + ': (Length:' + str(s2.len()) + ') '+ str(s2))
print('Sequence ' + str(3) + ': (Length:' + str(s3.len()) + ') '+ str(s3))
def do_GET(self):
termcolor.cprint(self.requestline, 'green')
req_line = self.requestline.split(' ')
arguments = req_line[1].split('?')
verb = arguments[0]
contents = Path('Error.html').read_text()
error_code = 404
if verb == "/":
contents = Path('form-4.html').read_text()
error_code = 200
elif verb == "/ping":
contents = """
<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8" >
<title> PING </title >
</head >
<body>
<h2> PING OK!</h2>
<p> The SEQ2 server in running... </p>
<a href="/">Main page</a>
</body>
</html>
"""
error_code = 200
elif verb == "/get":
# -- Get the argument to the right of the ? symbol
pair = arguments[1]
# -- Get all the pairs name = value
pairs = pair.split('&')
# -- Get the two elements: name and value
name, value = pairs[0].split("=")
n = int(value)
# -- Get the sequence
seq = SEQ_GET[n]
# -- Generate the html code
contents = f"""
<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8" >
<title> GET </title >
</head >
<body>
<h2> Sequence number {n}</h2>
<p> {seq} </p>
<a href="/">Main page</a>
</body>
</html>
"""
error_code = 200
elif verb == "/gene":
# -- Get the argument to the right of the ? symbol
pair = arguments[1]
# -- Get all the pairs name = value
pairs = pair.split('&')
# -- Get the two elements: name and value
name, gene = pairs[0].split("=")
s = Seq()
s.read_fasta(FOLDER + gene + EXT)
gene_str = str(s)
# -- Generate the html code
contents = f"""
<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8" >
<title> GENE </title >
</head >
<body>
<h2> Gene: {gene}</h2>
<textarea readonly rows="20" cols="80"> {gene_str} </textarea>
<br>
<br>
<a href="/">Main page</a>
</body>
</html>
"""
error_code = 200
elif verb == "/operation":
# -- Get the argument to the right of the ? symbol
pair = arguments[1]
# -- Get all the pairs name = value
pairs = pair.split('&')
# -- Get the two elements: name and value
name, seq = pairs[0].split("=")
# -- Get the two elements of the operation
name, op = pairs[1].split("=")
# -- Create the sequence
s = Seq(seq)
if op == "comp":
result = s.complement()
elif op == "rev":
result = s.reverse()
else:
sl = s.len()
ca = s.count_base('A')
pa = "{:.1f}".format(100 * ca / sl)
cc = s.count_base('C')
pc = "{:.1f}".format(100 * cc / sl)
cg = s.count_base('G')
pg = "{:.1f}".format(100 * cg / sl)
ct = s.count_base('T')
pt = "{:.1f}".format(100 * ct / sl)
result = f"""
<p>Total length: {sl}</p>
<p>A: {ca} ({pa}%)</p>
<p>C: {cc} ({pc}%)</p>
<p>G: {cg} ({pg}%)</p>
<p>T: {ct} ({pt}%)</p>"""
contents = f"""
<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8" >
<title> OPERATION </title >
</head >
<body>
<h2> Sequence </h2>
<p>{seq}</p>
<h2> Operation: </h2>
<p>{op}</p>
<h2> Result: </h2>
<p>{result}</p>
<br>
<br>
<a href="/">Main page</a>
</body>
</html>
"""
error_code = 200
# Generating the response message
self.send_response(error_code) # -- Status line: OK!
# Define the content-type header:
self.send_header('Content-Type', 'text/html')
self.send_header('Content-Length', len(str.encode(contents)))
# The header is finished
self.end_headers()
# Send the response message
self.wfile.write(str.encode(contents))
return
from Seq1 import Seq
s1 = Seq()
s2 = Seq("ACTGA")
s3 = Seq("Invalid sequence")
print(f"Sequence 1: (Length: {s1.len()}) {s1}")
print(f" Bases: {s1.count()}")
print(f"Reverse: {s1.reverse()}")
print(f"Complement: {s1.complement()}")
print(f"Sequence 2: (Length: {s2.len()}) {s2}")
print(f" Bases: {s2.count()}")
print(f"Reverse: {s2.reverse()}")
print(f"Complement: {s2.complement()}")
print(f"Sequence 3: (Length: {s3.len()}) {s3}")
print(f" Bases: {s3.count()}")
print(f"Reverse: {s3.reverse()}")
print(f"Complement: {s3.complement()}")
from Client0 import Client
from Seq1 import Seq
PRACTICE = 2
EXERCISE = 6
print(f"-----| Practice {PRACTICE}, Exercise {EXERCISE} |------")
IP = "192.168.1.54"
PORT = 8080
c = Client(IP, PORT)
s = Seq()
s.read_fasta('../SESSION 4/FRAT1.txt')
count = 0
i = 0
while i < len(s.strbases) and count < 5:
fragment = s.strbases[i:i + 10]
count += 1
i += 10
print('Fragment', count, ':', fragment)
print(c.talk(fragment))
from Seq1 import Seq
"""Write a python program that automatically calculate the answer to this question:
Which is the most frequent base in each gene?
This exercise is the same than the exercise 8 of practice 0,
but we are using the Seq Class instead of the functions developed
in the Seq0 module"""
PROJECT_PATH = '../P0/sequences/'
print('--------- |Practice 1, Exercise 10| ---------')
list_sequences = ['U5.txt', 'ADA.txt', 'FRAT1.txt', 'FXN.txt', 'RNU6_269P.txt']
for i in list_sequences:
seq = Seq()
seq.seq_read_fasta(PROJECT_PATH +
i) #quitan la primera línea y leen el código
print('Gene ' + i[:-4] + ': Most frequent Base: ' + seq.processing_genes())
def do_GET(self):
global contents
termcolor.cprint(self.requestline, 'green')
termcolor.cprint(self.path, 'blue')
o = urlparse(self.path)
path_name = o.path
arguments = parse_qs(o.query)
print("Resource requested: ", path_name)
print("Parameters: ", arguments)
# IN this simple server version:
# We are NOT processing the client's request
# It is a happy server: It always returns a message saying
# that everything is ok
context = {}
# Message to send back to the client
PARAMETERS = '?content-type=application/json'
SERVER = "rest.ensembl.org"
connection = http.client.HTTPConnection(SERVER)
if path_name == '/':
contents = Path('./html/index.html').read_text()
elif path_name == "/listSpecies":
try:
ENDPOINT = '/info/species'
connection.request('GET', ENDPOINT + PARAMETERS)
response = connection.getresponse()
final_response = json.loads(response.read().decode())
species_list = final_response['species']
names_list = []
for elem in species_list:
s1 = elem['name']
lists = [s1]
names_list = names_list + lists
if 'limit' in arguments:
limit = int(arguments['limit'][0])
final_list = names_list[:limit]
if limit <= len(final_list):
context['length'] = len(names_list)
context['final_list'] = final_list
context['limit'] = limit
contents = su.read_template_html_file(
'./html/limit_name_list.html').render(
context=context)
else:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
elif 'limit' not in arguments:
context['length'] = len(names_list)
context['final_list'] = names_list
contents = su.read_template_html_file(
'./html/full_name_list.html').render(context=context)
except KeyError:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
elif path_name == "/karyotype":
try:
species_name = arguments['species_name'][0]
ENDPOINT = '/info/assembly/'
connection.request('GET', ENDPOINT + species_name + PARAMETERS)
response = connection.getresponse()
final_response = json.loads(response.read().decode())
karyotype = final_response['karyotype']
context['karyotype'] = karyotype
contents = su.read_template_html_file(
'./html/karyotype.html').render(context=context)
except KeyError:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
elif path_name == "/chromosomeLength":
try:
if 'species_name' not in arguments:
contents = su.read_template_html_file(
'./html basic/ERROR.html').render()
elif 'chromosome_name' not in arguments:
contents = su.read_template_html_file(
'./html basic/ERROR.html').render()
else:
global chromosome_length
species_name = arguments['species_name'][0]
chromosome_name = arguments['chromosome_name'][0]
ENDPOINT = '/info/assembly/'
connection.request('GET',
ENDPOINT + species_name + PARAMETERS)
response = connection.getresponse()
final_response = json.loads(response.read().decode())
list_dict = final_response['top_level_region']
for elem in list_dict:
if (elem['name']
== chromosome_name) and (elem['coord_system']
== 'chromosome'):
chromosome_length = elem['length']
else:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
context['chromosome_length'] = chromosome_length
contents = su.read_template_html_file(
'./html/chromosome_length.html').render(
context=context)
except KeyError:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
elif path_name == "/geneSeq":
try:
gene = arguments['gene'][0]
GENE_ID = genes_dict[gene]
ENDPOINT = '/sequence/id/'
connection.request('GET', ENDPOINT + GENE_ID + PARAMETERS)
response = connection.getresponse()
final_response = json.loads(response.read().decode())
sequence = final_response['seq']
context['sequence'] = sequence
contents = su.read_template_html_file(
'./html/Seq.html').render(context=context)
except KeyError:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
elif path_name == "/geneInfo":
try:
gene = arguments['gene'][0]
GENE_ID = genes_dict[gene]
ENDPOINT = '/sequence/id/'
connection.request('GET', ENDPOINT + GENE_ID + PARAMETERS)
response = connection.getresponse()
final_response = json.loads(response.read().decode())
info_list = final_response['desc'].split(':')
context['genname'] = gene
context['start'] = info_list[3]
context['end'] = info_list[4]
context['length'] = int(info_list[4]) - int(info_list[3])
context['id'] = GENE_ID
context['chromoname'] = info_list[1]
contents = su.read_template_html_file(
'./html/Info.html').render(context=context)
except KeyError:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
elif path_name == '/geneCalc':
try:
gene = arguments['gene'][0]
GENE_ID = genes_dict[gene]
ENDPOINT = '/sequence/id/'
connection.request('GET', ENDPOINT + GENE_ID + PARAMETERS)
response = connection.getresponse()
final_response = json.loads(response.read().decode())
sequence = final_response['seq']
s = Seq(sequence)
context['length'] = s.len()
context['percentageA'] = s.percentage_base('A')
context['percentageC'] = s.percentage_base('C')
context['percentageG'] = s.percentage_base('G')
context['percentageT'] = s.percentage_base('T')
contents = su.read_template_html_file(
'./html/Calc.html').render(context=context)
except KeyError:
contents = su.read_template_html_file(
'./html/error.html').render(context=context)
else:
pass
self.send_response(200) # -- Status line: OK!
# Define the content-type header:
self.send_header('Content-Type', 'text/html')
content_length = len(str.encode(contents))
self.send_header('Content-Length', content_length)
# The header is finished
self.end_headers()
# Send the response message
self.wfile.write(contents.encode())
return
import operator
from Seq1 import Seq
from pathlib import Path
FOLDER = "/home/alumnos/joseepp/PycharmProjects/2019-2020-PNE-Practices/Session-04/"
FILENAME = ["U5", "ADA", "FRAT1", "FXN", "RNU6_269P"]
BASES = ["A", "C", "G", "T"]
# - - For each gene (element of FILENAME) we calculate its data:
for element in FILENAME:
dnafile = FOLDER + element + ".txt"
s = Seq()
s1 = Seq(s.read_fasta(dnafile))
print("Gene", element + ":", " Most frequent base: ",
s1.processing_genes(BASES))
from Seq1 import Seq
FOLDER = "../Session-04/"
FILENAME = "U5.txt"
# -- Create a Null sequence
s = Seq()
# -- Initialize the null seq with the given file in fasta format
s.read_fasta(FOLDER+FILENAME)
print(f"Sequence : (Length: {s.len()}) {s}\n Bases: {s.seq_count()} \n "
f"Rev: {s.seq_reverse()} \n Comp: {s.seq_complement()}")
# -- Read the response's body
data1 = r1.read().decode("utf-8")
# -- Create a variable with the data,
# -- form the JSON received
response = json.loads(data1)
termcolor.cprint(f"Gene: ", "green", end="")
print(element)
termcolor.cprint(f"Description: ", "green", end="")
print(response['desc'])
bases = response['seq']
sequence = Seq(bases)
termcolor.cprint(f"Total lengh: ", "green", end="")
print(sequence.len())
freq_counter = 0
for base in list_bases:
sequence.count_base(base)
termcolor.cprint(f"{base}: ", "blue", end="")
print(
f"{sequence.count_base(base)[0]} ({sequence.count_base(base)[1]}%)"
)
if sequence.count_base(base)[0] > freq_counter:
freq_counter = sequence.count_base(base)[0]
freq_base = base
from Seq1 import Seq
def print_counts(i, sequence):
print(f"Sequence {i}: (Length: {Seq.len(sequence)}) {sequence}")
a, c, t, g = Seq.count_bases_no_count(sequence)
print(f" A: {a}, C: {c}, T: {t}, G: {g}")
print("-----| Practice 1, Exercise 5 |------")
seq1 = Seq()
seq2 = Seq("ACTGA")
seq3 = Seq("Invalid sequence")
# NO LOOP
#print_counts(1, seq1)EXERCISE
#print_counts(2, seq2)
#print_counts(3, seq3)
# WITH A FOR LOOP
sequence_list = [seq1, seq2, seq3]
for i in range(1, len(sequence_list) + 1):
print_counts(i, sequence_list[i - 1])
from Seq1 import Seq, test_sequences
print("-----| Practice 1, Exercise 4 |------")
slist = list(test_sequences())
Seq.print_seqs((slist))
def print_counts(i, sequence):
print(f"Sequence {i}: (Length: {Seq.len(sequence)}) {sequence}")
a, c, t, g = Seq.count_bases_no_count(sequence)
print(f" A: {a}, C: {c}, T: {t}, G: {g}")
def rev(seq):
s = Seq(seq)
result = str(Seq.reverse(s))
context = {"seq": s, "op": "Rev", "res": result}
content = read_template("./html/operation.html").render(context=context)
return content
from Client0 import Client
from Seq1 import Seq
print(f"-----| Practice 2, Exercise 5 |------")
IP = "127.0.0.1"
PORT = 8080
c = Client(IP, PORT)
FOLDER = "../Session_04/"
GENE = "U5"
EXT = ".txt"
file_name = FOLDER + GENE + EXT
sequence = Seq("")
sequence = str(sequence.read_fasta(file_name))
c.debug_talk(f"Sending the {GENE} Gene to the server...")
c.debug_talk(sequence)