def highestScoreButtonClicked(self):
from Scene.HighestScoreScene import HighestScoreScene
highestScoreScene = HighestScoreScene(Director().window)
Director().nowScene = highestScoreScene
highestScoreScene.init()
highestScoreScene.show()
self.deleteLater()
def crearCuentaCorriente(self):
cuentaCorrienteBuilder = CuentaCorriente()
director = Director()
director.setBuilder(cuentaCorrienteBuilder)
cuentaCorriente = director.getAccount()
cuentaCorriente.getAccountInfo()
print("Creando cuenta corriente.")
def returnToStartSceneButtonClicked(self):
from Scene.StartScene import StartScene
startScene = StartScene(Director().window)
Director().nowScene = startScene
startScene.init()
startScene.show()
self.deleteLater()
def settingButtonClicked(self):
from Scene.SettingScene import SettingScene
settingScene = SettingScene(Director().window)
Director().nowScene = settingScene
settingScene.init()
settingScene.show()
self.deleteLater()
def crearCuentaAhorros(self):
cuentaAhorrosBuilder = CuentaAhorros()
director = Director()
director.setBuilder(cuentaAhorrosBuilder)
cuentaAhorros = director.getAccount()
cuentaAhorros.getAccountInfo()
print("Creando cuenta de ahorros.")
def newGameButtonClicked(self):
from Scene.SpeedChooseScene import SpeedChooseScene
speedChooseScene = SpeedChooseScene(Director().window)
Director().nowScene = speedChooseScene
speedChooseScene.init()
speedChooseScene.show()
self.deleteLater()
def test_other():
filename = 'Data1000Movies.csv'
file_reader = MovieFileCSVReader(filename)
file_reader.read_csv_file()
all_directors_sorted = sorted(file_reader.dataset_of_directors)
assert all_directors_sorted[0:3] == [
Director("Aamir Khan"),
Director("Abdellatif Kechiche"),
Director("Adam Leon")
]
def __init__(self, species):
self.species = species
self.director = Director()
self.refseq = RefseqBuilder(self.species)
self.ensembl = EnsemblBuilder(self.species)
self.idConv = ConverterBuilder(self.species)
self.Transcripts = {}
self.Genes = {}
self.Domains = {}
self.Proteins = {}
self.mismatches_sep = []
self.mismatches_merged = []
def test_file_to_seqbias(self):
seq_list = [
[
"test1",
"IKAAESFLPSPVLRTDVMFLVPALKYNPLHRLLIQILGGHETMIQIGHAETATVKFEERLVERIFDKRAGTSSLILIQIDYDEIQIWPGYSILRLGMPEKDEIQIAIITEMKRGAPHIQIQILDFGPAISFKESWLDCVMGNCYNDIASEIKVRGSDLNKVGVRARKECGVATSPINAFINRLLSATYSVGVNFLAVIQISTGIDKVHTNYDKA"
],
[
"test2",
"TTNIISELRCTQTCGNAMDNWMGEVLDGTPAFHFGVHCGDTAGPASKRFLLVCLEFSLRGYDLLVRLLLIKDEDANDVHCNQKCSQCCQKCMAHLALGPVTCSSSFNVHYSPGIGALWACIQTCEIDYCIQPCKACVQSCEERSLKVIKADGITAKSFAPMPNGAVDPSTVEYMVKTLIVCLQTCYDENRTVRRFPEKAL"
],
[
"test3",
"YPSSALQGGSMSRFLSPTMLRVRASLGFLGINLLPWTLFVIAALPSKSDAQLSSTQPLSAMGMEFIRANTESEINFVDKIHYAYHNLVVDPRKVDSEIAKERCKLLKSIVQVGSVTFATVPGDSYIGISSRSLMFVSEKNTGRELGNKCSAEQDDSSDQKNSGTAECGKLYSYEQWESTREGVDIIRKKTAVTHSNRQIPSVADHPLFLADAHEG"
]
]
path_in = "/Users/coltongarelli/SequenceAnalyzer/PAM/Tests/Resources/SequenceBiasIOTestFile"
director = Director()
director.file_in_path = path_in
director.start_up()
seq_record_list = []
for i in seq_list:
seq_record_list.append(SeqRecord.SeqRecord(id=i[0], seq=i[1]))
director.master_list = seq_record_list
director.run_bias_analysis()
for i in range(len(seq_list)):
self.assertEqual(director.master_list[i].seq, seq_list[i][1])
self.assertEqual(director.master_list[i].id, seq_list[i][0])
def updateDirector(self, db):
id = eval(raw_input(" Enter id: "))
name = raw_input(" Enter name: ")
country = raw_input(" Enter country: ")
age = eval(raw_input(" Enter age: "))
countFilms = eval(raw_input(" Enter count of films: "))
db.update_director(Director(id, name, country, age, countFilms))
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
movie = Movie(row["Title"], int(row["Year"]))
movie.description = row["Description"]
movie.runtime_minutes = int(row["Runtime (Minutes)"])
self.__total_runtime_minutes += int(row["Runtime (Minutes)"])
self.__runtime_minutes_number_of_movies += 1
if row["Rating"] != "N/A":
movie.rating = float(row['Rating'])
self.__total_rating += float(row['Rating'])
self.__rating_number_of_movies += 1
if row["Votes"] != "N/A":
movie.votes = int(row["Votes"])
self.__total_votes += int(row["Votes"])
self.__votes_number_of_movies += 1
if row["Revenue (Millions)"] != "N/A":
movie.revenue_millions = float(row["Revenue (Millions)"])
self.__total_revenue_millions += float(
row["Revenue (Millions)"])
self.__revenue_millions_number_of_movies += 1
if row["Metascore"] != "N/A":
movie.metascore = int(row["Metascore"])
self.__total_metascore += int(row["Metascore"])
self.__metascore_number_of_movies += 1
self.__dataset_of_movies.append(movie)
self.__dataset_of_directors.add(Director(row["Director"]))
for actor in row["Actors"].split(","):
self.__dataset_of_actors.add(Actor(actor.strip()))
for genre in row["Genre"].split(","):
self.__dataset_of_genres.add(Genre(genre.strip()))
index += 1
def read_csv_file(self):
with open(self._file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
# Title Add
title = row['Title']
release_year = int(row['Year'])
new_movie = Movie(title, release_year)
self.dataset_of_movies.add(new_movie)
# Actor Add
actors = row['Actors']
actors_list = actors.split(",")
for people in actors_list:
new_actor = Actor(people.strip())
if new_actor not in self.dataset_of_actors:
self.dataset_of_actors.add(new_actor)
# Director Add
director = row['Director']
new_director = Director(director)
if new_director not in self.dataset_of_directors:
self.dataset_of_directors.add(new_director)
# Genre Add
genre = row['Genre']
genre_list = genre.split(",")
for g in genre_list:
new_genre = Genre(g.strip())
if new_genre not in self.dataset_of_genres:
self.dataset_of_genres.add(new_genre)
class EnlistCharacter:
personajesclonados = None
determinarpersonaje = None
determinararma = None
determinarAurora = None
constructorpersonaje = None
armarpersonaje = None
def __init__(self):
self.determinarpersonaje = DetermineCharacter()
self.determinararma = DetermineWeapon()
self.determinaraurora = Character()
self.constructorpersonaje = CharacterBuilder()
self.armarpersonaje = Director()
def generateChackra(func):
x = randint(0, 3)
def wrapper(self):
func(self, x)
return func
return wrapper
def createWeapon(self, number):
self.determinararma.createWeapon(number)
@generateChackra #decorador
def createAurora(self, number):
print(str(number))
self.determinaraurora.setAurora(number)
def createCharacter(self, number):
self.determinarpersonaje.createCharacter(number)
def BuildCharacter(self):
self.armarpersonaje.setBuilder(self.constructorpersonaje)
self.armarpersonaje.BuildCharacter(
self.determinarpersonaje.getCharacter(),
self.determinararma.getWeapon(),
self.determinaraurora.getAuroraNum())
def cloneCharacter(self):
self.personajesclonados = self.armarpersonaje.getCharacter()
return self.personajesclonados.clone()
def run(self):
if self.__renderer is None:
print("[Fatal Error] No screen initialized")
sys.exit(1)
director = Director()
Director().set_scene(MainGameScene())
previous_time = time()
delta_t = time()
while not self.__gameover:
delta_t = (time() - previous_time)
scene = director.get_current_scene()
scene.update(delta_t)
self.handle_events()
self.__renderer.draw(scene)
previous_time = time()
return 0
class EnlistarPersonaje:
determinarpersonaje = None
determinararma = None
determinarescudo = None
constructorpersonaje = None
armarpersonaje = None
personajesclonados = None
def __init__(self):
self.determinarpersonaje = DeterminarPersonaje()
self.determinararma = DeterminarArma()
self.determinarescudo = Personaje()
self.constructorpersonaje = PersonajeBuilder()
self.armarpersonaje = Director()
def generarChakra(func):
x = randint(0, 4)
def wrapper(self):
func(self, x)
return func
return wrapper
def crearArma(self, number):
self.determinararma.crearArma(number)
@generarChakra #Patron decorator
def crearEscudo(self, number):
print(str(number))
self.determinarescudo.setEscudo(number)
def crearPersonaje(self, number):
self.determinarpersonaje.crearPersonaje(number)
def BuildPersonaje(self):
self.armarpersonaje.setBuilder(self.constructorpersonaje)
self.armarpersonaje.BuildPersonaje(
self.determinarpersonaje.getPersonaje(),
self.determinararma.getArma(),
self.determinarescudo.getEscudoNum())
def clonePersonaje(self):
self.personajesclonados = self.armarpersonaje.getPersonaje()
return self.personajesclonados.clone()
def test_jsonBuilder(self):
item1 = Item("id", 1)
item1.append("lastName", "Muster")
item1.append("firstName", "Max")
item2 = Item("id", 2)
item2.append("lastName", "Müller")
item2.append("firstName", "Ute")
builder = JsonBuilder()
builder.append(item1)
builder.append(item2)
director = Director(builder)
json = director.construct()
self.assertEqual(
'{{"id":"1", "lastName":"Muster", "firstName":"Max"},{"id":"2", "lastName":"Müller", "firstName":"Ute"}}',
json)
def test_xmlBuilder(self):
item1 = Item("id", 1)
item1.append("lastName", "Muster")
item1.append("firstName", "Max")
item2 = Item("id", 2)
item2.append("lastName", "Müller")
item2.append("firstName", "Ute")
builder = XmlBuilder()
builder.append(item1)
builder.append(item2)
director = Director(builder)
xml = director.construct()
self.assertEqual(
"<list><item><id>1</id><lastName>Muster</lastName><firstName>Max</firstName></item><item><id>2</id><lastName>Müller</lastName><firstName>Ute</firstName></item></list>",
xml)
def lista_dir(cale):
for element in os.listdir(cale):
if os.path.isdir(os.path.abspath(cale) + "\\" + element):
dir_list.append(Director(element, os.path.abspath(cale)+"\\"+element))
lista_dir(os.path.abspath(cale) + "\\" + element)
def initializeEmployees(self, respondentCount, managerCount,
directorCount):
for i in range(respondentCount):
self.respondentStack.append(Respondent("Respondent" + str(i)))
for i in range(managerCount):
self.managerStack.append(Manager("Manager" + str(i)))
for i in range(directorCount):
self.directorStack.append(Director("Director" + str(i)))
def test_given(movie):
movie = Movie("Moana", 2016)
assert movie == Movie("Moana", 2016)
director = Director("Ron Clements")
movie.director = director
assert movie.director == Director("Ron Clements")
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie.add_actor(actor)
assert movie.actors == actors
movie.runtime_minutes = 107
assert movie.runtime_minutes == 107
def crear_director(id_director, nombre_apellido, anio_nacimiento, anio_debut,
casado, calificacion_pelicula_alta_IMDB_director):
director = Director()
director.set_id_director = director
director.set_nombre_apellido = nombre_apellido
director.set_anio_nacimiento = anio_nacimiento
director.set_anio_debut = anio_debut
director.set_casado = casado
director.set_calificacion_pelicula_alta_IMDB = calificacion_pelicula_alta_IMDB_director
return director
def gameEnd(self):
#定时器停止
self.timer.stop()
#判断是否是最高分
#如果是的话，则保存最高分并且录入保持者名字
if self.score > Config().highestScore:
Config().highestScore = self.score
highestScorePlayer = ""
#必须有纪录保持者
while highestScorePlayer == "":
highestScorePlayer = QInputDialog.getText(
self, self.tr("最高分！"),
self.tr("恭喜你的分数 %d 成为最高分，请留下你的尊姓大名。") % self.score)[0]
#录入最高分纪录保持者
Config().highestScorePlayer = highestScorePlayer
#判断是否要再来一局
#如果不要的话回到开始场景
if QMessageBox.information(
self, self.tr("游戏结束"),
self.tr("您的得分是：%d，是否要以当前难度再来一局？") % self.score,
QMessageBox.Yes, QMessageBox.No) == QMessageBox.No:
startScene = StartScene(Director().window)
Director().nowScene = startScene
startScene.init()
startScene.show()
self.deleteLater()
#否则将游戏的各项数据设置复原
else:
#重置蛇和食物
self.snake = Snake([5, 5], 2, 3)
self.food.updatePos(-1, self.spaceNum, -1, self.spaceNum,
self.snake.pos)
#重置分数
self.score = 0
#重置绘制定时器
self.timer.setInterval(1000 / self.fps)
self.timer.start()
def main():
if len(sys.argv) != 2:
usage()
if sys.argv[1] == "plain":
textbuilder = TextBuilder()
director = Director(textbuilder)
director.construct()
result = textbuilder.get_result()
print(result)
elif sys.argv[1] == "html":
htmlbuilder = HTMLBuilder()
director = Director(htmlbuilder)
director.construct()
filename = htmlbuilder.get_result()
print("{0}文件编写完成。".format(filename))
def __init__(self, download=False):
self.allDomains = dict(
) # keys are id, vals sre tuple combined from Domain object info
self.internalID = 0
self.allExt = dict()
self.allNames = dict()
self.allCDD = dict()
director = Director()
self.Interpro = InterProBuilder()
director.setBuilder(self.Interpro)
director.collectFromSource(download=False)
def __init__(self, download=False):
self.allDomains = pd.DataFrame({"name": [], "other_name": [], "description": [], "CDD_id": [],
"cdd": [], "pfam": [], "smart": [], "tigr": [], "interpro": []})
self.internalID = 0
self.allExt = dict()
self.allNames = dict()
self.allCDD = dict()
director = Director()
self.Interpro = InterProBuilder()
director.setBuilder(self.Interpro)
director.collectFromSource(download=download)
class Facade:
director = Director()
def crearCuentaAhorros(self):
cuentaAhorrosBuilder = CuentaAhorros()
director = Director()
director.setBuilder(cuentaAhorrosBuilder)
cuentaAhorros = director.getAccount()
cuentaAhorros.getAccountInfo()
print("Creando cuenta de ahorros.")
def crearCuentaCorriente(self):
cuentaCorrienteBuilder = CuentaCorriente()
director = Director()
director.setBuilder(cuentaCorrienteBuilder)
cuentaCorriente = director.getAccount()
cuentaCorriente.getAccountInfo()
print("Creando cuenta corriente.")
def handle_event(self, event: pygame.event):
if event.type == pygame.MOUSEBUTTONDOWN:
if self.button_rect.collidepoint(event.pos):
Director().pop_scene()
elif self.ten_km_up.get_rect().collidepoint(event.pos):
if self.db['points'] >= 50:
self.db['speed'] += 10
self.db['points'] -= 50
elif self.hundred_km_up.get_rect().collidepoint(event.pos):
if self.db['points'] >= 300:
self.db['speed'] += 100
self.db['points'] -= 300
elif self.five_hundred_km_up.get_rect().collidepoint(event.pos):
if self.db['points'] >= 1000:
self.db['speed'] += 500
self.db['points'] -= 1000
elif self.double_click_points.get_rect().collidepoint(event.pos):
if self.db['points'] >= 200:
self.db['points_per_click'] *= 2
self.db['points'] -= 200
def __init__(self, download=False):
self.allDomains = dict(
) # keys are id, vals are tuple combined from Domain object info
self.internalID = 0
self.allExt = dict()
self.allNames = dict()
self.allCDD = dict()
self.ignored_domains = {
"nonInterpro": [],
"onlyInterpro": [],
"family": []
}
director = Director()
self.Interpro = InterProBuilder()
director.setBuilder(self.Interpro)
director.collectFromSource(download=download)
import pygame
from Director import Director
from Pantallas import *
from Variables import *
from Personaje import Personaje
#testing comment
pygame.init()
#testing vs code git 2
director = Director()
pj = Personaje(pjx, pjy)
#create scenes
scene1 = Pantalla1(map1, "imagenes/mapas/city.jpg", soundtrack1, pj)
scene2 = Pantalla2(map2, "imagenes/mapas/forest.png", soundtrack2, pj)
scenes = [scene1, scene2]
#doing this we create all the scenes at the beginning and just change them during program
for e in scenes:
e.scenes = scenes
#use the first scene
if mapaG == 0:
director.change_scene(scene1)
pygame.mixer.music.load(scene1.soundtrack)
elif mapaG == 1:
director.change_scene(scene2)
pygame.mixer.music.load(scene2.soundtrack)
pygame.mixer.music.play()
#start the main loop
class Collector:
def __init__(self, species):
self.species = species
self.director = Director()
self.refseq = RefseqBuilder(self.species)
self.ensembl = EnsemblBuilder(self.species)
self.idConv = ConverterBuilder(self.species)
self.Transcripts = {}
self.Genes = {}
self.Domains = {}
self.Proteins = {}
self.mismatches_sep = []
self.mismatches_merged = []
def CollectSingle(self, attrName, download=False):
"""Collect data (call director) for a single builder (attrName)"""
self.director.setBuilder(self.__getattribute__(attrName))
self.director.collectFromSource(download)
print("{} data - collected!".format(attrName))
def collectAll(self, download=False, withEns=True):
"""Collect data from all builders (using CollectSingle)"""
BuildersList = ['refseq', 'idConv']
if withEns:
BuildersList.append('ensembl')
for builder in BuildersList:
self.CollectSingle(builder, download)
print("--------------------------------")
print("Data collection - COMPLETED!")
if withEns:
self.AllSourcesData()
else:
self.Transcripts = self.refseq.Transcripts
self.Proteins = self.refseq.Proteins
self.Genes = self.refseq.Genes
self.Domains = self.refseq.Domains
def AllSourcesData(self):
"""Combine the Transcrips, Gene, Protein, Domains data from refseq and ensembl"""
print("Merging Transcript, Gene, Protein Data from Sources")
# recombine = {}
# ensembls = set()
writtenIDs = set()
genesIDs = set()
for refT, record in self.refseq.Transcripts.items():
if refT[1] == "R": # only protein coding
continue
ensT = self.idConv.findConversion(refT, transcript=True)
if record.protein_refseq is None or record.protein_refseq == '-':
record.protein_refseq = self.refseq.trans2pro.get(refT, None)
refP = record.protein_refseq
ensP = self.idConv.findConversion(refP, protein=True)
if refP is None or refP not in self.refseq.Proteins: # if no matching protein - ignore the transcript
continue
ensPflag = ensP in self.ensembl.Proteins
ensTflag = ensT in self.ensembl.Transcripts
if not ensTflag and ensPflag:
tempensT = self.ensembl.pro2trans[ensP]
if ensT is None:
record.ensembl = tempensT
ensT = tempensT
elif ensTflag and not ensPflag:
ensP = self.ensembl.trans2pro[ensT]
refG = record.gene_GeneID
ensG = self.idConv.findConversion(refG, gene=True)
# add gene to dict
if refG not in self.Genes:
self.Genes[refG] = self.refseq.Genes[refG].mergeGenes(
self.ensembl.Genes.get(ensG, ensG))
genesIDs.add(refG)
if ensG is not None:
genesIDs.add(ensG)
if ensP in self.ensembl.Proteins and abs(
int(self.refseq.Proteins[refP].length) -
int(self.ensembl.Proteins[ensP].length)
) <= 1: # if the diff between protein length is smaller than 1- ignore
self.mismatches_merged.append((
ensP,
refP,
))
self.Transcripts[refT] = self.idConv.FillInMissingsTranscript(
record)
self.Proteins[refP] = self.idConv.FillInMissingProteins(
self.refseq.Proteins[refP])
self.Proteins[refP].mergeDescription(
self.ensembl.Proteins[ensP])
self.Domains[refP] = self.CompMergeDomainLists(
self.refseq.Domains.get(refP, []),
self.ensembl.Domains.get(ensP, []))
writtenIDs.add(ensT)
writtenIDs.add(refT)
# if refG not in self.Genes:
# self.Genes[refG] = self.refseq.Genes[refG].mergeGenes(self.ensembl.Genes.get(ensG, ensG))
# genesIDs.add(refG)
# if ensG is not None:
# genesIDs.add(ensG)
else: # separate the records
# refseq records
self.Transcripts[refT] = self.refseq.Transcripts[refT]
self.Transcripts[refT].gene_ensembl = ensG
self.Proteins[refP] = self.refseq.Proteins[refP]
self.Domains[refP] = self.refseq.Domains.get(refP, [])
writtenIDs.add(refT)
# if refG not in self.Genes:
# self.Genes[refG] = self.refseq.Genes[refG].mergeGenes(self.ensembl.Genes.get(ensG, ensG))
# genesIDs.add(refG)
# if ensG is not None:
# genesIDs.add(ensG)
# ensembl records
if ensP in self.ensembl.Proteins:
self.Transcripts[ensT] = self.ensembl.Transcripts[ensT]
if ensG != self.Transcripts[ensT].gene_ensembl:
ensG = self.Transcripts[ensT].gene_ensembl
refG = self.idConv.findConversion(ensG, gene=True)
self.Transcripts[ensT].gene_GeneID = refG
self.Proteins[ensP] = self.ensembl.Proteins[ensP]
self.Domains[ensP] = self.ensembl.Domains.get(ensP, [])
self.mismatches_sep.append((
ensP,
refP,
))
writtenIDs.add(ensT)
if refG is None:
self.Genes[ensG] = self.ensembl.Genes[ensG]
genesIDs.add(ensG)
elif refG not in self.Genes:
self.Genes[refG] = self.ensembl.Genes[ensG].mergeGenes(
self.refseq.Genes.get(refG, refG))
genesIDs.add(refG)
if ensG is not None:
genesIDs.add(ensG)
elif ensT not in self.ensembl.Transcripts:
self.Transcripts[
refT] = self.idConv.FillInMissingsTranscript(record)
self.Proteins[refP] = self.idConv.FillInMissingProteins(
self.refseq.Proteins[refP])
# ~~~~ End of RefSeq Loop ~~~~~
for ensT, record in self.ensembl.Transcripts.items():
if ensT not in writtenIDs:
ensP = record.protein_ensembl
refT = self.idConv.findConversion(ensT, transcript=True)
if ensP is None or ensP not in self.ensembl.Proteins or (
refT is not None and refT[1] == "R"):
continue
self.Transcripts[ensT] = self.idConv.FillInMissingsTranscript(
record)
# self.Transcripts[ensT] = self.ensembl.Transcripts[ensT]
# self.Proteins[ensP] = self.ensembl.Proteins[ensP]
refP = record.protein_refseq
self.Proteins[ensP] = self.idConv.FillInMissingProteins(
self.ensembl.Proteins[ensP])
self.Proteins[ensP].mergeDescription(
self.refseq.Proteins.get(refP, None))
self.Domains[ensP] = self.CompMergeDomainLists(
self.refseq.Domains.get(refP, []),
self.ensembl.Domains.get(ensP, []))
ensG = self.Transcripts[ensT].gene_ensembl
refG = self.Transcripts[ensT].gene_GeneID
if refG in self.Genes:
if ensG == self.idConv.findConversion(
refG, gene=True) or self.idConv.findConversion(
refG, gene=True) is None:
self.Genes[refG].ensembl = ensG if self.Genes[
refG].ensembl is None else self.Genes[refG].ensembl
genesIDs.add(ensG)
elif ensG not in genesIDs:
self.Genes[ensG] = self.ensembl.Genes[ensG]
self.Transcripts[ensT].gene_GeneID = None
genesIDs.add(ensG)
elif ensG not in genesIDs:
if refG is None:
self.Genes[ensG] = self.ensembl.Genes[ensG]
genesIDs.add(ensG)
else:
self.ensembl.Genes[ensG].gene_GeneID = refG
self.Genes[refG] = self.ensembl.Genes[ensG].mergeGenes(
self.refseq.Genes.get(refG, refG))
genesIDs.add(ensG)
genesIDs.add(refG)
# ~~~~~ End of Ensmebl Loop ~~~~~
def CompMergeDomainLists(self, doms1, doms2):
if len(doms1) == 0 or doms1 is None:
return doms2
elif len(doms2) == 0 or doms2 is None:
return doms1
finalList = list(doms1)
added_index = []
for dom in doms1:
for i in range(len(doms2)):
refDom = doms2[i]
if i not in added_index and dom != refDom:
finalList.append(refDom)
added_index.append(i)
return tuple(finalList)
