def __init__(self, voice):
"""
init class
create database, modules (submodules) and console (in/out) object
Args:
voice (bool): enable or desable speech -- true (enable)
"""
self._db = DB()
self._modules = Modules()
self._console = Console(stop=self.stop, voice=voice)
self._on = True
self._user_input = ''
self._functionality = {}
def mostrar_tabela(self):
Console.quebrar_linha(2)
n = '\033[0;0m'
if self.fatias_executadas < 27:
tamanho_da_fatia_em_tela = 3 * ' '
elif self.fatias_executadas < 43:
tamanho_da_fatia_em_tela = 2 * ' '
else:
tamanho_da_fatia_em_tela = 1 * ' '
for processo in self.processos:
Console.mostrar(f'{processo.nome} -> ', n=n, t=' ')
for estado in processo.historico:
representacao = f'{CORES[estado]}{tamanho_da_fatia_em_tela}'
Console.mostrar(f'|{representacao}', n=n, t='')
Console.quebrar_linha(2)
class CAV(object):
"""
class master
control of the entire program flow
Attrs:
db (object): database manager
modules (object): resource module
console (object): handle input and output
on (bool): running -- true
user_input (str): user input in the round
"""
def __init__(self, voice):
"""
init class
create database, modules (submodules) and console (in/out) object
Args:
voice (bool): enable or desable speech -- true (enable)
"""
self._db = DB()
self._modules = Modules()
self._console = Console(stop=self.stop, voice=voice)
self._on = True
self._user_input = ''
self._functionality = {}
def run(self):
"""
execution flow
- get user input
- find functionality
- run functionality
"""
self._user_input = self._console.get('How can I help you?').lower()
self._functionality = self.find_functionality()
if not self._functionality:
self._console.show('Sorry I do not understand', type_msg='error')
return
for keyword in self._functionality['keywords_found']:
self._user_input = self._user_input.replace(keyword['value'], '')
if self._functionality['value'] == 'calculate':
self.calculate()
elif self._functionality['value'] == 'open_program':
self.open_program()
else:
self._console.show('Sorry, something went wrong...',
type_msg='error')
def calculate(self):
"""
calculate skill
- clear user input
- run calculator
- show result
"""
expression = self._modules.calculator.remove_unwanted_characters(
self._user_input)
result = self._modules.calculator.run(expression)
self._console.show(f'The result is {result}!')
def open_program(self):
"""
open program skill
- get all programs in database
- find correct program
- remove program from user input
- get all parameters
- run program with params
"""
columns = ['id', 'nickname', 'value']
sql_code = self._db.select('programs', columns=columns)
all_programs = self._db.run(sql_code, columns=columns)
program = self._modules.open_program.find_program(
self._user_input, programs_bd=all_programs)
if not program:
self._console.show('Program not found', type_msg='error')
return
self._user_input = self._user_input.replace(program, '')
sql_code = self._db.select('parameters', columns=columns)
all_parameters = self._db.run(sql_code, columns=columns)
parameters = self._modules.open_program.find_params(
self._user_input, parameters_bd=all_parameters)
self._modules.open_program.run(program, parameters)
def find_functionality(self):
columns = ['id', 'value', 'id_function']
sql_code = self._db.select('keywords', columns=columns)
keywords = self._db.run(sql_code, columns=columns)
columns = ['id', 'value']
sql_code = self._db.select('functions', columns=columns)
functionalities = self._db.run(sql_code, columns=columns)
functionality = self._modules.check.correct_functionality(
self._user_input,
keywords=keywords,
functionalities=functionalities)
return functionality
def stop(self):
print('Bye Bye')
self._on = False
exit()
# -*- coding: utf-8 -*-
import re
import sys
import uuid
import telebot
from telebot import types
from app.dict import *
import pymysql
from app.console import Console
from app.sett import Settings as sett
console = Console(sys.argv)
console.canRun()
bot = telebot.TeleBot(sett.BOT_KEY)
con = pymysql.connect(sett.HOST_NAME, sett.USER_NAME, sett.USER_PASS,
sett.SQL_NAME)
cur = con.cursor()
@bot.message_handler(commands=['start'])
def welcome_message(message):
bot.send_message(message.from_user.id, WELCOME_TEXT)
user_id = message.from_user.id
cur.execute(f"SELECT COUNT(user_id) FROM users WHERE user_id = {user_id}")
is_exist = cur.fetchone()[0]
print(1)
if is_exist == 0:
print(1)
bank = 0.0
def mostrar_resultados(self):
media_de_espera = 0
media_em_memoria = 0
for processo in self.processos:
fatias_gastas = len(processo.historico)
fatias_gastas_em_memoria = fatias_gastas - processo.inicio
fatias_em_espera = fatias_gastas_em_memoria - processo.fatias
media_de_espera += fatias_em_espera
media_em_memoria += fatias_gastas_em_memoria
Console.quebrar_linha(2)
Console.mostrar(f'Resultados do processo {processo.nome}')
Console.adicionar_separador(13)
Console.mostrar(f'Tempo de espera -> {fatias_em_espera}')
Console.mostrar(f'Tempo de execução -> {fatias_gastas_em_memoria}')
Console.adicionar_separador(13)
quantidade_de_processos = len(self.processos)
media_de_espera /= quantidade_de_processos
media_em_memoria /= quantidade_de_processos
Console.quebrar_linha(2)
Console.adicionar_separador(19)
Console.mostrar(
f'Tempo médio de espera -> {media_de_espera :.2f} fatias')
Console.mostrar(
f'Tempo médio de execução -> {media_em_memoria :.2f} fatias')
Console.adicionar_separador(19)
def mostrar_execucao(self):
def obter_espacos(valor):
return (2 - len(f'{valor}')) * ' '
Console.quebrar_linha(vezes=1)
for i, processo in enumerate(self.fila_de_execucao):
faltando = processo.fatias - processo.processado
n = ' | '
Console.mostrar(f'{i+1} -> {processo.nome}', n=n)
espacos = obter_espacos(faltando)
Console.mostrar(f'Faltando -> {espacos}{faltando}', n=n, t='')
espacos = obter_espacos(processo.processado)
Console.mostrar(f'Processado -> {espacos}{processo.processado}',
n=n,
t='')
espacos = obter_espacos(processo.fatias)
Console.mostrar(f'Necessario -> {espacos}{processo.fatias}',
n=n,
t='')
estado = processo.estado()
if i == 0 and estado != 'finalizado':
estado = 'executou'
Console.mostrar(f'Estado -> {estado}', t='')
def carregar_via_console(self):
Console.quebrar_linha(vezes=1)
self.quantum = int(Console.obter('De quanto é o quantum ?'))
self.contexto = int(
Console.obter('Qual o custo da troca de contexto ?'))
quantidade_de_processos = int(
Console.obter('Qual a quantidade de processos ?'))
for i in range(quantidade_de_processos):
Console.adicionar_separador(tamanho=22)
nome = Console.obter(f'Qual o nome do processo {i + 1} ?').upper()
inicio = int(
Console.obter(
f'Em que fatia de tempo "{nome}" entra na memoria ?'))
fatias = int(
Console.obter(
f'Quantas fatias de tempo "{nome}" irá precisar ?',
linhas=0))
Console.adicionar_separador(tamanho=22)
Console.quebrar_linha(vezes=2)
self.processos.append({
'nome': nome,
'inicio': inicio,
'fatias': fatias
})