def renderDados(self):
acumulador = None
if self.acue_obj:
acumulador = self.acue_obj.acue_content[self.nspace]
else:
acumulador = classes.getAcumuladorEpoca(
self.epoca, config.VERSAO_ACUMULADOR, self.nspace).acue_content[self.nspace]
# agora vamos obter os objectos (clubes) que fazem parte da LIGA desta época
#, e fazer uma hash invertida.
liga = self.epoca.epo_competicoes.filter("cmp_tipo = ","Liga").get()
ac = classes.getAcumuladorCompeticao(liga, config.VERSAO_ACUMULADOR, "clube")
clus = {}
if ac:
clubes_liga_ids = ac.acuc_content["clube"].keys()
clubes = Clube.get_by_id(clubes_liga_ids)
for clube in clubes:
clus[clube.key().id()] = clube
# no HTML, escrever só as entradas que tem clube.
# se não tiver, são de clubes acessórios e não importantes
if acumulador:
for key, list_values in acumulador.items():
for idx, val in enumerate(acumulador[key]):
if clus.has_key(acumulador[key][idx]["clu"]):
acumulador[key][idx]["clube"] = clus[acumulador[key][idx]["clu"]]
return acumulador
def renderDados(self):
acumulador = None
if self.acue_obj:
acumulador = self.acue_obj.acue_content[self.nspace]
else:
acumulador = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, self.nspace).acue_content[self.nspace]
arb_ids = []
hash_arbitros = {}
for key, list_values in acumulador.items():
for idx, val in enumerate(acumulador[key]):
if not acumulador[key][idx]["arb"] in arb_ids:
arb_ids.append(acumulador[key][idx]["arb"])
# converter ids em Arbitros
arb_objs = Arbitro.get_by_id(arb_ids)
for arb in arb_objs:
hash_arbitros[arb.key().id()] = arb
for key, list_values in acumulador.items():
for idx, val in enumerate(acumulador[key]):
acumulador[key][idx]["arbitro"] = hash_arbitros[acumulador[key][idx]["arb"]]
return acumulador
def renderDados(self):
dados = {}
epoca_corrente = config.EPOCA_CORRENTE
acumulador = classes.getAcumuladorEpoca(self.epoca,
config.VERSAO_ACUMULADOR, "jogador")
jogadores = Jogador.all().filter("jgd_clube_actual = ", self.clube).order("jgd_nome").fetch(1000)
# o pickle tinha de vir num hash, portanto, o value é a lista
top_jogadores = acumulador.acue_content["jogador"]
dados["jogadores"] = []
#logging.info(top_jogadores.keys())
for jogador in jogadores:
key = jogador.key().id()
ctj = jogador.jgd_clubes.filter("ctj_epocas = ",epoca_corrente.key()).get()
data = {"jogador":jogador,
"numero":ctj.ctj_numero if ctj else 0,
"posicao":jogador.jgd_posicao,
"jogos_realizados":0,
"minutos_jogados":0,
"golos_marcados":0,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
#logging.info(key)
if top_jogadores.has_key(key):
# vamos ver as states mas só para quando o jogador esteve a jogar neste clube
clu_id = self.clube.key().id()
if top_jogadores[key].has_key(clu_id):
if top_jogadores[key][clu_id].has_key("jr"):
data["jogos_realizados"] =top_jogadores[key][clu_id]["jr"]
if top_jogadores[key][clu_id].has_key("mj"):
data["minutos_jogados"] =top_jogadores[key][clu_id]["mj"]
if top_jogadores[key][clu_id].has_key("gm"):
data["golos_marcados"] =top_jogadores[key][clu_id]["gm"]
if top_jogadores[key][clu_id].has_key("ca"):
data["cartoes_amarelos"] =top_jogadores[key][clu_id]["ca"]
if top_jogadores[key][clu_id].has_key("cda"):
data["cartoes_duplo_amarelos"] =top_jogadores[key][clu_id]["cda"]
if top_jogadores[key][clu_id].has_key("cv"):
data["cartoes_vermelhos"] =top_jogadores[key][clu_id]["cv"]
data["indisciplina"] = top_jogadores[key][clu_id]["ca"] + 1.5*top_jogadores[key][clu_id]["cda"] + 2*top_jogadores[key][clu_id]["cv"]
dados["jogadores"].append(data)
return dados
def checkCacheFreshen(self):
data_cache = None # data do HTML gerado em cache
self.softcache_html = memcache.get(self.cache_url, namespace=self.cache_namespace)
if self.softcache_html:
data_cache = self.softcache_html['date']
else:
self.hardcache_html = CacheHTML.all().filter("cch_url = ",self.cache_url).get()
if self.hardcache_html:
data_cache = self.hardcache_html.cch_date
self.acumulador_icc = memcache.get("acumulador-%s-%s" % (self.epoca, config.VERSAO_ACUMULADOR),
namespace=self.nspace1)
if not self.acumulador_icc:
self.acumulador_icc = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, self.nspace1)
if data_cache and self.acumulador_icc and self.acumulador_icc.acue_date > data_cache:
self.refreshen_cache = True
self.acumulador_ica = memcache.get("acumulador-%s-%s" % (self.epoca, config.VERSAO_ACUMULADOR),
namespace=self.nspace3)
if not self.acumulador_ica:
self.acumulador_ica = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, self.nspace3)
if data_cache and self.acumulador_ica and self.acumulador_ica.acue_date > data_cache:
self.refreshen_cache = True
self.acumulador_tabela_icc = memcache.get("acumulador-%s-%s" % (self.epoca, config.VERSAO_ACUMULADOR),
namespace=self.nspace2)
if not self.acumulador_tabela_icc:
self.acumulador_tabela_icc = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, self.nspace2)
if data_cache and self.acumulador_tabela_icc and self.acumulador_tabela_icc.acue_date > data_cache:
self.refreshen_cache = True
def renderDados(self):
acumulador = None
if self.acue_obj:
acumulador = self.acue_obj.acue_content[self.nspace]
else:
acumulador = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, self.nspace).acue_content[self.nspace]
# vamos recolher os ids de todos os jogadores
ids = []
for item in acumulador["mais_golos"]:
# item = {jgd:1L, gol:1L}
if not item["jgd"] in ids:
ids.append(item["jgd"])
for item in acumulador["mais_cartoes"]:
# item = {jgd:1L, crt:{ca:, cda: cv: tot:}}
if not item["jgd"] in ids:
ids.append(item["jgd"])
for item in acumulador["mais_lances"]:
# item = {jgd:1L, crt:{ca:, cda: cv: tot:}}
if not item["jgd"] in ids:
ids.append(item["jgd"])
# agora vamos obter os objectos, e fazer uma hash invertida.
jogadores = Jogador.get_by_id(ids)
jgds = {}
for jogador in jogadores:
if jogador:
jgds[jogador.key().id()] = jogador
# agora vamos substituir os ids pelos objectos
for idx, val in enumerate(acumulador["mais_golos"]):
acumulador["mais_golos"][idx]["jogador"] = jgds[val["jgd"]]
for idx, val in enumerate(acumulador["mais_cartoes"]):
acumulador["mais_cartoes"][idx]["jogador"] = jgds[val["jgd"]]
for idx, val in enumerate(acumulador["mais_lances"]):
acumulador["mais_lances"][idx]["jogador"] = jgds[val["jgd"]]
return acumulador
def renderDados(self):
competicoes = []
melhores_marcadores = []
mais_indisciplinados = []
top_list_melhores_marcadores = 5
top_list_mais_indisciplinados = 5
# top jogadores:
acumulador = classes.getAcumuladorEpoca(self.epoca,
config.VERSAO_ACUMULADOR, "top_jogadores")
top_jogadores = acumulador.acue_content["top_jogadores"]
howmany = len(top_jogadores["mais_golos"]) if len(top_jogadores["mais_golos"]) <= top_list_melhores_marcadores else top_list_melhores_marcadores
for linha in top_jogadores["mais_golos"][:howmany]:
melhores_marcadores.append(linha)
howmany = len(top_jogadores["mais_cartoes"]) if len(top_jogadores["mais_cartoes"]) <= top_list_mais_indisciplinados else top_list_mais_indisciplinados
for linha in top_jogadores["mais_cartoes"][:howmany]:
mais_indisciplinados.append(linha)
# vamos recolher os ids de todos os jogadores
ids = []
for item in melhores_marcadores:
# item = {jgd:1L, gol:1L}
if not item["jgd"] in ids:
ids.append(item["jgd"])
for item in mais_indisciplinados:
# item = {jgd:1L, crt:{ca:, cda: cv: tot:}}
if not item["jgd"] in ids:
ids.append(item["jgd"])
# agora vamos obter os objectos, e fazer uma hash invertida.
jogadores = Jogador.get_by_id(ids)
jgds = {}
for jogador in jogadores:
jgds[jogador.key().id()] = jogador
# agora vamos substituir os ids pelos objectos
for idx, val in enumerate(melhores_marcadores):
melhores_marcadores[idx]["jogador"] = jgds[val["jgd"]]
for idx, val in enumerate(mais_indisciplinados):
mais_indisciplinados[idx]["jogador"] = jgds[val["jgd"]]
for competicao in self.epoca.epo_competicoes:
acumulador = classes.getAcumuladorCompeticao(competicao,
config.VERSAO_ACUMULADOR, "classificacao_real")
classificacao_total = None
if acumulador and acumulador.acuc_content.has_key("classificacao_real"):
classificacao_total = acumulador.acuc_content["classificacao_real"]["total"]
# vamos tirar a linha que interessa...
competicoes.append({
"competicao":competicao,
"dados":classificacao_total[0] if classificacao_total else None,
"clube":Clube.get_by_id(classificacao_total[0]["clu"]) if classificacao_total else None
})
dados = {"competicoes":competicoes,
"melhores_marcadores":melhores_marcadores,
"mais_indisciplinados":mais_indisciplinados}
return dados
def renderDados(self):
dados = {}
epoca_corrente = config.EPOCA_CORRENTE
acumulador = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, "jogador")
logging.info(acumulador)
top_jogador = acumulador.acue_content["jogador"][self.jogador.key().id()]
arbitros = {}
for jogador_key, jogador_values in top_jogador.items():
arbitros = {}
arb_ids = []
hash_arbitros = {}
for arbitro_id, amarelo in jogador_values["a_a"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arb_ids.append(arbitro_id)
arbitros[arbitro_id]["cartoes_amarelos"] += amarelo
arbitros[arbitro_id]["indisciplina"] += amarelo
for arbitro_id, damarelo in jogador_values["a_da"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arb_ids.append(arbitro_id)
arbitros[arbitro_id]["cartoes_duplo_amarelos"] += damarelo
arbitros[arbitro_id]["indisciplina"] += 1.5 * damarelo
for arbitro_id, vermelho in jogador_values["a_v"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arb_ids.append(arbitro_id)
arbitros[arbitro_id]["cartoes_vermelhos"] += vermelho
arbitros[arbitro_id]["indisciplina"] += 2 * vermelho
# converter ids em Arbitros
arb_objs = Arbitro.get_by_id(arb_ids)
for arb in arb_objs:
hash_arbitros[arb.key().id()] = arb
# adicionar o objecto
for arb_id, arb_value in arbitros.items():
arbitros[arb_id]["arbitro"] = hash_arbitros[arb_id]
dados = arbitros.values()
return dados
def renderDados(self):
dados = {}
acumulador = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, "arbitro")
top_arbitro = acumulador.acue_content["arbitro"][self.arbitro.key().id()]
ids = []
jogadores = {}
for jogador_id, amarelo in top_arbitro["j_a"].items():
if not jogador_id in ids:
ids.append(jogador_id)
jogadores[jogador_id] = {
"jgd":jogador_id,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
jogadores[jogador_id]["cartoes_amarelos"] += amarelo
jogadores[jogador_id]["indisciplina"] += amarelo
for jogador_id, damarelo in top_arbitro["j_da"].items():
if not jogador_id in ids:
ids.append(jogador_id)
jogadores[jogador_id] = {
"jgd":jogador_id,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
jogadores[jogador_id]["cartoes_duplo_amarelos"] += damarelo
jogadores[jogador_id]["indisciplina"] += 1.5 * damarelo
for jogador_id, vermelho in top_arbitro["j_v"].items():
if not jogador_id in ids:
ids.append(jogador_id)
jogadores[jogador_id] = {
"jgd":jogador_id,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
jogadores[jogador_id]["cartoes_vermelhos"] += vermelho
jogadores[jogador_id]["indisciplina"] += 2 * vermelho
# agora vamos obter os objectos, e fazer uma hash invertida.
lista_jogadores = Jogador.get_by_id(ids)
jgds = {}
for jogador in lista_jogadores:
jgds[jogador.key().id()] = jogador
# agora vamos substituir os ids pelos objectos
for idx, val in jogadores.items():
jogadores[idx]["jogador"] = jgds[jogadores[idx]["jgd"]]
dados = jogadores.values()
return dados
def load_grafico_ica_for_epoca(self, epoca):
acue = classes.getAcumuladorEpoca(epoca, config.VERSAO_ACUMULADOR, "ica")
if acue:
self.grafico = acue.acue_content["ica"]
def renderDados(self):
dados = {}
competicoes = []
melhores_marcadores = []
mais_indisciplinados = []
top_list_melhores_marcadores = 5
top_list_mais_indisciplinados = 5
# primeiro, vamos saber quais são os jogadores deste clube
# e fazer uma hash
jgd_ids = []
hash_jogadores = {}
clu_id = self.clube.key().id()
jogadores = Jogador.all().filter("jgd_clube_actual = ", self.clube)
for j in jogadores:
jgd_id = j.key().id()
jgd_ids.append(jgd_id)
hash_jogadores[jgd_id] = j
acumulador = classes.getAcumuladorEpoca(self.epoca, config.VERSAO_ACUMULADOR, "top_jogadores")
if acumulador:
top_jogadores = acumulador.acue_content["top_jogadores"]
so_far = 0
for linha in top_jogadores["mais_golos"]:
if linha["jgd"] in jgd_ids and so_far < top_list_melhores_marcadores:
# adiciona o obj a partir do id
linha["jogador"] = hash_jogadores[linha["jgd"]]
melhores_marcadores.append(linha)
so_far += 1
so_far = 0
for linha in top_jogadores["mais_cartoes"]:
if linha["jgd"] in jgd_ids and so_far < top_list_mais_indisciplinados:
# adiciona o obj a partir do id
linha["jogador"] = hash_jogadores[linha["jgd"]]
mais_indisciplinados.append(linha)
so_far += 1
# total para as competições
total_competicoes = {"jr": 0, "vr": 0, "er": 0, "dr": 0, "gmr": 0, "gsr": 0, "pr": 0}
for competicao in self.epoca.epo_competicoes:
acuc = classes.getAcumuladorCompeticao(competicao, config.VERSAO_ACUMULADOR, "classificacao_real")
if acuc:
classificacao_total = acuc.acuc_content["classificacao_real"]["total"]
for linha in classificacao_total:
if linha["clu"] == clu_id:
competicoes.append({"competicao": competicao, "stats": linha})
total_competicoes["jr"] += linha["jr"]
total_competicoes["vr"] += linha["vr"]
total_competicoes["er"] += linha["er"]
total_competicoes["dr"] += linha["dr"]
total_competicoes["gmr"] += linha["gmr"]
total_competicoes["gsr"] += linha["gsr"]
dados = {
"competicoes": competicoes,
"total_competicoes": total_competicoes,
"melhores_marcadores": melhores_marcadores,
"mais_indisciplinados": mais_indisciplinados,
}
return dados
def load_tabela_icc_for_epoca(self, epoca): acue = classes.getAcumuladorEpoca(epoca, config.VERSAO_ACUMULADOR,"tabela_icc") if acue: self.tabela = acue.acue_content["tabela_icc"]
def gera(epoca, acue_basico,
acue_tabela_icc, acue_icc, acue_top_arbitros,
acue_top_jogos, acue_top_jogadores, acue_top_clubes):
acuc = AcumuladorCompeticao.all().filter("acuc_epoca = ", epoca).filter("acuc_versao = ", config.VERSAO_ACUMULADOR).fetch(1000)
stats = {}
if acue_basico == "on":
logging.info("acue_basico está on, vou gerar arbitro, jogador, clube e jogo a partir das estatísticas")
stats = {
"arbitro":{},
"jogo": {},
"jogador":{},
"clube":{},
"top_arbitros":{},
"top_jogos": {},
"top_jogadores":{},
"top_clubes":{}
}
for ac in acuc:
# depicle it
content = ac.acuc_content
logging.info(u"acumulador_epoca: a ler dados do acumulador_competicao %s " % ac.acuc_competicao.__str__())
if (ac.acuc_namespace == "arbitro"):
doit(content["arbitro"], stats["arbitro"], "arbitro")
if (ac.acuc_namespace == "jogador"):
doit(content["jogador"], stats["jogador"], "jogador")
if (ac.acuc_namespace == "jogo"):
doit(content["jogo"], stats["jogo"], "jogo")
if (ac.acuc_namespace == "clube"):
doit(content["clube"], stats["clube"], "clube")
else:
logging.info("acue_basico está off, vou gerar arbitro, jogador, clube e jogo a partir do acumulador")
acumuladorepocas = AcumuladorEpoca.all().filter("acue_epoca = ", epoca).filter("acue_versao = ", config.VERSAO_ACUMULADOR)
stats_total = {}
stats = {}
for acu in acumuladorepocas:
if acu.acue_namespace == "arbitro":
stats["arbitro"] = acu.acue_content["arbitro"]
if acu.acue_namespace == "clube":
stats["clube"] = acu.acue_content["clube"]
if acu.acue_namespace == "jogador":
stats["jogador"] = acu.acue_content["jogador"]
if acu.acue_namespace == "jogo":
stats["jogo"] = acu.acue_content["jogo"]
##############
### TABELA ICC ###
##############
liga = epoca.epo_competicoes.filter("cmp_tipo = ","Liga").get()
ac = classes.getAcumuladorCompeticao(liga, config.VERSAO_ACUMULADOR, "clube")
if ac:
clubes_liga_ids = ac.acuc_content["clube"].keys()
else:
ac = classes.getAcumuladorEpoca(epoca, config.VERSAO_ACUMULADOR, "clube")
clubes_liga_ids = ac.acue_content["clube"].keys()
clubes = Clube.get_by_id(clubes_liga_ids)
clubes = sorted(clubes, cmp=lambda x,y: cmp(x.clu_numero_visitas, y.clu_numero_visitas), reverse=True)
if acue_tabela_icc == "on":
# vamos assumir que sabemos que queremos uma tabela icc / Liga
stats["tabela_icc"] = TabelaICC.gera_nova_tabela_icc(stats, clubes)
###########
### ICC ###
###########
if acue_icc == "on":
# vamos assumir que sabemos que queremos uma tabela icc / Liga
arbitros = Arbitro.all().fetch(1000)
stats["icc"] = GraficoICC.gera_novo_grafico_icc(stats, {}, clubes)
stats["ica"] = GraficoICA.gera_novo_grafico_ica(stats, {}, arbitros)
############
### TOPS ###
############
# os tops podem ser aglotinações de hashes das competições, não é preciso regerar
for ac in acuc:
if acue_top_clubes == "on" and ac.acuc_namespace == "top_clubes":
doit(ac.acuc_content["top_clubes"], stats["top_clubes"], "top_clubes")
if acue_top_arbitros == "on" and ac.acuc_namespace == "top_arbitros":
doit(ac.acuc_content["top_arbitros"], stats["top_arbitros"], "top_arbitros")
if acue_top_jogadores == "on" and ac.acuc_namespace == "top_jogadores":
doit(ac.acuc_content["top_jogadores"], stats["top_jogadores"], "top_jogadores")
if acue_top_jogos == "on" and ac.acuc_namespace == "top_jogos":
doit(ac.acuc_content["top_jogos"], stats["top_jogos"], "top_jogos")
return stats
def renderDados(self):
dados = {}
epoca_corrente = config.EPOCA_CORRENTE
acumulador = classes.getAcumuladorEpoca(self.epoca,
config.VERSAO_ACUMULADOR, "clube")
if acumulador and acumulador.acue_content["clube"].has_key(self.clube.key().id()):
top_clube = acumulador.acue_content["clube"][self.clube.key().id()]
arbitros = {}
arb_ids = []
hash_arbitros = {}
#logging.info(top_jogadores.keys())
for arbitro_id, jogos in top_clube["a_j"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"jogos_realizados":0,
"icc":0,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arbitros[arbitro_id]["jogos_realizados"] += jogos
arb_ids.append(arbitro_id)
for arbitro_id, icc in top_clube["a_i"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"jogos_realizados":0,
"icc":0,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arbitros[arbitro_id]["icc"] += icc
arb_ids.append(arbitro_id)
for arbitro_id, amarelo in top_clube["a_a"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"jogos_realizados":0,
"icc":0,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arbitros[arbitro_id]["cartoes_amarelos"] += amarelo
arbitros[arbitro_id]["indisciplina"] += amarelo
arb_ids.append(arbitro_id)
for arbitro_id, damarelo in top_clube["a_da"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"jogos_realizados":0,
"icc":0,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arbitros[arbitro_id]["cartoes_duplo_amarelos"] += damarelo
arbitros[arbitro_id]["indisciplina"] += 1.5 * damarelo
arb_ids.append(arbitro_id)
for arbitro_id, vermelho in top_clube["a_v"].items():
if not arbitros.has_key(arbitro_id):
arbitros[arbitro_id] = {
"jogos_realizados":0,
"icc":0,
"cartoes_amarelos":0,
"cartoes_duplo_amarelos":0,
"cartoes_vermelhos":0,
"indisciplina":0
}
arbitros[arbitro_id]["cartoes_vermelhos"] += vermelho
arbitros[arbitro_id]["indisciplina"] += 2 * vermelho
arb_ids.append(arbitro_id)
# converter ids em Arbitros
arb_objs = Arbitro.get_by_id(arb_ids)
for arb in arb_objs:
hash_arbitros[arb.key().id()] = arb
# adicionar o objecto
for arb_id, arb_value in arbitros.items():
arbitros[arb_id]["arbitro"] = hash_arbitros[arb_id]
dados = arbitros.values()
return dados
