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']))