def main():
arquivo_transações = input("Entre com o arquivo de descrição das transações: ")
ger = Gerenciador(arquivo_transações)
sair = False
while not sair:
arquivo_história = input("Entre com o arquivo com a história das transações. Caso deseje inseri-las a"+
" partir do terminal, escreva \"stdin\": ")
arquivo_saída = input("Entre com o arquivo com a saída da execução da história. Caso deseje vê-la no"+
" terminal, escreva \"stdout\": ")
ger.executar(arquivo_história, arquivo_saída)
print("")
encerrar = input("Deseja sair? (s/n) ")
while (encerrar != "s" and encerrar != "n"):
encerrar = input("Deseja sair? (s/n) ")
if (encerrar == "s"):
sair = True
else:
sair = False
def main():
print("Algoritmos de escalonamento")
opcao = -1
while(opcao != '0'):
fila_processos = leitor("processos.txt")
gp = Gerenciador()
for processo in fila_processos:
bcp = BCP()
bcp.set_id(processo[0])
bcp.set_tempo_CPU(processo[1]) # setando os dados no bcp
bcp.set_prioridade(processo[2])
bcp.set_tempo_chegada(processo[3])
bcp.set_fila_io(processo[4:])
gp.add_fila_processos(bcp)
for i in gp.get_fila_processos():
#i.fila_IO = [int(k) for k in i.fila_IO]
print(i.get_id(), i.get_tempo_chegada(), i.get_fila_io(), i.get_tempo_CPU())
escalonador = Escalonador()
# limpa a tela no Windows ou Linux
os.system('cls' if os.name == 'nt' else 'clear')
print("Escalonadores")
print("[1] FIFO")
print("[2] SJF")
print("[3] Prioridade")
print("[4] Round Robin")
print("[0] Sair")
opcao = input(">> ")
if(opcao == '1'):
escalonador.fifo(gp)
if(opcao == '2'):
escalonador.sjf(gp)
if(opcao == '3'):
escalonador.prioridade(gp)
if(opcao == '4'):
escalonador.RoundRobin(gp)
print(escalonador.tempo_total())
'Tempo total {}'.format(escalonador.tempo_total())
def recomendacoes():
for i in pessoas:
for j in ativos:
recomenda = Gerenciador().indica_ativo(i, j)
if recomenda:
i.comprar(j)
i.verifica_saldo_final()
class Menu:
def __init__(self, tamanho_memoria):
self.gerenciador = Gerenciador(tamanho_memoria)
def criar(self):
id = int(input("Digite o id do processo: "))
tamanho = int(input("Digite o tamanho do processo: "))
print("Defina o tipo de estrategia [ 0 - First-Fit; 1 - Best-Fit; 2 - Worst-Fit ]")
estrategia = int(input("valor: "))
processo = Processo(id, tamanho, estrategia, None)
return self.gerenciador.criar_novo_processo(processo)
def deletar(self):
id = int(input("Digite o id do processo: "))
self.gerenciador.deletar_processo(id)
def imprimir(self):
self.gerenciador.imprimir_dump_memoria()
def main():
if len(sys.argv) != 5:
print(
'{} <num_clientes> <num_garçons> <capacidade_garçom> <num_rodadas>'
.format(sys.argv[0]))
exit(-1)
g = Gerenciador(
int(sys.argv[1]), # num clientes
int(sys.argv[2]), # num garçons
int(sys.argv[3]), # capacidade garçom
int(sys.argv[4]) # num rodadas
)
g.startGarcons()
g.startClientes()
g.start()
from gerenciador import Gerenciador gerenciador = Gerenciador() revisoes = gerenciador.revisoes recomendacoes = gerenciador.recomendacoes #criar o arquivo revicoes_processadas.pickle #print(len(revisoes)) #print(len(recomendacoes)) #testar o arquivo revisoes_processadas.pickle print(revisoes[0]) print(recomendacoes[0])
def __init__(self, tamanho_memoria): self.gerenciador = Gerenciador(tamanho_memoria)
from gerenciador import Gerenciador
from reutilizavel import Reutilizavel
from time import sleep
if __name__ == "__main__":
gerenciador: Gerenciador = Gerenciador(10)
sleep(5)
print("Cliente requisitando um objeto disponível no gerenciador...")
objeto_reusavel: Reutilizavel = gerenciador.adquirir()
print("Cliente está usando o objeto reutilizável...")
sleep(5)
print("Terminou de usar. Devolvendo ao gerenciador...")
gerenciador.adicionar(objeto_reusavel)
def main():
# Caminho onde se encontra o conjunto de dados
caminho = "dados/mock/" + dataset + "/" + dataset + dados + ".csv"
print(dataset)
print("Carregando os dados no caminho: {}".format(caminho))
# Cria um objeto do tipo gerenciador já inicializando os parametros necessários
gerenciador = Gerenciador(caminho)
# Numero de cluster para os algoritimos de clusterização de dados
num_cluster = numCluster
tsbirch = threshholdBirch
tsLeader = threshholdLeader
# Cria um df dos dados retirados do csv
gerenciador.inicia(num_cluster, tsbirch, tsLeader)
gerenciador.iniciaDataset(numPart)
gerenciador.iniciar(False)
while (gerenciador.executa):
gerenciador.novoDataStream(False)
# Salva os resultados
gerenciador.finalizador(dataset)
print("Labels MV")
print(gerenciador.marjorityvoting.labels)
print("Labels BoK")
print(gerenciador.bok.labels)
print("Labels BOEM")
print(gerenciador.boem.labels)
print("Labels BIRCH")
print(len(list(gerenciador.birch.labels)))
print("Labels K-Means")
print(list(gerenciador.simple_kmeans.labels))
print("Labels Leader")
print(gerenciador.leader.labels)
from gerenciador import Gerenciador
ger = Gerenciador.get_instance()
global opc
def main():
opc = -1
while opc != 3:
try:
opc = int(
input('Olá. O Que deseja fazer na Agência Nuvem Voadora?\n'
'1) Reservar Vôo \n'
'2) Ver dados da reserva \n'
'3) Sair \n'))
except ValueError:
print("Informe apenas um números inteiros.")
else:
if opc == 1:
fazer_reserva()
elif opc == 2:
visualizar_reserva()
elif opc == 3:
print(
'Obrigado por utilizar o Sistema Nuvem Voadora! \n Boa Viagem!'
)
else:
print("Informe um número válido.")
def fazer_reserva():
def main():
# obtenção de valores de configuração da estufa
incrementoTemp = obtemValores()
limitesAquecedor, limitesResfriador, limitesUmidade, limitesCO2 = obtemLimites(
)
#valores iniciais dos parâmetros da estufa
temperatura = 30
umidade = 35
decrementoUmid = 0.7
co2 = 400
decrementoCO2 = 0.8
incrementoAquec = 1.5
decrementoResf = 1.5
incrementoIrrig = 1.5
incrementoInj = 1.5
# porta utilizada nas comunicações entre componentes
porta = 65000
#declaração dos componentes
gerenciador = Gerenciador(8, '127.0.0.1', limitesAquecedor,
limitesResfriador, limitesUmidade, limitesCO2)
sensortemp = SensorTemperatura(1, temperatura, incrementoTemp, (
gerenciador.host,
porta,
))
sensorumid = SensorUmidade(2, umidade, decrementoUmid, (
gerenciador.host,
porta,
))
sensorco2 = SensorCO2(3, co2, decrementoCO2, (
gerenciador.host,
porta,
))
aquecedor = Aquecedor(4, incrementoAquec, (
gerenciador.host,
porta,
))
resfriador = Resfriador(5, decrementoResf, (
gerenciador.host,
porta,
))
irrigador = Irrigador(6, incrementoIrrig, (
gerenciador.host,
porta,
))
injetor = InjetorCO2(7, incrementoInj, (
gerenciador.host,
porta,
))
cliente = Cliente((
gerenciador.host,
porta,
))
#fila de valores dos parametros da estufa
#usada para compartilhar os valores entre diferentes processos
temperaturas = SimpleQueue()
umidades = SimpleQueue()
co2 = SimpleQueue()
#locks para garantir a correta atualização dos valores entre processos
atualizandoTemp = Lock()
atualizandoUmid = Lock()
atualizandoCO2 = Lock()
#permite iniciar os componentes somente quando o gerenciador (servidor) estiver pronto
gerenciadorPronto = Event()
#permite encerrar a aplicação quando solicitado
encerraApp = Event()
#declaração dos processos
processoGerenciador = Process(target=gerenciador.processaSocket,
args=(
porta,
gerenciadorPronto,
))
processoSensorTemp = Process(target=sensortemp.iniciaThreads,
args=(
temperaturas,
atualizandoTemp,
))
processoSensorUmid = Process(target=sensorumid.iniciaThreads,
args=(
umidades,
atualizandoUmid,
))
processoSensorCO2 = Process(target=sensorco2.iniciaThreads,
args=(
co2,
atualizandoCO2,
))
processoAquecedor = Process(target=aquecedor.iniciaThreads,
args=(
temperaturas,
atualizandoTemp,
))
processoResfriador = Process(target=resfriador.iniciaThreads,
args=(
temperaturas,
atualizandoTemp,
))
processoIrrigador = Process(target=irrigador.iniciaThreads,
args=(
umidades,
atualizandoUmid,
))
processoInjetor = Process(target=injetor.iniciaThreads,
args=(
co2,
atualizandoCO2,
))
threadCliente = Thread(target=cliente.iniciaThreads, args=(encerraApp, ))
#inicia o gerenciador e aguarda até que ele esteja pronto para receber conexões
processoGerenciador.start()
gerenciadorPronto.wait()
# inicia os outros processos
processoSensorTemp.start()
processoSensorUmid.start()
processoSensorCO2.start()
processoAquecedor.start()
processoResfriador.start()
processoIrrigador.start()
processoInjetor.start()
threadCliente.start()
# aguarda a sinalização de encerrar a aplicação
encerraApp.wait()
# finaliza os processos
processoSensorTemp.terminate()
processoAquecedor.terminate()
processoResfriador.terminate()
processoSensorUmid.terminate()
processoIrrigador.terminate()
processoSensorCO2.terminate()
processoInjetor.terminate()
processoGerenciador.terminate()