class AlunoSpec(unittest.TestCase):
def setUp(self):
Aluno.alunos = {}
Aluno.contador_matriculas = 0
self.a = Aluno('joao', 'rua dos bobos', 'enrolado')
#Construtor
def test_atribuir_matricula(self):
self.a.matricula | should | equal_to(1)
def test_armazenar_instancia(self):
Aluno.alunos | should | include_values(self.a)
#/Construtor
def test_associar_responsavel(self):
from pessoa import Pessoa
responsavel = Pessoa('Maria', 'rua das coves', 'casada')
self.a.associar_responsavel(responsavel)
self.a.responsavel | should | be(responsavel)
def test_matricular(self):
from curso import Curso
curso = Curso('Informatica')
self.a.matricular(curso)
self.a.curso | should | be(curso)
curso.alunos | should | include_values(self.a)
def menu(self):
opcao = Form().menu()
if (opcao == "1-1"):
p = Form().cadastroAluno()
Aluno().save(p.nome, p.idade)
if (opcao == "1-2"):
d = Form().cadastroDisciplina()
Disciplina().save(d.nome)
if (opcao == "1-3"):
d = Form().cadastroProva()
Prova().save(d.disciplina, d.pontos)
if (opcao == "1-4"):
d = Form().cadastroNota()
if (opcao == "2-1"):
Aluno().all()
if (opcao == "2-2"):
Disciplina().all(Prova().objects)
if (opcao == "2-3"):
Prova().all()
if (opcao == "3-1"):
Aluno().get(Form().pesquisaAluno(), Prova(), Disciplina().objects)
if (opcao == "3-2"):
Disciplina().get(Form().pesquisaDisciplina(Prova().objects),
Prova())
if (opcao == "3-3"):
Prova().get(Form().pesquisaProva())
if (opcao == "9"):
clear = lambda: os.system('clear')
clear()
if (opcao != "x" and opcao != "X"):
app.menu()
class AlunoSpec(unittest.TestCase):
def setUp(self):
Aluno.alunos = {}
Aluno.contador_matriculas = 0
self.a = Aluno('joao', 'rua dos bobos','enrolado')
#Construtor
def test_atribuir_matricula(self):
self.a.matricula |should| equal_to(1)
def test_armazenar_instancia(self):
Aluno.alunos |should| include_values(self.a)
#/Construtor
def test_associar_responsavel(self):
from pessoa import Pessoa
responsavel = Pessoa('Maria', 'rua das coves', 'casada')
self.a.associar_responsavel(responsavel)
self.a.responsavel |should| be(responsavel)
def test_matricular(self):
from curso import Curso
curso = Curso('Informatica')
self.a.matricular(curso)
self.a.curso |should| be(curso)
curso.alunos |should| include_values(self.a)
def it_inserir_aluno_curso(self):
aluno = Aluno('001', 'Grazi', '997876543', 'Rua das Flores', 'grazi@grazi')
escola = Escola('001', 'IFF', 'iff@iff', 'iff.edu.br')
curso = Curso(123,'curso',40,2,1,150.00,escola)
alunoCurso = AlunoCurso('001',6.8,1,aluno,curso)
aluno.inserirAlunoCursos(alunoCurso)
(alunoCurso in aluno.alunoCursos) |should| equal_to(True)
class Vetor:
alunos = []
alunos.append(Aluno("Johnata", "03/09/1991", 123, "Rua Alba"))
alunos.append(Aluno("Marina", "10/02/1990", 345, "Rua Peixoto de Castro"))
for i in alunos:
print(
"O nome do aluno é: {}\n a data de nascimento: {}\n o cpf dele é: {}\n e o endereço dele é: {}"
.format(i.nome, i.datanascimento, i.cpf, i.endereco))
def testa_matricular(nome_disciplina):
disciplinas = []
um_aluno = Aluno('Joao')
disciplinas = Disciplina.lista_nomes_disciplinas()
if nome_disciplina in disciplinas:
um_aluno.matricular(nome_disciplina)
print 'Aluno matriculado!'
else:
print 'Disciplina nao existente!'
def excluirAluno(self):
alu = Aluno()
alu.idaluno = self.txtidaluno.get()
self.lblmsg["text"] = alu.deleteAluno()
self.txtidaluno.delete(0, END)
self.txtnome.delete(0, END)
self.txtcpf.delete(0, END)
def inserirAluno(self):
alu = Aluno()
alu.nome = self.txtnome.get()
alu.cpf = self.txtcpf.get()
self.lblmsg["text"] = alu.insertAluno()
self.txtidaluno.delete(0, END)
self.txtnome.delete(0, END)
self.txtcpf.delete(0, END)
def resultado(self, nome, notaUm, notaDois, notaTres):
aluno = Aluno(nome, notaUm, notaDois, notaTres)
return """
<a type="button" onClick="history.go(-1)" style="cursor:pointer">Voltar</a>
<h1>Relatório</h1>
<br>
Nome : {} <br>
Nota 1 : {} <br>
Nota 2 : {} <br>
Nota 3 : {} <br>
<h2>A média das notas é {}.</h2>
""".format(aluno.nome, aluno.notaUm, aluno.notaDois, aluno.notaTres,
aluno.media())
def __init__(self):
if(len(Aluno().objects) == 0):
Aluno().save('João', 12)
Aluno().save('Maria', 11)
Aluno().save('Gabriela', 14)
if(len(Disciplina().objects) == 0):
Disciplina().save('Matemática')
Disciplina().save('Português')
Disciplina().save('História')
if(len(Prova().objects) == 0):
Prova().save(1, 10.0)
Prova().save(2, 10.0)
Prova().save(3, 15.0)
def buscarAluno(self):
alu = Aluno()
idaluno = self.txtidaluno.get()
self.lblmsg["text"] = alu.selectAluno(idaluno)
self.txtidaluno.delete(0, END)
self.txtidaluno.insert(INSERT, alu.idaluno)
self.txtnome.delete(0, END)
self.txtnome.insert(INSERT, alu.nome)
self.txtcpf.delete(0, END)
self.txtcpf.insert(INSERT, alu.cpf)
class Main:
alunos = []
arquivo = open('teste.csv', 'r') # Abra o arquivo (leitura)
pessoas = csv.DictReader(arquivo)
for pessoas in pessoas:
alunos.append(
Aluno(pessoas["Cod"], pessoas["Nome"], pessoas["Nota"],
pessoas["Controle"]))
#print(pessoas["Cod"],pessoas["Nome"],pessoas["Nota"],pessoas["Controle"])
#for aluno in alunos:
#print(aluno.toString())
arquivo.close()
print("-!!!! SGDB Pythonzica !!!!-")
op = input("Digite (1) para iniciar uma transação:\n")
if op == '1':
data = datetime.now()
timestamp = datetime.timestamp(data)
print(timestamp)
try:
arquivo_user = open("" + str(timestamp) + ".csv", 'w')
writer = csv.writer(arquivo_user)
writer.writerow(('Cod', 'Nome', 'Nota', 'Controle'))
# for aluno in alunos:
#writer.writerow(str(aluno.getCodigo()),str(aluno.getNome()),str(aluno.getNota()),str(aluno.getControle()))
finally:
arquivo_user.close()
else:
print("Opção inválida")
def cadastro_aluno():
nome = input("Nome do aluno: ")
matricula = input("Matrícula: ")
endereco = input("Endereço: ")
cpf = input("CPF: ")
aluno = Aluno(nome, matricula, endereco, cpf)
return aluno
def __init__(self, sessao):
self.sessao = sessao
self.treino = Treino()
self.aluno = Aluno()
self.professor = Professores()
self.window = self.main()
self.layout()
self.frame = self.alunos(self.professor.alunos(self.sessao["id"]))
self.window.mainloop()
def lerDados(self):
with open(self.arquivo) as alunosDados:
csvReader = csv.reader(alunosDados, delimiter=",")
for aluno in csvReader:
alunoClasse = Aluno(aluno[0], aluno[1], aluno[2], aluno[3],
aluno[4], aluno[5])
self.alunos.append(alunoClasse)
def test_confirmacao_matricula():
aluno = Aluno('Lucas', 1701419)
turma = Turma('Tecnologia Web')
matricula = Matricula(aluno, turma)
professor = Professor('Professor', 1)
assert professor.confirmar_matricula(matricula) == False
def api_newaluno():
global alunos
req_data = request.get_json()
id = req_data['id']
nome = req_data['nome']
idade = req_data['idade']
new_aluno = Aluno(id, nome, idade)
alunos.append(new_aluno)
res = {'status': 'ok'}
return jsonify(res)
def cadastrar_aluno(alunos):
nome = input('Digite o nome do aluno: ')
cpf = input('Digite o cpf do aluno: ')
try:
nota = float(input('Digite a nota do aluno: '))
except ValueError:
nota = None
novo_aluno = Aluno(nome, cpf, nota)
alunos.append(novo_aluno)
def buscar(self, cod):
try:
with connect(self._dados_con) as conn:
cur = conn.cursor()
cur.execute('SELECT * FROM aluno WHERE codigo = %s', [cod])
row = cur.fetchone()
aluno = Aluno(codigo=row[0],login=row[1],idade=row[2])
cur.close()
return aluno
except BaseException as e:
print ("Problema no buscar -- exception seguindo para ser tratada")
raise e
def cadastroNota(self):
alunos = Aluno()
dataProva = Prova().getOnlyData(Form().pesquisaProva(' não realizada', "\nErro: Pesquise por uma prova da lista e que não foi realizada ainda."))
print('\n\n\n##############################################################################################')
print("{:>30} {}".format(' ', ' INFORMAÇÕES SOBRE A PROVA '))
print('\n{:>30} {}'.format(' ', "Prova de {} valendo {} pontos:".format(dataProva[1].nome, dataProva[0].pontos)))
for aluno in alunos.objects:
nota = Form().inputFloat('\n\n{:>30} {}'.format(' ', 'Digite a nota de {}: '.format(aluno.nome)), '\nErro: A nota deve ser um número (casas decimais devem separadas por .)', dataProva[0].pontos, 'Erro: Digite um número maior ou igual a 0 e menor ou igual a {}.'.format(dataProva[0].pontos))
Nota().save(dataProva[0].id, aluno.matricula, nota)
#Atualiza o status da prova pra "Realizada"
Prova().atualizaStatus(dataProva[0].id)
def listar(self):
vet = []
try:
with connect(self._dados_con) as conn:
cur = conn.cursor()
cur.execute('SELECT * FROM aluno')
for row in cur.fetchall():
vet.append(Aluno(codigo=row[0],login=row[1],idade=row[2]))
cur.close()
except BaseException as e:
print ("Problema no listar -- exception seguindo para ser tratada")
raise e
return vet
def get_Aluno(self,event):
self.notaList.delete(*self.notaList.get_children())
notas = self.notaCRUD.consultar_por_matricula(self.buscaEdit.get())
if (len(notas)>0):
item = self.notaList.selection()
for item in notas:
fk_aluno_id = item[0]
fk_disciplina_id = item[1]
av1 = item[2]
av2 = item[3]
av3 = item[4]
media = item[5]
if fk_aluno_id == self.buscaEdit.get():
self.notaList.insert('','end',values=(str(fk_aluno_id),fk_disciplina_id,av1,av2,av3,media))
else: notas != self.buscaEdit.get()
id_aluno = Aluno()
self.alunoResult = id_aluno.consultar_por_matricula(self.buscaEdit.get())
lista = id_aluno.consultar_por_matricula(self.buscaEdit.get())
item = self.notaList.selection()
for item in lista:
fk_aluno_id = item[1]
#deleta os campos prenchidos do formulario
#self.alunoEdit.configure(state=NORMAL)
self.alunoEdit.delete(0, tk.END)
self.alunoEdit.insert(0, fk_aluno_id)
#self.alunoEdit.configure(state=DISABLED)
self.av1Edit.delete(0, tk.END)
self.av2Edit.delete(0, tk.END)
self.av3Edit.delete(0, tk.END)
self.mediaEdit.delete(0, tk.END)
self.buscaEdit.delete(0, tk.END)
self.notaList.insert('','end',values=(str(fk_aluno_id),))
self.buscaEdit.insert(0, 'Digite sua Matrica')
self.buscaEdit.configure(state=DISABLED)
self.buscaEdit.bind('<Button-1>', self._on_click)
def alterarAluno(self):
alu = Aluno()
alu.idaluno = self.txtidaluno.get()
alu.nome = self.txtnome.get()
alu.cpf = self.txtcpf.get()
self.lblmsg["text"] = alu.updateAluno()
self.txtidaluno.delete(0, END)
self.txtnome.delete(0, END)
self.txtcpf.delete(0, END)
def main():
biblio1 = Biblioteca() #istancio uma Biblioteca
print("--Digite 0 para sair--")
print("--Digite 1 para cadastrar livros--")
print("--Digite 2 para consultar todos os livros--")
print("--Digite 3 pegar livro emprestado--")
print("--Digite 4 devolver livro--")
print("--Digite 5 cadastrar aluno--")
print("--Digite 6 para consultar todos os alunos--")
opt = 99
while opt != 0:
opt = int(input("Escolha uma opcao: "))
if opt == 1:
print("--vc escolheu 1 cadastrar livros--")
nome = input("nome: ")
isbn = input("isbn: ")
autor = input("autor: ")
descricao = input("descricao: ")
quantidade = int(input("quantidade: "))
livro1 = Livro(nome, isbn, autor, descricao,
quantidade) #intancio um livro
biblio1.setLivros(livro1)
elif opt == 2:
print("--vc escolheu 2 consultar todos os livros --")
biblio1.printarLivros()
elif opt == 3:
print("--vc escolheu 3 pegar livro emprestado--")
elif opt == 4:
print("--vc escolheu 4 devolver livro--")
elif opt == 5:
print("--vc escolheu 5 cadastrar aluno--")
nome = input("nome: ")
cpf = input("cpf: ")
idade = int(input("idade: "))
turma = input("turma: ")
aluno1 = Aluno(nome, cpf, idade, turma) #intancio um aluno
biblio1.setAlunos(aluno1)
elif opt == 6:
print("--6 consultar todos os alunos ja cadastrados--")
biblio1.printarAlunos()
elif opt == 0:
print("--vc escolheu sair--")
else:
print("opcao invalida")
def cadastrarTurma():
limpaTela()
print("---- Cadastro de Turmas ----\n")
print("Curso:")
curso = input()
print("\n")
print("Ano:")
ano = input()
tr = Turma(ano, curso)
opcao = 1
while True:
print("\n")
print("-- Cadastrar Aluno da Turma ----\n")
print("Nome do Aluno: ")
nome = input()
print("\n")
print("Matriculado ? S - SIM || N - NÃO")
op = input()
matriculado = False
if op == 'S':
matriculado = True
al = Aluno(tr.getId(), nome, matriculado)
tr.addAluno(al)
print("\n")
print(
"Cadastrar um novo aluno para a turma? 1 - SIM || OUTRO VALOR - NÃO"
)
opcao = input()
if opcao == '1':
limpaTela()
continue
else:
break
return tr
def getNotas(self, id_prova):
alunos = Aluno()
print(
'\n\n\n##############################################################################################'
)
print("{:>30} {}".format(' ', ' NOTAS DOS ALUNOS '))
print(
'\n|--------------------------------------+-----------------------------------------------------|'
)
print("{:>15} {} {:>40} {}".format('', 'ALUNO', '', 'NOTA'))
print(
'|--------------------------------------+-----------------------------------------------------|'
)
for aluno in alunos.objects:
t = 60
nota = Nota().getNotaAluno(id_prova, aluno.matricula)
print(f"{'':15} {aluno.nome:15} {nota:35}")
print(
'|--------------------------------------+-----------------------------------------------------|'
)
def imprime_nome(matricula): nome = Aluno.busca_por_matricula(matricula) if nome != None: print nome else: print 'Matricula (%i) inexistente!' % matricula
from aluno import Aluno
from prova import Prova
from responsavel import Responsavel
if __name__ == '__main__':
responsavel = Responsavel(idade=39, rg='345666')
prova1 = Prova(id=1, materia='Matematica', conceito=9.5)
prova2 = Prova(id=2, materia='Geometria', conceito=4.5)
weslley = Aluno(idade=17, responsavel=responsavel, provas=[prova1, prova2])
print(weslley)
print(weslley.get_media_notas())
def __init__(self, nome, matricula, ano):
Aluno.__init__(self, nome, matricula)
self.ano = ano
def imprimir(self):
Aluno.imprimir(self)
print("Ano: ", self.ano)
def construir_mapa_alunos(planilha):
f_obj = open(planilha)
reader = csv.DictReader(f_obj, delimiter=';')
mapa_alunos = {}
mapa_alunos_para_ultimo_periodo_letivo_inscricao = {}
line_number = 0
for line in reader:
line_number = line_number + 1
try:
matr_aluno = line["MATR_ALUNO"]
nome_aluno = line["NOME_PESSOA"]
cpf_aluno = line["CPF"]
cod_curso = line["COD_CURSO"]
ano = int(line["ANO"])
periodo_str = line["PERIODO"]
periodo = int(periodo_str[0])
except ValueError:
print "Valor não pode ser convertido: %s. Linha: %d." % (
line["ANO"], line_number)
print matr_aluno
sys.exit(1)
if not matr_aluno in mapa_alunos_para_ultimo_periodo_letivo_inscricao:
mapa_alunos_para_ultimo_periodo_letivo_inscricao[
matr_aluno] = PeriodoLetivo(ano, periodo)
else:
ultimo_matriculado = mapa_alunos_para_ultimo_periodo_letivo_inscricao[
matr_aluno]
periodo_corrente = PeriodoLetivo(ano, periodo)
if (ultimo_matriculado < periodo_corrente) and (
periodo_corrente <= PeriodoLetivo(
Parametros.ANO_BASE, Parametros.PERIODO_BASE)):
mapa_alunos_para_ultimo_periodo_letivo_inscricao[
matr_aluno] = periodo_corrente
if not matr_aluno in mapa_alunos:
aluno = Aluno(nome_aluno, cpf_aluno, matr_aluno, cod_curso)
mapa_alunos[matr_aluno] = aluno
for (matr_aluno, aluno) in mapa_alunos.iteritems():
aluno = mapa_alunos[matr_aluno]
aluno.ultimo_periodo_letivo_inscricao = mapa_alunos_para_ultimo_periodo_letivo_inscricao[
matr_aluno]
'''
NB: apenas alunos que fizeram matricula (mesmo que seja de
trancamento total) no período letivo tomado como base são
considerados. Os demais são ignorados, por estarem
em situação de ABANDONO ou CONCLUÍDO.
'''
mapa_alunos_temp = {}
for (matr_aluno, aluno) in mapa_alunos.iteritems():
if aluno.tem_matricula_ativa():
mapa_alunos_temp[matr_aluno] = aluno
mapa_alunos = mapa_alunos_temp
mapas_periodos = AnalisadorDesempenhoAcademico.construir_mapas_periodos(
planilha, mapa_alunos)
mapa_periodos_cursados_por_aluno = mapas_periodos[0]
mapa_trancamentos_totais_por_aluno = mapas_periodos[1]
mapas_reprovacoes = AnalisadorDesempenhoAcademico.construir_mapas_reprovacoes(
planilha, mapa_alunos)
mapa_de_aluno_para_qtd_max_de_reprovacoes_em_uma_disciplina = mapas_reprovacoes[
0]
print len(mapa_alunos)
print len(mapa_periodos_cursados_por_aluno)
print len(mapa_trancamentos_totais_por_aluno)
print len(mapas_reprovacoes)
for (matr_aluno, aluno) in mapa_alunos.iteritems():
if matr_aluno in mapa_trancamentos_totais_por_aluno:
trancamentos_totais = mapa_trancamentos_totais_por_aluno[
matr_aluno]
aluno.trancamentos_totais = trancamentos_totais
if matr_aluno in mapa_periodos_cursados_por_aluno:
qtd_periodos_cursados = mapa_periodos_cursados_por_aluno[
matr_aluno]
aluno.qtd_periodos_cursados = qtd_periodos_cursados
if matr_aluno in mapa_de_aluno_para_qtd_max_de_reprovacoes_em_uma_disciplina:
aluno.qtd_maxima_reprovacoes = int(
mapa_de_aluno_para_qtd_max_de_reprovacoes_em_uma_disciplina[
matr_aluno])
return mapa_alunos
def deletar(cod):
dao = AlunoDAO()
pessoa = Aluno(codigo=cod)
dao.excluir(pessoa)
return redirect('/')
from aluno import Aluno
aluno = Aluno()
menu=True
while menu:
op=int(input("1- cadastrar\n"
"2- alterar\n"
"3- deletar\n"
"4- ler\n"
"5- sair\n"
"opção: "))
if op==1:
nome = input("digite o nome do aluno: ")
sobrenome = input("digite o sobrenome do aluno: ")
curso = input("digite o curso do aluno {0} {1}: ".format(nome, sobrenome))
aluno.save(nome,sobrenome,curso)
elif op==2:
procura=input("digite o nome do aluno que se deseja atualizar: ")
nome = input("digite o nome do aluno: ")
sobrenome = input("digite o sobrenome do aluno: ")
curso = input("digite o curso do aluno {0} {1}: ".format(nome, sobrenome))
aluno.att(procura, nome, sobrenome, curso)
def listar(prof, id_usuario_online):
limpar_tela()
Aluno.listar()
banco_de_questoes(prof, id_usuario_online)
def testa_buscar_por_matricula(): print Aluno.lista_matriculas() imprime_nome(1) imprime_nome(100)
def setUp(self):
Aluno.alunos = {}
Aluno.contador_matriculas = 0
self.a = Aluno('joao', 'rua dos bobos','enrolado')
def testar():
c = Curso('Info')
a = Aluno('Joao','01/01/01')
d = Disciplina('Loo', 4, c)
e = Disciplina('ED', 4, c)
f = Disciplina('TE', 4, c)
a.matricular(c)
d1 = Desempenho(a,d, 5,1)
d2 = Desempenho(a,e, 6,2)
d3 = Desempenho(a,f, 7,3)
a.listar_desempenhos()
a2 = Aluno('Maria','01/01/01')
a2.matricular(c)
a3 = Aluno('Jose','01/01/01')
a3.matricular(c)
d4 = Desempenho(a2,d, 4,3)
d5 = Desempenho(a3,d, 7,0)
d.listar_alunos()