def copy_folder(path_origem: str, path_destino: str, replace=True) -> bool: """ Faz a copia de uma pasta e todas subpastas e arquivos :param str path_origem: Caminho onde o folder se encontra. :param str path_destino: Caminho para onde o folder sera copiado. :param bool replace: Flag para fazer substituicao da pasta e conteudo :return: se o arquivo foi copiado com sucesso ou teve erro :rtype: bool """ if replace: if os.path.isdir(path_destino): Loggin().log( texto=f'Apagando pasta {path_destino} para substituicao') shutil.rmtree(path_destino) try: Loggin().log( texto=f'Copiando conteudo {path_origem} para {path_destino}') shutil.copytree(path_origem, path_destino) Loggin().log(texto=f'Pasta {path_destino} gerada com sucesso') return True except Exception as ex: Loggin().log( tipo=EnumLogStatus.ERRO_FATAL, arquivo=__name__, texto= f'Folder [{path_origem}] NÃO copiado com sucesso para [{path_destino}].', info_ex=str(ex)) return False
def _evaluate(self, x, out, *args, **kwargs): if len(kwargs) == 0: return iteracao_max = max(list(self._solucoes.solucoes)) iteracao_atual = iteracao_max + 1 id = max(list(self._solucoes.solucoes[iteracao_max])) + 1 Loggin().log(arquivo=__name__, tipo=EnumLogStatus.INFO, texto=f"Inicializando o Calculo para geração [{iteracao_atual}]") solucao_base: Solucao = self._contexto.get_atributo(EnumAtributo.SOLUCAO_BASE) for ii in range(x.shape[0]): solucao_nova = Solucao(id, iteracao_atual, solucao_base) id += 1 variavies = solucao_base.get_variavies_by_tipo() jj = 0 for variavel in variavies: try: solucao_nova.variaveis.get_variavel_by_nome(variavel).posicao = int(x[ii][jj]) except ValueError as ex: Loggin().log(arquivo=__name__, texto="Valor for do limite", info_ex=str(ex)) jj += 1 solucao_nova.geral = f'[{self._otimizador}]' self._solucoes.add_in_solucoes(solucao_nova) self._contexto.set_atributo(EnumAtributo.SOLUCOES, self._solucoes, True) self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, [iteracao_atual], True) Loggin().log(arquivo=__name__, tipo=EnumLogStatus.INFO, texto=f"Iniciando avaliação.") avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO) self._contexto = avaliacao.run(self._contexto) self._solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES) f1 = np.zeros((len(self._solucoes.solucoes[iteracao_atual]), self._n_obj)) g1 = np.zeros((len(self._solucoes.solucoes[iteracao_atual]), self._n_obj)) for ii in self._solucoes.solucoes[iteracao_atual]: try: posicao = ii - list(self._solucoes.solucoes[iteracao_atual])[0] n_of = 0 for nome_of in sorted(self._nomes_direcoes_of): # para minimizar precisa ser -1 o valor padrão. direcao_of_valor = 1 if EnumValues.MIN.name in self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]: direcao_of_valor = -1 if self._solucoes.solucoes[iteracao_atual][ii].has_erro is None: f1[posicao][n_of] = -1 * self._solucoes.solucoes[iteracao_atual][ii].of[nome_of].valor * direcao_of_valor g1[posicao][n_of] = -1 * self._solucoes.solucoes[iteracao_atual][ii].of[nome_of].valor * direcao_of_valor else: f1[posicao][n_of] = -1 * Solucao.of_padrao(self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]) g1[posicao][n_of] = -1 * Solucao.of_padrao(self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]) n_of += 1 except Exception as ex: Loggin().log(arquivo=__name__, tipo=EnumLogStatus.ERRO, texto=f"Não foi possivel ler of da solucao [{ii}] geracao [{iteracao_atual}].") out["F"] = f1 out["G"] = g1 self._salvar()
def _carregar_contexto(self): try: path_resume = InOut().ajuste_path('\\'.join([ self._contexto.get_atributo(EnumAtributo.PATH_PROJETO), self._contexto.get_atributo( EnumAtributo.INICIALIZACAO_RESUME_PATH) ])) with open(path_resume, 'rb') as file: contexto_resume = pickle.load(file) Loggin.set_arquivo_log(self._contexto.arquivo_log) contexto_resume.set_arquivo_log(self._contexto.arquivo_log) contexto_resume.set_atributo( EnumAtributo.PATH_PROJETO, self._contexto.get_atributo(EnumAtributo.PATH_PROJETO), True) contexto_resume.set_atributo( EnumAtributo.PATH_CONFIGURACAO, self._contexto.get_atributo(EnumAtributo.PATH_CONFIGURACAO), True) contexto_resume.set_atributo( EnumAtributo.PATH_LOG, self._contexto.get_atributo(EnumAtributo.PATH_LOG), True) return contexto_resume except Exception as ex: self.log(tipo=EnumLogStatus.ERRO_FATAL, texto='Erro ao carregar arquivo de resume', info_ex=str(ex))
def copy_file(path_origem: str, path_destino: str, replace=True) -> bool: """ Faz a copia de um arquivo para outro lugar, fazendo a checagem se existe diretorio e criando se não existir :param str path_origem: Caminho onde o arquivo se encontra. :param str path_destino: Caminho para onde o arquivo sera comiado. :return: se o arquivo foi copiado com sucesso ou teve erro :rtype: bool """ try: if not Copy.criar_arquivos(path_destino): return False try: if not replace: if os.path.isfile(path_destino): Loggin().log( arquivo=__name__, texto= f'Arquivo [{path_destino}] já existente. Arquivo não foi copiado.' ) return False shutil.copy(path_origem, path_destino) Loggin().log( arquivo=__name__, texto= f'Arquivo [{path_origem}] copiado com sucesso para [{path_destino}].' ) except Exception as ex: Loggin().log( tipo=EnumLogStatus.ERRO, arquivo=__name__, texto= f'Arquivo [{path_origem}] NÃO copiado com sucesso para [{path_destino}].', info_ex=str(ex)) return False return True except Exception as ex: Loggin().log( arquivo=__name__, tipo=EnumLogStatus.ERRO_FATAL, texto= f'Não foi possível copiar aquivo de [{path_origem}] para [{path_destino}].', info_ex=str(ex)) return False
def LogarMemoria(contexto): """ Método que libera memória e retorna a quantidade de memória usada. :param contexto: :type contexto: :return: Quantidade de mem�ria usada :rtype: int """ memoria_usada = 0 try: LiberarMemoria() pid = os.getpid() p = psutil.Process(pid) memorias = (p.memory_info()) memoria_usada = int(memorias.rss / 1000000) n_solucoes = 0 if contexto.tem_atributo(EnumAtributo.SOLUCOES): solucoes = contexto.get_atributo(EnumAtributo.SOLUCOES) if solucoes is not None: for it in solucoes.solucoes: n_solucoes += len(solucoes.solucoes[it]) Loggin().log(texto=f'Quantilidade de solucao = {n_solucoes}') Loggin().log(texto=f'Memoria usada [{memoria_usada}Mb]') path_arquivo = f'{contexto.get_atributo(EnumAtributo.PATH_PROJETO)}/memoria_info.csv' if int(n_solucoes) == 0: try: os.remove(path_arquivo) Loggin().log(texto=f'Removido o arquivo {arquivo_remover}') except Exception as ex: pass conteudo = f'solucoes;memoria_usada[Mb];Mb/solucao\n{n_solucoes};{memoria_usada};inf\n' TXT().salvar(path_arquivo, conteudo, '+a') else: TXT().salvar( path_arquivo, f'{n_solucoes};{memoria_usada};{memoria_usada/(n_solucoes)}\n', '+a') except Exception as ex: Loggin().log(tipo=EnumLogStatus.WARN, texto='Erro ao logar memoria', info_ex=str(ex)) finally: return memoria_usada
def criar_arquivos(path_file: str) -> bool: """ Criar toda estrutura de arquivo para depois fazer a copia do arquivo. :param str path_file: Deve ser o caminho do arquivo, com o nome do arquivo junto. :return: Se tudo correu ok :rtype: bool """ test_path = "" try: barra = '/' inicio = '/' if platform.system().upper() == "WINDOWS": barra = '\\' inicio = '' path_aux = path_file.split(barra) for pp in range(len(path_aux) - 1): if path_aux[pp] == "": continue if test_path == "": test_path = InOut.ajuste_path(f'{inicio}{path_aux[pp]}') else: test_path = InOut.ajuste_path( f'{test_path}{barra}{path_aux[pp]}') if not os.path.isdir(test_path): Loggin().log(arquivo=__name__, tipo=EnumLogStatus.WARN, texto=f'Caminho {test_path} não existe.') os.mkdir(test_path) Loggin().log( arquivo=__name__, tipo=EnumLogStatus.WARN, texto=f'Caminho {test_path} foi criado com sucesso.') return True except Exception as ex: Loggin().log(arquivo=__name__, tipo=EnumLogStatus.ERRO_FATAL, texto=f'Não foi possível diretorios [{test_path}].', info_ex=str(ex)) return False
def __init__(self, path_projeto: str, path_config: str, modules: list): """ Chama a função de leitura das informações nor arquivo de configura no caminho path_configuracao :param str path_projeto: O caminho referente a raiz do projeto :param str arquivo_config: Caminho para o arquivo de configuracao """ super().__init__() self._name = __name__ # variável com nome do arquivo path_projeto = TXT().ajuste_path(path_projeto) path_config = TXT().ajuste_path(path_projeto + '/' + path_config) if not TXT().diretorio_existe(path_projeto): self.log(tipo=EnumLogStatus.ERRO_FATAL, texto=f"Diretorio [{path_projeto}] não existe.") if not TXT().arquivo_existe(path_config): self.log( tipo=EnumLogStatus.ERRO_FATAL, texto=f"O arquivo de configuracao [{path_config}] não existe.") path_log = TXT().ajuste_path(f'{path_projeto}/log.out') Loggin.set_arquivo_log(path_log) self.log(texto="[INICIO_TARDIS] - Iniciando Carregamento.") self._contexto = Contexto() self._contexto.set_atributo(EnumAtributo.PATH_PROJETO, [path_projeto]) self._contexto.set_atributo(EnumAtributo.PATH_CONFIGURACAO, [path_config]) self._contexto.set_atributo(EnumAtributo.PATH_LOG, [path_log]) try: self._carregar_informacao(modules) self._contexto.set_defaults() self._valida_contexto() except Exception as ex: self.log(texto="Erro para configurar valores defaults", info_ex=str(ex), tipo=EnumLogStatus.ERRO_FATAL)
def diretorio_existe(path_: str) -> bool: """ Verificar se o arquivo existe :param str path_: Verifica se o arquivo existe :return: Devolve bool informando se o arquivo existe :rtype: bool """ if not os.path.isdir(path_): Loggin().log(tipo=EnumLogStatus.ERRO, texto=f"{path_} diretorio nao existe.") return False return True
import tests.utilitarios.PathsFiles as paths_files from src.loggin.Loggin import Loggin from src.inout.InOut import InOut import platform inout = InOut() Loggin().set_arquivo_log(paths_files.path_arquivo_log()) def test_ajuste_barras(): path_desajustado = '..\\\\mocks/exemplo.txt' path_win = '..\\mocks\\exemplo.txt' path_lin = '../mocks/exemplo.txt' if platform.system().upper() == "WINDOWS": assert inout.ajuste_path(path_desajustado) == path_win else: assert inout.ajuste_path(path_desajustado) == path_lin def test_de_existencia_de_arquivo(): assert inout.arquivo_existe(paths_files.path_arquivo_exemplo()) == True def test_de_nao_existencia_de_arquivo(): path_mocks = paths_files.path_mocks() path_arquivo_inexistente = inout.ajuste_path('\\'.join( [path_mocks, 'arquivo_inexistente.txt']))