def mkdir(diretorio):
if diretorio is None:
print('mkdir precisa de um argumento')
return
try:
dados, caminho_destino, nome_diretorio = pega_dados(diretorio)
except FileNotFoundError:
return
if dados.tem(nome_diretorio):
print('Já existe este diretório')
return
# É necessário o índice inicial ser alocado aqui, porque esse indice vai ser usado tanto como entrada no diretório
# correspondente quanto como primeiro índice do bloco do arquivo copiado.
index = aloca()
# Adicionando o índice do primeiro bloco da sequencia do novo arquivo como entrada do diretório destino
dados.add_entry(nome_diretorio, index)
dados.save(unidade)
# Criando um diretorio vazio com o indice adicionado na entrada do outro diretório
dados = Dados(bitmap, fat, index)
dados.mkdir(nome_diretorio)
dados.save(unidade)
# Em cada operação devemos salvar o estado dos metadados
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def __init__(self, jugadores):
if len(jugadores) < 2:
raise AttributeError(
'No se puede crear un parques con menos de 2 jugadores')
self.jugadores = []
self.tablero = []
self.escalera = [] # Las fichas que van al cielo
self.fichas = []
self.carcel = set()
self.cielo = set() # Las fichas que ya ganaron
self.esperando_movimiento = False
self.jugador_actual = None
self.dados = Dados()
self.ganador = None
for datos in jugadores:
jugador = Jugador(*datos)
self.jugadores.append(jugador)
if datos[2] == 1:
self.jugador_actual = jugador
for jugador in self.jugadores:
for ficha in jugador.fichas:
self.fichas.append(ficha)
for ficha in self.fichas:
self.carcel.add(ficha)
self.construir_tablero()
def find_recursive(dados, caminho_destino, arquivo_procurado):
for nome_arquivo in dados.keys():
index = dados.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.carrega_cabeçalho(unidade)
if arquivo.is_dir():
arquivo.load(unidade)
find_recursive(arquivo, caminho_destino + [nome_arquivo], arquivo_procurado)
else:
if arquivo.get_nome() == arquivo_procurado:
print(
'/' + '/'.join(caminho_destino) + '/' + arquivo_procurado if type(dados) is not Root else '/'.join(
caminho_destino) + '/' + arquivo_procurado)
def main():
"""
Atribui aos objetos que tem seus estados alterados a tarefa de notificar
os objetos interessados nessas mudanças, por exemplo, Na bolsa de valores
as ações estão em constante mudança e as corretoras e bancos sempre querem
ficar observando as alterações nessas ações.
"""
dados = Subject()
dados.adiciona_observador(Tabela(dados))
dados.adiciona_observador(Porcento(dados))
dados.modifica_estado(Dados(7, 3, 1))
dados.modifica_estado(Dados(2, 3, 1))
def percorre_caminho(caminho_destino):
if len(caminho_destino) == 0:
return root
nome_diretorio = caminho_destino.pop(0)
index = root.get_entry(nome_diretorio)
while len(caminho_destino):
dados = Dados(bitmap, fat, index)
dados.load(unidade)
if not dados.is_dir():
print('Não é um diretório')
raise NotADirectoryError
index = dados.get_entry(caminho_destino.pop(0))
dados = Dados(bitmap, fat, index)
dados.load(unidade)
return dados
def Enviar():
participante = Palestrante(nome1.get(), email1.get(), telefone1.get(),
cpf1.get(), data1.get(), matricula1.get())
savePalest(participante)
time.sleep(5)
i.destroy()
Dados(participante)
def __init__(self, txt, timer, dados, j):
#cria o job
self.job = Job(txt)
#nome do processo
self.nome = txt + str(j)
#prepara o timer
if self.job.data > 0:
self.estado = 'BLOQUEADO'
timer.timer_int_as(self.job.data, self.nome)
else:
self.estado = 'PRONTO'
#prepara o estado da cpu
self.cpu_estado = Cpu_estado()
#copia da mmu
self.copia_mmu = Mmu(int(dados.mem_size / dados.page_size),
dados.page_size)
#memoria secundaria /copia da memoria principal
self.mem_secundaria = Dados(dados.mem_size, dados.page_size)
self.index_saida = 1
self.cpu_time = 0
self.fim = 0
self.tempo_em_es = 0
self.tempo_em_troca_pagina = 0
self.vezes_bloqueado = 0
self.prioridade = 0.5
self.preempcao = 0
self.falha_pagina = 0
self.vezes_escalonado = 0
def __init__(self): """Constructor de la clase. Inicializa la interfaz grafica y los objetos que va a utilizar durante el juego.""" self.mazo = Mazo(paises.paises_por_tarjeta) self.dados = Dados() self.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes) Interfaz.iniciar(paises.coordenadas_de_paises, paises.archivo_tablero, paises.color_tablero) self.jugadores = []
def ls(diretorio):
if diretorio is None:
print('ls precisa de um argumento')
return
dados, caminho_destino, nome_arquivo = pega_dados(diretorio)
if nome_arquivo is None:
faça_ls(dados)
else:
index = dados.get_entry(nome_arquivo)
dados = Dados(bitmap, fat, index)
dados.carrega_cabeçalho(unidade)
if dados.is_dir():
dados.load(unidade)
faça_ls(dados)
else:
print('É um arquivo.')
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def rmdir_recursivo(index, caminho):
dados = Dados(bitmap, fat, index)
dados.carrega_cabeçalho(unidade)
if dados.is_dir():
dados.load(unidade)
for arquivos in dados.keys():
index = dados.get_entry(arquivos)
rmdir_recursivo(index, caminho + [arquivos])
print('/' + '/'.join(caminho) + '/' + dados.get_nome())
while index != -1:
bitmap.set_1(index)
index = fat.get(index)
def ls(diretorio):
if diretorio is None:
print('ls precisa de um argumento')
return
dados, caminho_destino, nome_arquivo = pega_dados(diretorio)
if nome_arquivo is None:
faça_ls(dados)
else:
index = dados.get_entry(nome_arquivo)
dados = Dados(bitmap, fat, index)
dados.carrega_cabeçalho(unidade)
if dados.is_dir():
dados.load(unidade)
faça_ls(dados)
else:
print('É um arquivo.')
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def rm(arquivo):
if arquivo is None:
print('rm precisa de um argumento')
return
dados, caminho_destino, nome_arquivo = pega_dados(arquivo)
if nome_arquivo in dados.keys():
index = dados.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.carrega_cabeçalho(unidade)
if arquivo.is_dir():
print('É um diretório')
return
while index != -1:
bitmap.set_1(index)
index = fat.get(index)
dados.del_entry(nome_arquivo)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
pass
def rm(arquivo):
if arquivo is None:
print('rm precisa de um argumento')
return
dados, caminho_destino, nome_arquivo = pega_dados(arquivo)
if nome_arquivo in dados.keys():
index = dados.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.carrega_cabeçalho(unidade)
if arquivo.is_dir():
print('É um diretório')
return
while index != -1:
bitmap.set_1(index)
index = fat.get(index)
dados.del_entry(nome_arquivo)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
pass
def df():
quantidade_diretórios = 1
quantidade_arquivos = 0
espaço_livre = 99940000
espaço_desperdiçado = 224 # 224 B desperdiçado nos metadados
pilha = []
# Tratamento especial para o root
for nome_arquivo in root.keys():
index = root.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if arquivo.is_dir():
quantidade_diretórios += 1
# 328 bytes para o cabeçalho do diretório e cada linha ocupa 257 bytes
espaço_desperdiçado += 4000 - arquivo.get_len_tabela() * 257 - 328
pilha.append(arquivo)
else:
quantidade_arquivos += 1
espaço_desperdiçado += 4000 - arquivo.get_tamanho() - 332 # 332 bytes para o cabeçalho do diretório
espaço_livre -= 4000
while len(pilha):
dado = pilha.pop()
for nome_arquivo in dado.keys():
index = dado.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if arquivo.is_dir():
quantidade_diretórios += 1
# 328 bytes para o cabeçalho do diretório e cada linha ocupa 257 bytes
espaço_desperdiçado += 4000 - dado.get_len_tabela() * 257 - 328
pilha.append(arquivo)
else:
quantidade_arquivos += 1
espaço_desperdiçado += 4000 - dado.get_tamanho() - 332 # 332 bytes para o cabeçalho do diretório
espaço_livre -= 4000
print('quantidade diretórios:', quantidade_diretórios)
print('quantidade arquivos:', quantidade_arquivos)
print('espaço livre:', espaço_livre)
print('espaço desperdiçado:', espaço_desperdiçado) # 224 B desperdiçado nos metadados)
class Simulador(object): """ Motores de simulacion de probabilidades para situaciones aleatorias""" def __init__(self, ultima_simulacion = 0): self.ultima_simulacion = ultima_simulacion self.dado = Dados() def ataque_individual(self, atacante, atacado, minatk = 1, maxdef = 0): """ Recibe la cantidad de ejercitos de cada lado, un minimo de ejercitos a conservar, y la cantidad tolerada de ejercitos enemigos sobrevivientes. Devuelve True si consigue destruir el minimo de ejercitos enemigos o False si no lo logra para cuando le quedan igual o menos ejercitos que el minimo propio. """ if atacado <= maxdef: return True elif atacante <= minatk: return False else: self.dado.lanzar_dados(atacante, atacado) self.ultima_simulacion = self.ataque_individual(atacante - self.dado.ejercitos_perdidos_atacante(), \ atacado - self.dado.ejercitos_perdidos_atacado(), minatk, maxdef) return self.ultima_simulacion def ataque(self, atacante, atacado, minatk = 1, maxdef = 0, precision = 1000): """ Corre mil veces la funcion ataque_individual, y devuelve la probabilidad (estimada) de victoria con esos ejercitos y limites """ ganados = 0 for i in xrange(precision): gane_combate = self.ataque_individual(atacante, atacado, minatk, maxdef) if gane_combate: ganados += 1 return ganados*1.0 / precision def ver_ultima_simulacion(self): """Devuelve el resultado del la ultima simulacion. """ return self.ultima_simulacion
def mkdir(diretorio):
if diretorio is None:
print('mkdir precisa de um argumento')
return
try:
dados, caminho_destino, nome_diretorio = pega_dados(diretorio)
except FileNotFoundError:
return
if dados.tem(nome_diretorio):
print('Já existe este diretório')
return
# É necessário o índice inicial ser alocado aqui, porque esse indice vai ser usado tanto como entrada no diretório
# correspondente quanto como primeiro índice do bloco do arquivo copiado.
index = aloca()
# Adicionando o índice do primeiro bloco da sequencia do novo arquivo como entrada do diretório destino
dados.add_entry(nome_diretorio, index)
dados.save(unidade)
# Criando um diretorio vazio com o indice adicionado na entrada do outro diretório
dados = Dados(bitmap, fat, index)
dados.mkdir(nome_diretorio)
dados.save(unidade)
# Em cada operação devemos salvar o estado dos metadados
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def percorre_caminho(caminho_destino):
if len(caminho_destino) == 0:
return root
nome_diretorio = caminho_destino.pop(0)
index = root.get_entry(nome_diretorio)
while len(caminho_destino):
dados = Dados(bitmap, fat, index)
dados.load(unidade)
if not dados.is_dir():
print('Não é um diretório')
raise NotADirectoryError
index = dados.get_entry(caminho_destino.pop(0))
dados = Dados(bitmap, fat, index)
dados.load(unidade)
return dados
def faça_ls(dados):
for nome in dados.keys():
index = dados.get_entry(nome)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if arquivo.is_dir():
print(arquivo.get_nome(), '/', sep='')
print(arquivo.modify)
else:
print(arquivo.get_nome())
print(arquivo.tamanho)
print(arquivo.modify)
def cp(origem, destino):
if origem is None:
print('origem faltando')
return
if destino is None:
print('destino faltando')
return
try:
dados, caminho_destino, nome_destino = pega_dados(destino)
except FileNotFoundError:
return
if nome_destino is None:
_, nome_destino = parse_path(origem)
if dados.tem(nome_destino):
print('Este Arquivo já existe')
return
# É necessário o índice inicial ser alocado aqui, porque esse indice vai ser usado tanto como entrada no diretório
# correspondente quanto como primeiro índice do bloco do arquivo copiado.
index = aloca()
# Adicionando o novo arquivo como entrada do diretório destino
dados.add_entry(nome_destino, index)
dados.save(unidade)
# Criando um novo arquivo com o mesmo indice da entrada adicionado do diretório com os dados copiados do arquivo
dados = Dados(bitmap, fat, index)
file = open(origem)
dados.set(nome_destino, file.read())
file.close()
dados.save(unidade)
# Em cada operação devemos salvar o estado dos metadados
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def rmdir_recursivo(index, caminho):
dados = Dados(bitmap, fat, index)
dados.carrega_cabeçalho(unidade)
if dados.is_dir():
dados.load(unidade)
for arquivos in dados.keys():
index = dados.get_entry(arquivos)
rmdir_recursivo(index, caminho + [arquivos])
print('/' + '/'.join(caminho) + '/' + dados.get_nome())
while index != -1:
bitmap.set_1(index)
index = fat.get(index)
def rmdir(diretorio):
if diretorio is None:
print('rmdir precisa de um argumento')
return
try:
dados, caminho_destino, nome_diretorio = pega_dados(diretorio)
except FileNotFoundError:
return
if dados.tem(nome_diretorio):
index = dados.get_entry(nome_diretorio)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if not arquivo.is_dir():
print('Não é diretório')
return
dados.del_entry(nome_diretorio)
dados.save(unidade)
for arquivos in arquivo.keys():
index = arquivo.get_entry(arquivos)
dado = Dados(bitmap, fat, index)
dado.load(unidade)
if dado.is_dir():
rmdir_recursivo(index, caminho_destino + [nome_diretorio])
else:
while index != -1:
bitmap.set_1(index)
index = fat.get(index)
print(nome_diretorio,
'%s removido%s com sucesso' % ('foram', 's') if len(dados.keys())
else '%s removido%s com sucesso' % ('foi', ''))
else:
print('Diretório %s não existe' % nome_diretorio)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def save_data_from_each_page(self, url, numero_tentativas=2):
try:
print(f'Salvando dados da página={url}')
self.fire_fox.get(url)
bs_page = BeautifulSoup(self.fire_fox.page_source, 'html.parser')
dados = Dados()
self.add_the_complaint(bs_page, dados)
self.add_replies_to_data_frame(bs_page, dados)
except Exception as e:
print(f'Erro ao tentar salvar dados da página={url}', e)
if numero_tentativas > 0:
sleep(3)
self.save_data_from_each_page(url, numero_tentativas - 1)
else:
return None
def mount(arquivo):
global unidade
if arquivo is None:
print('O comando mount precisa de nome de arquivo como argumento')
return
try:
unidade = open(arquivo, 'r+b')
bitmap.load(unidade)
fat.load(unidade)
root.load(unidade)
except FileNotFoundError:
unidade = open(arquivo, 'w+b')
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
Dados().save(unidade)
def faça_ls(dados):
for nome in dados.keys():
index = dados.get_entry(nome)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if arquivo.is_dir():
print(arquivo.get_nome(), '/', sep='')
print(arquivo.modify)
else:
print(arquivo.get_nome())
print(arquivo.tamanho)
print(arquivo.modify)
def pega_dados(nome_arquivo):
caminho = nome_arquivo.split('/')
while '' in caminho:
caminho.remove('')
if len(caminho) == 0:
return root, caminho, None
nome_arquivo = caminho.pop()
diretório = root
for nome_diretório in caminho:
if not diretório.tem(nome_diretório):
print('Diretório não foi encontrado')
raise FileNotFoundError
diretório = Dados(bitmap, fat, diretório.get_entry(nome_diretório))
diretório.load(unidade)
if not diretório.is_dir():
print(diretório.get_nome(), 'é um arquivo')
raise NotADirectoryError
return diretório, caminho, nome_arquivo
def find_recursive(dados, caminho_destino, arquivo_procurado):
for nome_arquivo in dados.keys():
index = dados.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.carrega_cabeçalho(unidade)
if arquivo.is_dir():
arquivo.load(unidade)
find_recursive(arquivo, caminho_destino + [nome_arquivo],
arquivo_procurado)
else:
if arquivo.get_nome() == arquivo_procurado:
print('/' + '/'.join(caminho_destino) + '/' +
arquivo_procurado if type(dados) is not Root else
'/'.join(caminho_destino) + '/' + arquivo_procurado)
def cat(arquivo):
if arquivo is None:
print('cat precisa de um argumento')
return
try:
dados, caminho_destino, nome_arquivo = pega_dados(arquivo)
except FileNotFoundError:
return
if dados.tem(nome_arquivo):
index = dados.get_entry(nome_arquivo)
dados = Dados(bitmap, fat, index)
dados.load(unidade)
print(dados.get_dado())
dados.save(unidade)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
pass
def cat(arquivo):
if arquivo is None:
print('cat precisa de um argumento')
return
try:
dados, caminho_destino, nome_arquivo = pega_dados(arquivo)
except FileNotFoundError:
return
if dados.tem(nome_arquivo):
index = dados.get_entry(nome_arquivo)
dados = Dados(bitmap, fat, index)
dados.load(unidade)
print(dados.get_dado())
dados.save(unidade)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
pass
def cp(origem, destino):
if origem is None:
print('origem faltando')
return
if destino is None:
print('destino faltando')
return
try:
dados, caminho_destino, nome_destino = pega_dados(destino)
except FileNotFoundError:
return
if nome_destino is None:
_, nome_destino = parse_path(origem)
if dados.tem(nome_destino):
print('Este Arquivo já existe')
return
# É necessário o índice inicial ser alocado aqui, porque esse indice vai ser usado tanto como entrada no diretório
# correspondente quanto como primeiro índice do bloco do arquivo copiado.
index = aloca()
# Adicionando o novo arquivo como entrada do diretório destino
dados.add_entry(nome_destino, index)
dados.save(unidade)
# Criando um novo arquivo com o mesmo indice da entrada adicionado do diretório com os dados copiados do arquivo
dados = Dados(bitmap, fat, index)
file = open(origem)
dados.set(nome_destino, file.read())
file.close()
dados.save(unidade)
# Em cada operação devemos salvar o estado dos metadados
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
emails.append(nomes[0] + nomes[1][0] + nomes[2][0] + dom)
emails.append(nomes[0] + nomes[2] + dom)
emails.append(nomes[0][0] + nomes[2] + dom)
emails.append(nomes[0][0] + nomes[1] + nomes[2] + dom)
return emails
def verificaMatricula(matricula):
for aluno in dadosAlunos.alunos:
if aluno.matricula == matricula:
return aluno
return False
# Lendo os dados da tabela CSV
dadosAlunos = Dados("./dados/alunos.csv")
dadosAlunos.lerDados()
# Requisitando a matricula do aluno
matricula = input("Digite sua matricula:")
# Buscando o aluno da matricula digitada
alunoLogado = verificaMatricula(matricula)
# Propondo os emails se logado, se não envia mensagem de erro
nomeAluno = alunoLogado.nome
emails = geraEmails(nomeAluno)
sinal = False
if alunoLogado:
if (alunoLogado.status == "Ativo"):
def touch(arquivo):
if arquivo is None:
print('touch precisa de um argumento')
return
try:
dados, caminho_destino, nome_arquivo = pega_dados(arquivo)
except FileNotFoundError:
return
if dados.tem(nome_arquivo):
index = dados.get_entry(nome_arquivo)
dados = Dados(bitmap, fat, index)
dados.load(unidade)
if dados.is_dir():
print('É um diretório!')
return
dados.get_dado(
) # com o get_dado eu estou atualizando o instante de acesso
dados.save(unidade)
else:
index = aloca()
dados.add_entry(nome_arquivo, index)
dados.save(unidade)
dados = Dados(bitmap, fat, index)
dados.set(nome_arquivo, '')
dados.save(unidade)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
pass
def touch(arquivo):
if arquivo is None:
print('touch precisa de um argumento')
return
try:
dados, caminho_destino, nome_arquivo = pega_dados(arquivo)
except FileNotFoundError:
return
if dados.tem(nome_arquivo):
index = dados.get_entry(nome_arquivo)
dados = Dados(bitmap, fat, index)
dados.load(unidade)
if dados.is_dir():
print('É um diretório!')
return
dados.get_dado() # com o get_dado eu estou atualizando o instante de acesso
dados.save(unidade)
else:
index = aloca()
dados.add_entry(nome_arquivo, index)
dados.save(unidade)
dados = Dados(bitmap, fat, index)
dados.set(nome_arquivo, '')
dados.save(unidade)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
pass
import sys
import numpy as np
from operator import itemgetter
from scipy import stats
import time
from dados import Dados
import glob
from mat_coocorrrencia import Mat_coocorrencia
N_train = 1120
N_test = 1120
im_train = [Dados() for i in range(N_train)]
im_test = [Dados() for i in range(N_test)]
cont_train = 0
cont_test = 0
name_images = glob.glob('Carvao/*.tif')
name_images.sort()
niveis = 5
caracteristicas = 16
matTrain_coocorrencia = np.zeros((N_train, caracteristicas))
matTest_coocorrencia = np.zeros((N_test, caracteristicas))
labelTrain = []
labelTest = []
#metodo=int(str(sys.argv[1]))
metodo = 0
# metodo 0->
# metodo 1->
# metodo 2 ->
# metodo 3 ->
class ProjetoApp(App):
construir_medidas_com_historico = False
dados = Dados()
# dados.gera_data_bases()
icon = "imagens/icone.png"
kv_file = "projeto.kv"
def on_start(self):
pass
def build(self):
self.manager = ScreenManager()
self.constroi_tela_home()
self.constroi_tela_inserir_constantes("simples")
self.constroi_tela_inserir_constantes("duplo")
self.constroi_tela_sobre()
# self.constroi_tela_historico()
self.manager.ids["circuito_simples_botao_ok"].bind(
on_release=self.button_circuito_botao_ok("simples"))
self.manager.ids["circuito_duplo_botao_ok"].bind(
on_release=self.button_circuito_botao_ok("duplo"))
# self.manager.current = "circuito_simples"
return self.manager
def vai_para_tela(self, nome: str):
def dentro(*args):
self.manager.current = nome
return dentro
def button_circuito_botao_ok(self, tipo: str):
def funcao_dentro(*args):
self.ler_entrada_dados(tipo)
self.tela_anterior = f"circuito_{tipo}"
return funcao_dentro
def button_circuito_duplo_botao_ok(self, button):
self.ler_entrada_dados("duplo")
self.tela_anterior = "circuito_duplo"
def button_circuito_simples_botao_ok(self, button):
self.ler_entrada_dados("simples")
self.tela_anterior = "circuito_simples"
def button_voltar_home(self, button):
self.manager.current = "home"
def button_voltar_home_e_apaga_insercoes(self, tipo):
distancias = [""] * 3
constantes = [tipo] + [""] * len(NOMES_CONSTANTES[tipo][:-2]) + ["0"]
def funcao_interna(*argsv):
self.constroi_telas_a_partir_do_historico(constantes, distancias)
self.manager.current = "home"
return funcao_interna
def button_home_circuito_duplo(self, button):
self.construir_medidas_com_historico = False
self.constroi_tela_inserir_constantes("duplo")
def button_home_circuito_simples(self, button):
self.construir_medidas_com_historico = False
self.constroi_tela_inserir_constantes("simples")
def button_home_historico(self, button):
self.constroi_tela_historico()
def button_botoes_historico(self, button):
key = button.key
dados = self.dados.ler_do_banco_dados()[key]
# print(f"Botao {key}, Valor: {dados}")
constantes, distancias = dados
self.constroi_telas_a_partir_do_historico(constantes[2:],
distancias[1:])
def button_inserir_distancias_botao_voltar(self, button):
self.manager.current = self.tela_anterior
def button_inserir_distancias_botao_ok(self, button):
self.ler_entrada_distancias()
def button_home_sair(self, *args, **kwargs):
# print("chamou")
tela: TelaHome = self.manager.get_screen("home")
tela.confirmacao_saida()
return True
def button_historico_botao_limpar(self, button):
# print("limpando banco de dados")
box = BoxLayout(orientation="vertical", padding="10sp", spacing="10sp")
botoes = BoxLayout(padding="10sp", spacing="10sp")
pop = Popup(title="Deseja Limpar o Histórico?",
content=box,
title_size="25sp",
size_hint=(.5, .35))
pop.opacity = .85
imagem = Image(source="./imagens/atencao.png")
def limpa_e_recarrega_hitorico(*args):
self.dados.gera_data_bases()
self.constroi_tela_historico()
pop.dismiss()
sim = PopButton(text="sim",
font_size="20sp",
on_release=limpa_e_recarrega_hitorico)
nao = PopButton(text="nao", font_size="20sp", on_release=pop.dismiss)
botoes.add_widget(sim)
botoes.add_widget(nao)
box.add_widget(imagem)
box.add_widget(botoes)
pop.open()
# self.dados.gera_data_bases()
# self.constroi_tela_historico()
def button_relatorio_voltar(self, button):
self.manager.current = self.tela_anterior
def constroi_telas_a_partir_do_historico(self, constantes, distancias):
tipo = constantes[0]
nome = f"circuito_{tipo}" + "_{}"
nomes_constantes = NOMES_CONSTANTES[tipo]
for txt, cons in zip(constantes[1:], nomes_constantes[1:]):
if cons == "CONDUTORES_SIMETRICOS":
self.manager.ids[nome.format(cons)].active = int(txt)
continue
self.manager.ids[nome.format(cons)].text = str(txt)
self.manager.current = f"circuito_{tipo}"
self.construir_medidas_com_historico = True
self._distancias = distancias
def constroi_tela_home(self):
screen = TelaHome(name="home")
home = TelaHomeWidget(Window.size)
for chave, valor in home.ids.items():
self.manager.ids[chave] = valor
screen.add_widget(home)
self.manager.add_widget(screen)
self.manager.ids["home_circuito_simples"].bind(
on_release=self.button_home_circuito_simples)
self.manager.ids["home_circuito_duplo"].bind(
on_release=self.button_home_circuito_duplo)
self.manager.ids["home_historico"].bind(
on_release=self.button_home_historico)
self.manager.ids["home_sobre"].bind(
on_release=self.vai_para_tela("sobre"))
self.manager.ids["home_sair"].bind(on_release=self.button_home_sair)
def constroi_tela_historico(self):
nome_tela = "historico"
if self.manager.has_screen(nome_tela):
screen = self.manager.get_screen(nome_tela)
screen.canvas.clear()
else:
screen = Screen(name=nome_tela)
self.manager.add_widget(screen)
historico = HistoricoWidget(Window.size, self.dados)
try:
historico.ids['historico_botao_voltar'].bind(
on_release=self.button_voltar_home)
historico.ids['historico_botao_limpar'].bind(
on_release=self.button_historico_botao_limpar)
except:
pass
for chave, valor in historico.ids.items():
if valor.__class__.__name__.endswith("HistoricoButton"):
valor.bind(on_press=self.button_botoes_historico)
screen.add_widget(historico)
self.manager.current = nome_tela
def constroi_tela_inserir_constantes(self, tipo):
assert isinstance(tipo, str)
nome_tela = f"circuito_{tipo}"
if self.manager.has_screen(nome_tela):
self.manager.current = nome_tela
return
screen = Screen(name=nome_tela)
nomes = NOMES_CONSTANTES[tipo]
tela_inserir = TelaInserirWidget(
Window.size,
nome_tela,
nomes[1:],
titulo=f"Dados para Circuito {tipo}".title())
screen.add_widget(tela_inserir)
self.manager.add_widget(screen)
for chave, valor in tela_inserir.ids.items():
self.manager.ids[chave] = valor
self.manager.ids[f"{nome_tela}_botao_voltar"].bind(
on_release=self.button_voltar_home)
def constroi_tela_inserir_medidas(self, numero_condutores):
nome_tela = "inserir_distancias"
if self.manager.has_screen(nome_tela):
screen = self.manager.get_screen(nome_tela)
screen.canvas.clear()
else:
screen = Screen(name=nome_tela)
self.manager.add_widget(screen)
simetria = int(self.constantes_lidas[-1])
if simetria:
if numero_condutores > 4:
raise NotImplementedError(
"Codigo no modulo Calculos nao implementado ... Parando ainda no modulo main"
)
nomes_campos = ["Distancia entre os contutores"]
keys = ["TEXT_INPUT"]
else:
nomes_campos = [
f"Distancia entre os cabos {i+1} e {j+1}"
for i in range(numero_condutores)
for j in range(i + 1, numero_condutores)
]
keys = [f"TEXT_INPUT{i}" for i, j in enumerate(nomes_campos)]
inserir = TelaInserirWidget(Window.size,
nome_tela,
nomes_campos,
"Entre com as distancias".title(),
keys=keys)
screen.add_widget(inserir)
n = 0
for chave, valor in inserir.ids.items():
if self.construir_medidas_com_historico and "TEXT_INPUT" in chave:
try:
valor.text = str(self._distancias[n])
except:
valor.text = ""
n += 1
self.manager.ids[chave] = valor
self.manager.ids[f"{nome_tela}_botao_voltar"].bind(
on_release=self.button_inserir_distancias_botao_voltar)
self.manager.ids[f"{nome_tela}_botao_ok"].bind(
on_release=self.button_inserir_distancias_botao_ok)
# self.manager.current = nome_tela
def constroi_tela_sobre(self):
nome_tela = "sobre"
screen = Screen(name=nome_tela)
dados = [[
"Programa desenvolvido pelos estudantes",
], ["Danilo C Nascimento", "*****@*****.**"],
["Kaio Nascimento", "*****@*****.**"],
["Shamella Castro", "*****@*****.**"]]
tela = TelaSobreWidget(titulo="Sobre os Desenvolvedores", dados=dados)
tela.ids["sobre_botao_voltar"].bind(
on_release=self.vai_para_tela("home"))
screen.add_widget(tela)
self.manager.add_widget(screen)
def constroi_tela_gera_relatorio(self):
# print("Aqui serão gerados os relatórios")
nomes = self.dados.get_valores_de_um_campo("NOME")
if self.NOME not in nomes:
self.dados.salva_no_banco_dados([
self.constantes_lidas_para_salvar,
self.distancias_lidas_para_salvar
])
nome_tela = "gera_relatorio"
if self.manager.has_screen(nome_tela):
screen = self.manager.get_screen(nome_tela)
screen.canvas.clear()
else:
screen = Screen(name=nome_tela)
self.manager.add_widget(screen)
#Execura os calculos
calculos = Calculos(self.constantes_lidas, self.distancias_lidas)
indutancia = calculos.calculo_indutancia()
capacitancia = calculos.calculo_capacitancia(True)
lista_tratada = []
unidade = "H/m H Ω/m Ω F/m F Ω/m Ω S".split()
num = unidades.para_notacao_cientifica(indutancia[1], unidade[1], 4)
for i, numero in enumerate(list(indutancia) + list(capacitancia)):
try:
num = unidades.para_notacao_cientifica(numero, unidade[i], 4)
num = str(num).replace(".", ",")
lista_tratada.append(num)
except Exception as e:
lista_tratada.append(numero)
print("Erro", e)
descricao = "Indutancia,Indutancia_Total,Reatancia_Indutiva,Reatancia Indutiva Total".split(
",")
descricao += "Capacitancia,Capacitancia Total,Reatancia Capacitiva,Reatancia Capacitiva Total, Susceptancia Capacitiva".split(
",")
dic = [(f"Descrição {i}", f"Valor {i}") for i in range(1, 20)]
valores = list(zip(descricao, lista_tratada))
#print(valores)
dic = dict(valores)
for i in range(1, 4):
txt = " " * i
dic[txt] = ""
relatorio = GeraRelatorioWidget(Window.size, nome_tela, "Relatórios",
dic)
relatorio.ids[f"{nome_tela}_botao_voltar"].bind(
on_release=self.button_relatorio_voltar)
tipo = self.constantes_lidas[0]
relatorio.ids[f"{nome_tela}_botao_home"].bind(
on_release=self.button_voltar_home_e_apaga_insercoes(tipo))
screen.add_widget(relatorio)
self.manager.current = nome_tela
def ler_entrada_dados(self, tipo: str):
"""
:param tipo: str ["simples", "duplo", "medidas"]
:param constantes: list
:return: list
"""
numero_condutores = 0
if tipo == "simples":
constantes = NOMES_CONSTANTES["simples"]
elif tipo == "duplo":
constantes = NOMES_CONSTANTES["duplo"]
else:
texto = f"tipo nao percence a " + ", \"{}\"" * 3
raise ValueError(texto.format("simples", "duplo"))
constantes_lidas = []
self.constantes_lidas_para_salvar = [tipo]
logs = []
texto_log = "O campo [b]{}[/b] {}"
simetria = False
nome_tela = "obtem_medidas"
if tipo != "medidas":
constantes_lidas = [tipo] # [f"\"{tipo}\""]
nome_tela = f"circuito_{tipo}"
for nome in constantes[1:]:
id = f"{nome_tela}_{nome}"
texto_label = " ".join(nome.split("_"))
if nome == "CONDUTORES_SIMETRICOS":
if self.manager.ids[id].active:
lido = "1"
simetria = True
else:
lido = "0"
simetria = False
constantes_lidas.append(lido)
self.constantes_lidas_para_salvar.append(lido)
continue
lido = str(self.manager.ids[id].text)
self.constantes_lidas_para_salvar.append(lido)
lido = lido.replace(",", ".")
try:
lido = unidades.de_notacao_cientifica(lido)
lido = str(lido)
except:
pass
if lido == "":
logs.append(texto_log.format(texto_label, "está vazio"))
elif nome == "NUMERO_CONDUTORES":
try:
lido = int(lido)
numero_condutores = lido
if lido <= 0:
logs.append(
texto_log.format(texto_label,
"deve ser maior que 0"))
if lido > 15:
logs.append(
texto_log.format(texto_label,
"deve ser menor ou igual a 15"))
except:
logs.append(texto_log.format(texto_label, "não é inteiro"))
elif nome != "NOME":
try:
lido = float(lido)
except:
logs.append(texto_log.format(texto_label, "não é real"))
constantes_lidas.append(lido)
self.NOME = constantes_lidas[1]
if simetria and numero_condutores > 4:
logs.append(
"Ainda não há implementação para calculos com mais de 4 consdutores simétricos"
)
if logs:
popup = LogPopup(Window.size, logs, opacity=.75)
popup.open()
elif numero_condutores > 1:
self.constantes_lidas = constantes_lidas
self.constroi_tela_inserir_medidas(numero_condutores)
self.numero_condutores = numero_condutores
self.manager.current = "inserir_distancias"
elif numero_condutores == 1:
self.distancias_lidas = []
self.constantes_lidas = constantes_lidas
self.constroi_tela_gera_relatorio()
def ler_entrada_distancias(self):
nome_tela = "inserir_distancias"
simetria = int(self.constantes_lidas[-1])
if simetria:
if self.numero_condutores > 4:
raise NotImplementedError(
"Codigo no modulo Calculos nao implementado ... Parando ainda no modulo main"
)
nomes_campos = ["Distancia entre os contutores"]
keys = ["TEXT_INPUT"]
else:
nomes_campos = [
f"Distancia entre os cabos {i + 1} e {j + 1}"
for i in range(self.numero_condutores)
for j in range(i + 1, self.numero_condutores)
]
keys = [f"TEXT_INPUT{i}" for i, j in enumerate(nomes_campos)]
distancias_lidas = []
self.distancias_lidas_para_salvar = []
logs = []
texto_log = "O campo [b]{}[/b] {}"
for nome, campo in zip(keys, nomes_campos):
lido = str(self.manager.ids[f"{nome_tela}_{nome}"].text)
self.distancias_lidas_para_salvar.append(lido)
lido = lido.replace(",", ".")
try:
lido = unidades.de_notacao_cientifica(lido)
lido = str(lido)
except:
...
if lido == "":
logs.append(texto_log.format(campo, "está vazio"))
else:
try:
lido = float(lido)
except:
logs.append(texto_log.format(campo, "nao é real"))
distancias_lidas.append(lido)
# print(distancias_lidas)
self.distancias_lidas = distancias_lidas
if logs:
popup = LogPopup(Window.size, logs, opacity=.75)
popup.open()
else:
self.distancias_lidas = distancias_lidas
self.constroi_tela_gera_relatorio()
class TEG(object):
"""Implementa la logica de una partida de TEG."""
def __init__(self):
"""Constructor de la clase.
Inicializa la interfaz grafica y los objetos que va a utilizar
durante el juego."""
self.mazo = Mazo(paises.paises_por_tarjeta)
self.dados = Dados()
self.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
Interfaz.iniciar(paises.coordenadas_de_paises, paises.archivo_tablero, paises.color_tablero)
self.jugadores = []
# Eventualmente aca haya falta agregar mas cosas...
def configurar_el_juego(self):
"""Pone a los jugadores en el juego."""
Interfaz.setear_titulo('Configurando el juego')
n = Interfaz.elegir('Jugadores', 'Seleccione el numero de jugadores', range(2,7))
nombre_colores = NOMBRE_COLORES.values()
for i in range(n):
nombre = Interfaz.elegir('Jugador %d' % (i + 1), 'Ingrese el nombre del jugador %d' % (i + 1))
color = Interfaz.elegir('Jugador %d' % (i + 1), 'Ingrese el color del jugador %d' % (i + 1), nombre_colores)
nombre_colores.remove(color)
c = NOMBRE_COLORES.keys()[NOMBRE_COLORES.values().index(color)]
self.jugadores.append(Jugador(c, nombre))
def repartir_paises(self):
"""Reparte en ronda las tarjetas de paises y pone un ejercito
en cada uno de los paises."""
Interfaz.setear_titulo('Repartiendo paises iniciales')
ntarjetas = self.mazo.cantidad_tarjetas()
njugadores = len(self.jugadores)
for jugador in \
self.jugadores * (ntarjetas / njugadores) + \
random.sample(self.jugadores, ntarjetas % njugadores):
t = self.mazo.sacar_tarjeta()
self.tablero.ocupar_pais(t.pais, jugador.color, 1)
self.mazo.devolver_tarjeta(t)
def agregar_ejercitos_inicial(self, inicia_ronda):
"""Realiza la primer fase de colocacion de ejercitos."""
Interfaz.setear_titulo('Incorporando ejercitos')
ejercitos_primera = int(math.ceil(self.tablero.cantidad_paises() / 10.0))
ejercitos_segunda = int(math.ceil(self.tablero.cantidad_paises() / 20.0))
for cantidad in (ejercitos_primera, ejercitos_segunda):
for i in range(len(self.jugadores)):
jugador = self.jugadores[(inicia_ronda + i) % len(self.jugadores)]
Interfaz.alertar(jugador, '%s pone ejercitos' % jugador)
# cantidad de ejercitos
#en cualquier continente
ejercitos = jugador.agregar_ejercitos(self.tablero, {"": cantidad})
assert(sum(ejercitos.values()) == cantidad)
for pais in ejercitos:
assert(self.tablero.color_pais(pais) == jugador.color)
self.tablero.asignar_ejercitos(pais, ejercitos[pais])
self.tablero.actualizar_interfaz()
def realizar_fase_ataque(self, jugador):
"""Implementa la fase de ataque de un jugador.
Sucesivamente hace combatir a los paises seleccionados.
Devuelve el numero de paises conquistados."""
Interfaz.setear_titulo('%s ataca' % jugador)
Interfaz.alertar(jugador, '%s ataca' % jugador)
paises_ganados = 0
while True:
ataque = jugador.atacar(self.tablero)
if not ataque:
break
atacante, atacado = ataque
assert(self.tablero.es_limitrofe(atacante, atacado))
assert(self.tablero.ejercitos_pais(atacante) > 1)
self.dados.lanzar_dados(self.tablero.ejercitos_pais(atacante), self.tablero.ejercitos_pais(atacado))
self.tablero.asignar_ejercitos(atacante, -self.dados.ejercitos_perdidos_atacante())
self.tablero.asignar_ejercitos(atacado, -self.dados.ejercitos_perdidos_atacado())
Interfaz.setear_titulo('%s: -%d, %s: -%d %s' % (atacante, self.dados.ejercitos_perdidos_atacante(), atacado, self.dados.ejercitos_perdidos_atacado(), self.dados))
if self.tablero.ejercitos_pais(atacado) == 0:
paises_ganados += 1
mover = Interfaz.elegir(jugador, 'Cuantos ejercitos se desplazan a %s?' % atacado, range(1, min(self.tablero.ejercitos_pais(atacante) - 1, 3) + 1))
self.tablero.asignar_ejercitos(atacante, -mover)
self.tablero.ocupar_pais(atacado, jugador.color, mover)
self.tablero.actualizar_interfaz()
else:
self.tablero.actualizar_interfaz()
time.sleep(1)
return paises_ganados
def realizar_fase_reagrupamiento(self, jugador):
"""
Realiza el reagrupamiento de ejercitos.
"""
Interfaz.setear_titulo('%s reagrupa' % jugador)
Interfaz.alertar(jugador, '%s reagrupa' % jugador)
lista = jugador.reagrupar(self.tablero)
# Se fija que el reagrupamiento sea consistente:
salientes = {}
for origen, destino, cantidad in lista:
assert(self.tablero.es_limitrofe(origen, destino))
assert(self.tablero.color_pais(origen) == jugador.color)
assert(self.tablero.color_pais(destino) == jugador.color)
salientes[origen] = salientes.get(origen, 0) + cantidad
for pais in salientes:
assert(self.tablero.ejercitos_pais(pais) > salientes[pais])
# Aplica la lista de cambios:
for origen, destino, cantidad in lista:
self.tablero.asignar_ejercitos(origen, -cantidad)
self.tablero.asignar_ejercitos(destino, cantidad)
def manejar_tarjetas(self, jugador, paises_ganados):
"""
Realiza la fase de obtencion de tarjetas de pais.
1) Si el jugador gano un pais del cual no habia usado una
tarjeta que posee, se colocan 2 ejercitos en ese pais.
2) Si el jugador realizo menos de 3 canjes y gano al menos un
pais o si realizo 3 o mas cajes y gano al menos dos paises,
recibe una nueva tarjeta de pais.
3) Si recibio tarjeta de pais y posee ese pais, recibe 2
ejercitos adicionales en el mismo.
"""
raise NotImplementedError()
def agregar_ejercitos(self, inicia_ronda):
"""Realiza la fase general de colocacion de ejercitos.
La cantidad de ejercitos a agregar son:
1) Si el jugador tiene tres tarjetas con el mismo simbolo o si
tiene tres tarjetas con distinto simbolo, entonces se realizara
el canje. Cuando se realiza el canje, las tarjetas del jugador
se devuelven al mazo.
El primer canje otorgara 4 ejercitos adicionales para ser
colocados en cualquier pais, el segundo 7, el tercero 10 y a
partir de ahi 15, 20, 25, etc.
2) El jugador agregara tantos ejercitos como paises / 2 posea
(division entera, truncando) en cualquiera de sus paises.
3) Si el jugador poseyera continentes completos agregara el
adicional que indica ejercitos_por_continente obligatoriamente
en dicho continente."""
raise NotImplementedError
def jugador_es_ganador(self, jugador):
"""Verifica si el jugador gano el juego.
Un jugador gana el juego si conquista el 100% de los paises."""
raise NotImplementedError
def jugador_esta_vivo(self, jugador):
"""Verifica si un jugador sigue en carrera.
Un jugador muere cuando se queda sin paises."""
raise NotImplementedError
def jugar(self):
Interfaz.setear_titulo('Trabajo de Entrega Grupal')
Interfaz.alertar('Bienvenido!', 'Bienvenido al Trabajo de Entrega Grupal')
# Se selecciona el numero de jugadores y se crean los mismos:
self.configurar_el_juego()
# Se reparten los paises iniciales:
self.repartir_paises()
self.tablero.actualizar_interfaz()
# Se sortea que jugador iniciara el juego:
inicia_ronda = random.randrange(len(self.jugadores))
Interfaz.setear_texto("Ronda: %s" % self.texto_ronda(inicia_ronda))
# Primer refuerzo de ejercitos:
self.agregar_ejercitos_inicial(inicia_ronda)
# Bucle principal del juego:
while Interfaz.esta_corriendo():
# Para cada jugador en la ronda:
for i in range(len(self.jugadores)):
jugador = self.jugadores[(inicia_ronda + i) % len(self.jugadores)]
# El jugador puede haber muerto durante esta ronda:
if not self.jugador_esta_vivo(jugador):
continue
# El jugador juega su fase de ataques:
paises_ganados = self.realizar_fase_ataque(jugador)
# Se verifica si gano el juego:
if self.jugador_es_ganador(jugador):
Interfaz.alertar('Hay ganador!', 'El jugador %s ha ganado el juego' % jugador)
return
# El jugador realiza sus reagrupamientos:
self.realizar_fase_reagrupamiento(jugador)
# Se entrega la tarjeta y se verifica si ocupa
# algun pais del cual posee tarjeta.
self.manejar_tarjetas(jugador, paises_ganados)
# Si algun jugador hubiera perdido durante la ronda
# anterior se lo saca del juego:
for i in range(len(self.jugadores) - 1, -1, -1):
if not self.jugador_esta_vivo(self.jugadores[i]):
Interfaz.alertar('Uno menos!', 'El jugador %s ha quedado eliminado' % jugador)
self.jugadores.pop(i)
if inicia_ronda >= i:
inicia_ronda -= 1
# La siguiente ronda es iniciada por el siguiente jugador:
inicia_ronda = (inicia_ronda + 1) % len(self.jugadores)
Interfaz.setear_texto("Ronda: %s" % self.texto_ronda(inicia_ronda))
# Los jugadores refuerzan sus ejercitos:
self.agregar_ejercitos(inicia_ronda)
def texto_ronda(self, inicia_ronda):
"""Magia negra de Python.
(Devuelve el nombre de los jugadores en el orden de la ronda.)"""
return ', '.join([str(x) for x in self.jugadores[inicia_ronda:] + self.jugadores[:inicia_ronda]])
def __init__(self, ultima_simulacion = 0): self.ultima_simulacion = ultima_simulacion self.dado = Dados()
if isinstance(dado, Dados):
if self.estaCheia() == False:
if self.estaVazia() == True:
self.inicio = dado
self.fim = dado
self.tamanho = 1
return self.inicio.getDado()
else:
dado.setAnterior(self.fim)
self.tamanho += 1
self.fim = dado
return self.fim.getDado()
else:
raise Exception("A fila está cheia!")
else:
raise Exception("O parâmetro passado é inválido")
dado1 = Dados(1)
dado2 = Dados(2)
fila = Fila(2)
fila.insere(dado1) # testa a inserção de dados na fila
fila.insere(dado2)
print(fila.estaCheia()) # testa se esta cheia - DEVE RETORNAR TRUE
print(fila.estaVazia()) # testa se esta vazia - DEVE RETORNAR FALSE
fila.remove()
print(
fila.getInicio().getDado()) # o ultimo elemento foi removido corretamente
print(fila.estaCheia()) # deve retornar false
fila.remove()
print(fila.estaVazia()) # deve retornar um erro
def rmdir(diretorio):
if diretorio is None:
print('rmdir precisa de um argumento')
return
try:
dados, caminho_destino, nome_diretorio = pega_dados(diretorio)
except FileNotFoundError:
return
if dados.tem(nome_diretorio):
index = dados.get_entry(nome_diretorio)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if not arquivo.is_dir():
print('Não é diretório')
return
dados.del_entry(nome_diretorio)
dados.save(unidade)
for arquivos in arquivo.keys():
index = arquivo.get_entry(arquivos)
dado = Dados(bitmap, fat, index)
dado.load(unidade)
if dado.is_dir():
rmdir_recursivo(index, caminho_destino + [nome_diretorio])
else:
while index != -1:
bitmap.set_1(index)
index = fat.get(index)
print(
nome_diretorio, '%s removido%s com sucesso' % ('foram', 's') if
len(dados.keys()) else '%s removido%s com sucesso' % ('foi', ''))
else:
print('Diretório %s não existe' % nome_diretorio)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def test_pesquisar():
assert Dados('Python').pesquisar() is not None
def find(diretorio, arquivo):
if diretorio is None or arquivo is None:
print('find precisa de dois argumentos')
return
dados, caminho_destino, diretorio = pega_dados(diretorio)
if diretorio is not None:
if not dados.tem(diretorio):
print('Diretório não encontrado')
return
index = dados.get_entry(diretorio)
dados = Dados(bitmap, fat, index)
dados.carrega_cabeçalho(unidade)
if not dados.is_dir():
print('Não é um diretório')
return
dados.load(unidade)
find_recursive(dados, caminho_destino + [diretorio], arquivo)
else:
for nome_arquivo in dados.keys():
index = dados.get_entry(nome_arquivo)
a = Dados(bitmap, fat, index)
a.carrega_cabeçalho(unidade)
if a.is_dir():
a.load(unidade)
find_recursive(a, caminho_destino + [nome_arquivo], arquivo)
else:
if a.get_nome() == arquivo:
print('/' + '/'.join(caminho_destino) + '/' +
arquivo if type(dados) is not Root else
'/'.join(caminho_destino) + '/' + arquivo)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def df():
quantidade_diretórios = 1
quantidade_arquivos = 0
espaço_livre = 99940000
espaço_desperdiçado = 224 # 224 B desperdiçado nos metadados
pilha = []
# Tratamento especial para o root
for nome_arquivo in root.keys():
index = root.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if arquivo.is_dir():
quantidade_diretórios += 1
# 328 bytes para o cabeçalho do diretório e cada linha ocupa 257 bytes
espaço_desperdiçado += 4000 - arquivo.get_len_tabela() * 257 - 328
pilha.append(arquivo)
else:
quantidade_arquivos += 1
espaço_desperdiçado += 4000 - arquivo.get_tamanho(
) - 332 # 332 bytes para o cabeçalho do diretório
espaço_livre -= 4000
while len(pilha):
dado = pilha.pop()
for nome_arquivo in dado.keys():
index = dado.get_entry(nome_arquivo)
arquivo = Dados(bitmap, fat, index)
arquivo.load(unidade)
if arquivo.is_dir():
quantidade_diretórios += 1
# 328 bytes para o cabeçalho do diretório e cada linha ocupa 257 bytes
espaço_desperdiçado += 4000 - dado.get_len_tabela() * 257 - 328
pilha.append(arquivo)
else:
quantidade_arquivos += 1
espaço_desperdiçado += 4000 - dado.get_tamanho(
) - 332 # 332 bytes para o cabeçalho do diretório
espaço_livre -= 4000
print('quantidade diretórios:', quantidade_diretórios)
print('quantidade arquivos:', quantidade_arquivos)
print('espaço livre:', espaço_livre)
print('espaço desperdiçado:',
espaço_desperdiçado) # 224 B desperdiçado nos metadados)
def test_get_informacao():
assert Dados('Python').get_insformacao(1, "name") is not None
from cortix.src.cortix_main import Cortix
from dados import Dados
'''
Cortix run file for DADOS using the IR-7040 gas ratemeter RS-232 interface.
'''
if __name__ == "__main__":
# Parameters
time_step = 0.1
cortix = Cortix(use_mpi=False)
# DADOS module.
dados = Dados()
# Port def.
rs232_port = Port('rs-232')
dados.add_port(rs232_port)
dados.rs232_filename = 'ir-7040'
dados.rs232_request_string = '\r\nP0001 01245689BCDMNVWYZaOdghin 55}'
# DataPlot module.
data_plot = DataPlot()
data_plot.title = 'IR-7040 Data Acquisition'
data_plot.dpi = 300
# Port def.
plot_port = Port('viz-data')
data_plot.add_port(plot_port)
# Network connectivity
def find(diretorio, arquivo):
if diretorio is None or arquivo is None:
print('find precisa de dois argumentos')
return
dados, caminho_destino, diretorio = pega_dados(diretorio)
if diretorio is not None:
if not dados.tem(diretorio):
print('Diretório não encontrado')
return
index = dados.get_entry(diretorio)
dados = Dados(bitmap, fat, index)
dados.carrega_cabeçalho(unidade)
if not dados.is_dir():
print('Não é um diretório')
return
dados.load(unidade)
find_recursive(dados, caminho_destino + [diretorio], arquivo)
else:
for nome_arquivo in dados.keys():
index = dados.get_entry(nome_arquivo)
a = Dados(bitmap, fat, index)
a.carrega_cabeçalho(unidade)
if a.is_dir():
a.load(unidade)
find_recursive(a, caminho_destino + [nome_arquivo], arquivo)
else:
if a.get_nome() == arquivo:
print(
'/' + '/'.join(caminho_destino) + '/' + arquivo if type(dados) is not Root else '/'.join(
caminho_destino) + '/' + arquivo)
bitmap.save(unidade)
fat.save(unidade)
root.save(unidade)
def test__name():
assert len(Dados("Python").get_informacao(1, "name")) > 1
else:
dado.setAnterior(self.topo)
self.topo = dado
return dado.getDado()
else:
raise Exception("Ops ocorreu um erro!")
def desempilha(self):
if self.estaVazia():
raise Exception("A pilha ja está vazia!")
else:
dado = self.topo
self.topo = dado.getAnterior()
dado1 = Dados(1)
dado2 = Dados(2)
dado3 = Dados(3)
p = Pilha(3)
p.empilha(dado1)
p.empilha(dado2)
p.empilha(dado3)
print(p.getTopo())
print(p.estaVazia()) #deve retornar false
print(p.estaCheia()) #deve retornar true
# p.empilha(dado3) deu erro entao ta certo
p.desempilha()
print(p.getTopo()) # funcionou
p.desempilha()
p.desempilha()
print(p.estaVazia()) #deve retornar true
def test_forks():
assert len(Dados("Python").get_informacao(1, "description")) > 1
