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 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 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(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 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
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