def main():
"""Tratamento para caso de ser informado um arquivo de saida
Insere um elemento a mais na lista ARGV, dessa forma garantindo que exista um elemento na posição 2 e este será usado como arquivo de saia.
"""
sys.argv.append(sys.argv[1][:-3] + 'afn')
automato_fz = Arquivo.abrir_automato(sys.argv[1])
if automato_fz is not None:
automato_fn = afz2afn(automato_fz)
Arquivo.salva_automato(sys.argv[2], automato_fn)
else:
print("Erro ao abrir o arquivo " + sys.argv[1])
print("Processo Abortado.")
return 0
def __init__(sell, txt1, txt2):
reading_files = Arquivo.Arquivo(txt1, txt2)
sell.e_inicial = reading_files.e_inicial
sell.e_final = reading_files.e_final
sell.simbolo_branco = reading_files.simbol_branco
sell.i_fita = reading_files.i_fita
sell.transicaol = reading_files.transicaol
sell.entrada = reading_files.entrada
def main():
"""Tratamento para caso de ser informado um arquivo de saida
Insere um elemento a mais na lista ARGV, dessa forma garantindo que exista um elemento na posição 2 e este será usado como arquivo de saia.
"""
sys.argv.append(sys.argv[1][:-3] + 'dot')
print("Carregando automato")
automato = Arquivo.abrir_automato(sys.argv[1])
if automato is not None:
print("Convertendo para .dot")
dot = af2dot(automato)
Arquivo.escrever(sys.argv[2], dot)
else:
print("Erro ao abrir o arquivo " + sys.argv[1])
print("Processo Abortado.")
return
def lerMascara(caminho):
mascArquivo = Arquivo.lerAquivo(caminho)
m, n = [int(x) for x in mascArquivo[0].split()]
dados = mascArquivo[1:len(mascArquivo)]
mascara = Matriz.gerarMatriz(m, n)
for i in range(0, m):
for j in range(0, n):
index = j + (i * m)
mascara[i][j] = int(dados[index])
return (mascara, m, n)
def main():
print("Carregando automato")
automato_fz = Arquivo.abrir_automato(sys.argv[1])
if automato_fz is not None:
automato_fd = afz2afd(automato_fz)
if verifica_palavra(automato_fd, sys.argv[2]):
print("ACEITA")
else:
print("REJEITADA")
else:
print("Erro ao abrir o arquivo " + sys.argv[1])
print("Processo Abortado.")
return
def load_and_preprocess_data():
data = Arquivo.ler()
x, y = Padronizar.dividir(data, 60, 12)
minmaxscaler = MinMaxScaler(feature_range=(0, 1))
dataNX, listMin, listMax = Padronizar.normalizarLinear(x, 0.1, 0.9)
dataNY, listMin1, listMax2 = Padronizar.normalizarLinear(y, 0.1, 0.9)
X_train, X_test, y_train, y_test = train_test_split(dataNX,
dataNY,
train_size=0.8,
test_size=0.2)
X_train = X_train.values
X_test = X_test.values
# WE WILL USE ONLY THE FIRST COLUMN
y_train = y_train[y_train.columns[0]].values
y_test = y_test[y_test.columns[0]].values
# X_train = 1.0 * X_train / 255
# X_test = 1.0 * X_test / 255
return add_bias(X_train), y_train, add_bias(X_test), y_test
Esse arquivo, irá ter a função similar do int main()
'''
import os, sys, Compactador, Descompactador, Arquivo
# pega os argumentos
if len(sys.argv) < 3:
print("Número de argumentos inválido")
else:
caminho = sys.argv[2]
# faz o compactador
if sys.argv[1] == '-c':
leitor = Arquivo.Arquivo(caminho, "rb")
gravador = Arquivo.Arquivo(caminho + ".cmp", "w+b")
Compactador.Compactador(leitor, gravador).compactar()
print("Compactado com sucesso!")
elif sys.argv[1] == '-d':
leitor = Arquivo.Arquivo(caminho, "rb")
gravador = Arquivo.Arquivo(caminho[0:len(caminho) - 4], "w")
Descompactador.Descompactador(leitor, gravador).descompactar()
print("Descompactado com sucesso!")
else:
print("parâmetro inválido!")
peso = sum([sum(linha) for linha in mascara])
a = int((m - 1) / 2)
b = int((n - 1) / 2)
largura = lar - (a * 2)
altura = alt - (b * 2)
aux = Matriz.gerarMatriz(largura, altura)
for i in range(0, lar):
for j in range(0, alt):
if (i - a >= 0 and j - b >= 0 and i + a < lar and j + b < alt):
for s in range(-a, a + 1):
for t in range(-b, b + 1):
aux[i -
a][j -
b] += mascara[a + s][b + t] * matriz[i + s][j +
t]
aux[i - a][j - b] = round(aux[i - a][j - b] / peso)
return (aux, largura, altura)
caminho = input('Digite o caminho do arquivo: ')
lista = Arquivo.lerAquivo(caminho)
matriz, largura, altura = Matriz.transformarEmMatriz(lista)
matriz, largura, altura = aplicarMedia(matriz, largura, altura)
ppm = Matriz.formatoPPM(matriz, largura, altura)
nome = input('Salvar como: ')
Arquivo.salvarArquivo(nome, ppm)
def __init__(self, interface = None, arquivo_entrada = None, arquivo_saida = None): self.arquivo_entrada = arquivo_entrada self.arquivo_saida = arquivo_saida self.arquivo = Arquivo( self.arquivo_entrada, self.arquivo_saida ) #estancia da classe Arquivo self.grafo = None self.interface = interface
class Main(object):
#construtor da classe, recebe como parametro os arquivos de entrada e saida
def __init__(self, interface = None, arquivo_entrada = None, arquivo_saida = None):
self.arquivo_entrada = arquivo_entrada
self.arquivo_saida = arquivo_saida
self.arquivo = Arquivo( self.arquivo_entrada, self.arquivo_saida ) #estancia da classe Arquivo
self.grafo = None
self.interface = interface
#funcao que que valida os arquivos de entrada e saida
def validar_arquivo(self):
try:
# Abro os aqruivos para garantir que não estão corrompidos
e = open(self.arquivo_entrada, "r")
s = open(self.arquivo_saida, "w")
#verifica se existe conteudo no arquivo de entrada
if len(e.readline()) == 0:
raise IOError
#tratando os erros
except IOError:
# os.system("cls")
print("\nArquivos de entradas invalidos ou corrompidos")
sys.exit(0)
#chama o metodo que ler os dados do arquivo de entrada
def tratar_dados_de_entrada(self):
return self.arquivo.ler_entrada()
#chama o metodo que vai gravar as respostas no arquivo de saida
def grava_resposta_arquivo(self, algoritmo, resposta):
return self.arquivo.grava_saida(algoritmo, resposta)
# #monta a lista de adjacencia
def monta_grafo(self, dados_do_grafo):
if len(dados_do_grafo) > 0:
self.grafo = Grafo(dados_do_grafo) #instancia da classe Grafo
self.grafo.cria_lista_adjacencia() #metodo que cria a lista de adjacencia
return True
else:
return False
#Executa algoritmo que calcula a distancia de um determinado caminho
def calcula_distancia(self, caminho, requisicao = False):
lista_caminho = list(caminho) #copia a lista de caminho para lista_caminho
result = self.grafo.calcula_distancia(caminho)
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Calcula distancia - [ ERROR ]')
else:
dados = {"caminho": lista_caminho, "distancia": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("distancia", dados)
if resposta != False:
self.interface.lista_respostas.append('Calcula distancia - [ OK ]')
def busca_largura(self, lista, requisicao = False):
vertices = list(lista)
result = self.grafo.busca_em_largura( lista[0], lista[1] )
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Busca em largura - [ ERROR ]')
else:
dados = {"vertices": vertices, "resposta": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("largura", dados)
if resposta != False:
self.interface.lista_respostas.append('Busca em largura - [ OK ]')
def busca_profundidade(self, lista, requisicao = False):
vertices = list(lista)
result = self.grafo.busca_em_profundidade( lista[0], lista[1] )
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Busca em profundidade - [ ERROR ]')
else:
dados = {"vertices": vertices, "resposta": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("profundidade", dados)
if resposta != False:
self.interface.lista_respostas.append('Busca em profundidade - [ OK ]')
def menor_caminho(self, origem, destino, requisicao = False):
result = self.grafo.dijkstra(origem, destino)
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Busca menor caminho (DIJKSTRA) - [ ERROR ]')
else:
dados = {"vertices": [origem, destino], "resposta": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("menorcaminho", dados)
if resposta != False:
self.interface.lista_respostas.append('Busca menor caminho (DIJKSTRA) - [ OK ]')
def gerar_prim(self, origem, requisicao = False):
result = self.grafo.prim( origem )
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Prim - [ ERROR ]')
else:
dados = {"vertices": origem, "resposta": result}
if requisicao == True:
return dados
else:
print(dados)
resposta = self.grava_resposta_arquivo("prim", dados)
if resposta != False:
self.interface.lista_respostas.append('Prim - [ OK ]')
#executa a lista de comandos do arquivo de entrada
def executa_comandos(self, comandos):
for i in comandos:
self.chama_funcoes(i)
print("Executando...")
def chama_funcoes(self, comando, requisicao = False):
if (requisicao == True):
if comando['algoritmo'].lower() == "distancia":
return self.calcula_distancia(comando['lista'], True)
if comando['algoritmo'].lower() == "largura":
return self.busca_largura(comando['lista'], True)
if comando['algoritmo'].lower() == "profundidade":
return self.busca_profundidade(comando['lista'], True)
if comando['algoritmo'].lower() == "menorcaminho":
return self.menor_caminho(comando['lista'][0], comando['lista'][1], True)
if comando['algoritmo'].lower() == "prim":
return self.gerar_prim(comando['lista'][0], True)
else:
if comando['algoritmo'].lower() == "distancia":
return self.calcula_distancia(comando['lista'])
if comando['algoritmo'].lower() == "largura":
return self.busca_largura(comando['lista'])
if comando['algoritmo'].lower() == "profundidade":
return self.busca_profundidade(comando['lista'])
if comando['algoritmo'].lower() == "menorcaminho":
return self.menor_caminho(comando['lista'][0], comando['lista'][1])
if comando['algoritmo'].lower() == "prim":
return self.gerar_prim(comando['lista'][0])
if comando == 1:
Nome_Documento.append(str(input(
"\nQual o nome do arquivo?\n="))) # exemplo de entrada = doc1.txt
elif comando == 2:
flag = 1
elif comando != 2 and comando != 1:
print("\nDigite Novamente.\n")
if len(Nome_Documento) == 0: # caso o usuário nao insira nenhum arquivo
sys.exit() # sair do programa
for NomeArq in Nome_Documento: # percorre a Lista Nome_Documento
string.append(
arq.OpenFile(NomeArq, contador)
) # le todos os documentos recebidos e joga em uma lista chamada string
contador = contador + 1
C = int(input("Qual o valor de C")) # valor da Variavel C
if C == 0:
print(
"\nComo o valor mínimo que ser pode assumir é 1, então o C=0 será transformado para C=1\n"
)
C = 1
for i in range(0, len(string)):
Dict[Nome_Documento[i]] = arq.CriaDict(
string[i], C
) # o arq.Criadicionario é responsavel por criar um dicionario que vai ser atribuido a outro dicionario {'Nome_Documento':{'palavra':Ocorrencias}}
import Arquivo as arq
import principal
import nucleoSpacy as ns
import funcaoGramatical
frase = 'O pensamento tem muito poder, muitas vezes aquilo que pensamos pode se realizar.'
media = 0
ml = principal.Invoke(frase)
tpn = ns.TipoNucleo(ns.RetornNucleo(frase))
fg = funcaoGramatical.Morfologia(frase)
if ml == 'B':
media = 1
if tpn == 'B':
media = media + 1
if fg == 'B':
media = media + 1
fileName = '../Data/leandro.csv'
array = [media, ml, tpn, fg]
cabecalho = 'Media,MAchineLearing,Classificação Nucleo, Função gramatical'
# Gerar Arquico
arq.GerarArquivoCSV(fileName, array, cabecalho)
import Interface
import Arquivo
from time import sleep
nome_arquivo = 'exerciciofinal115.txt'
if not Arquivo.arquivoExiste(nome_arquivo):
Arquivo.criarArquivo(nome_arquivo)
while True:
resposta = Interface.menu([
'Ver pessoas cadastradas', 'Cadastrar nova pessoa', 'Sair do sistema'
])
if resposta == 1:
# Opção de listar um conteúdo do arqu1ivo
Arquivo.lerArquivo(nome_arquivo)
elif resposta == 2:
# Cadastrar uma nova pessoa
Interface.cabeçalho('NOVO CADASTRO')
nome = input('Nome completo: ')
idade = Interface.leiaInt('Idade: ')
Arquivo.cadastrar(nome_arquivo, nome, idade)
elif resposta == 3:
# Opção par sair do sistema
print('Saindo do sistema... Até logo!')
break
else:
print('\033[31mERRO! Digite uma opção válida!\033[m')
def __init__(self, arquivo_entrada, arquivo_saida): self.arquivo_entrada = arquivo_entrada self.arquivo_saida = arquivo_saida self.arquivo = Arquivo( self.arquivo_entrada, self.arquivo_saida ) #estancia da classe Arquivo self.grafo = None
class Main:
#construtor da classe, recebe como parametro os arquivos de entrada e saida
def __init__(self, arquivo_entrada, arquivo_saida):
self.arquivo_entrada = arquivo_entrada
self.arquivo_saida = arquivo_saida
self.arquivo = Arquivo( self.arquivo_entrada, self.arquivo_saida ) #estancia da classe Arquivo
self.grafo = None
#funcao que que valida os arquivos de entrada e saida
def validar_arquivo(self):
try:
# Abro os aqruivos para garantir que não estão corrompidos
e = open(self.arquivo_entrada, "r")
s = open(self.arquivo_saida, "w")
#verifica se existe conteudo no arquivo de entrada
if len(e.readline()) == 0:
raise Erros #lancando erro
#tratando os erros
except IOError:
os.system("cls")
print("\nArquivos de entradas invalidos ou corrompidos")
sys.exit(0)
except Erros as E:
os.system("cls")
print(E.arquivo_vazio())
sys.exit(0)
#chama o metodo que ler os dados do arquivo de entrada
def tratar_dados_de_entrada(self):
return self.arquivo.ler_entrada()
#chama o metodo que vai gravar as respostas no arquivo de saida
def grava_resposta_arquivo(self, algoritmo, resposta):
return self.arquivo.grava_saida(algoritmo, resposta)
#monta a lista de adjacencia
def monta_grafo(self, dados):
self.grafo = Grafo(dados) #instancia da classe Grafo
self.grafo.cria_lista_adjacencia() #metodo que cria a lista de adjacencia
#Executa algoritmo que calcula a distancia de um determinado caminho
def calcula_distancia(self, caminho):
lista_caminho = list(caminho) #copia a lista de caminho para lista_caminho
result = self.grafo.calcula_distancia(caminho)
if result == None:
print("Caminho Invalido")
else:
dados = {"caminho": lista_caminho, "distancia": result}
resposta = self.grava_resposta_arquivo("distancia", dados)
if resposta != False:
#time.sleep( 1 )
print("Calcula distancia - [ OK ]")
#executa o algoritmo que encontra uma rota entre 2 vertices
def encontra_caminho(self, v_origem, v_destino):
result = self.grafo.encontra_caminho( v_origem, v_destino )
if result == None:
print("Caminho Invalido")
else:
self.grava_resposta_arquivo("caminho", result)
def busca_largura(self, lista):
vertices = list(lista)
result = self.grafo.busca_em_largura( lista[0], lista[1] )
if result == None:
print("Caminho Invalido")
else:
dados = {"vertices": vertices, "resposta": result}
resposta = self.grava_resposta_arquivo("largura", dados)
if resposta != False:
#time.sleep( 1 )
print("Busca em largura - [ OK ]")
def busca_profundidade(self, lista):
vertices = list(lista)
result = self.grafo.busca_em_profundidade( lista[0], lista[1] )
if result == None:
print("Caminho Invalido")
else:
dados = {"vertices": vertices, "resposta": result}
resposta = self.grava_resposta_arquivo("profundidade", dados)
if resposta != False:
#time.sleep( 1 )
print("Busca em profundidade - [ OK ]")
def dijkstra(self, origem, destino):
self.grafo.dijkstra(origem, destino)
#executa a lista de comandos do arquivo de entrada
def executa_comandos(self, comandos):
os.system("cls")
print ("\nExecutando algoritmos: \n")
for i in comandos:
self.chama_funcoes(i)
print("\nArquivo de saida criado com sucesso")
def chama_funcoes(self, comando):
if comando['algoritmo'].lower() == "distancia":
self.calcula_distancia(comando['lista'])
if comando['algoritmo'].lower() == "largura":
self.busca_largura(comando['lista'])
if comando['algoritmo'].lower() == "profundidade":
self.busca_profundidade(comando['lista'])
