def setInfoTemp(self, info):
if info is None:
self.infoTemp = deepc(self.infoModel)
else:
self.infoTemp = deepc(info)
return self.infoTemp
def initStatDb(self, database={}):
if database is None or len(database) == 0:
database = deepc(self.database)
def formatStuff(li):
form = {k: 0 for k in li}
return Od(form)
statG = deepc(database)
stat = deepc(database)
listaKeysStat = [
'3 Notti', '2 Notti', '1 Notte', 'Tasse finora', 'Netto finora',
'Spese finora'
]
for anno in stat.keys():
for mese in stat[anno].keys():
stat[anno][mese] = {k: 0 for k in listaKeysStat}
for anno in database.keys():
for mese in database[anno].keys():
for giorno in database[anno][mese].keys():
chiave = deepc(database[anno][mese][giorno]['checkIn'])
numeroNotti = int(chiave['totale notti'])
stat[anno][mese]['Spese finora'] = int(chiave['spese'])
if numeroNotti >= 3:
stat[anno][mese]['3 Notti'] += 1
elif numeroNotti == 2:
stat[anno][mese]['2 Notti'] += 1
elif numeroNotti == 1:
stat[anno][mese]['1 Notte'] += 1
tasse = int(chiave['tasse'])
stat[anno][mese]['Tasse finora'] += tasse
netto = int(chiave['netto'])
stat[anno][mese]['Netto finora'] += netto
return stat
def riempiTabellaStat(self, info=None):
if info is None:
info = deepc(self.infoSta)
# data = self.calendario.selectedDate()
# print('mese mostrato dal calendario:',self.calendario.currentMonth)
data = self.calendario.currentDate
a, m, g = self.amg(data)
m = self.calendario.currentMonth
dbStat = deepc(info)
try:
self.tableWidget_stat.setRowCount(0)
row = 0
for c0, c1 in dbStat[a][m].items():
self.tableWidget_stat.insertRow(row)
item0 = QtWidgets.QTableWidgetItem()
item0.setText(c0)
item1 = QtWidgets.QTableWidgetItem()
item1.setText(str(c1))
self.tableWidget_stat.setItem(row, 0, item0)
self.tableWidget_stat.setItem(row, 1, item1)
row += 1
self.tableWidget_stat.update()
except KeyError:
print('riempi stat key err ')
print(dbStat.keys())
def freethem(self):
"""
cancella di fatto la prenotazione posta in info
:return:
"""
try:
self.controlloNome()
data = self.getData()
if data is None:
print("fornire un info model - freethem")
return
flag = True
while flag:
checkIn, checkOut, nome, cognome = self.findDate(
self.DataBase, data)
if (checkIn['nome'] == self._nome
or checkIn['cognome'] == self._cognome
) and checkIn['data arrivo'] == self._dataIn:
spese = checkIn['spese']
note = checkIn['note']
checkIn = deepc(DBM.INFOMODEL)
checkIn['spese'] = spese
checkIn['note'] = note
checkOut = deepc(DBM.INFOMODELREDUX)
a, m, g = self.amg(data)
self.DataBase[a][m][g]['checkIn'] = checkIn
# if self.DataBase[a][m][g]['checkOut']['data partenza'] != '':
# self.DataBase[a][m][g]['checkOut'] = checkOut
print("checkin copiato")
data = data.addDays(1)
a, m, g = self.amg(data)
if self.DataBase[a][m][g]['checkOut'][
'data partenza'] != '':
self.DataBase[a][m][g]['checkOut'] = checkOut
else:
print(
self.DataBase[a][m][g]['checkOut']['data partenza']
+ ' ', g)
else:
flag = False
break
self.salvaDatabase(self.DataBase)
except:
import traceback
print(traceback.format_exc())
def getInfoFromDate(self, data):
# self.cleardisplay()
# print("controllo ", inspect.stack()[0][3])
self.get_date(data)
# print("data ",self.current_date)
a, m, g = self.amg(data)
info = self.getInfo(a, m, g)
if info is None:
info = deepc(self.infoModel)
return info
def addSpese(self):
try:
data = self.calendario.currentDate
a, m, g = self.amg(data)
finale = self.gestisciSpese(data)
spese = self.database[a][m][g]['checkIn']['spese']
if spese != finale:
copia = deepc(self.database[a][m][g]['checkIn'])
copia['spese'] = finale
for giorno in self.database[a][m].keys():
note = self.database[a][m][giorno]['checkIn']['note']
copia['note'] = note
self.database[a][m][giorno]['checkIn'] = deepc(copia)
# self.database[a][m][giorno]['checkIn']['spese'] = finale
dbm.salvaDatabase(self.database)
# self.updateInfoStat()
except:
print(fex())
def getInfo(self, a, m, g):
try:
database = self.getDatabase()
# print("getinfo database keys:\n", database.keys())
info = deepc(database[a][m][g]["checkIn"])
print("info['note'] from getInfo", info['note'])
# print('getInfo', info)
except KeyError:
print("keyerr getInfo evinterf")
info = None
return info
def setThem(self, out=False):
"""
crea una prenotazione e la salva su disco
:return:
"""
database = deepc(self.getDb())
data = self.getData()
data1 = self.getData()
if data is None:
print("fornire un info model - setThem")
return
notedict = deepc(self._info)
note = notedict['note']
self._info['note'] = ''
a1, m1, g1 = data1.year(), data1.month(), data1.day()
while data < self._dataOut:
a2, m2, g2 = self.amg(data)
# if a != annoIn:
# database = databaseOut
database[a2][m2][g2]['checkIn'] = deepc(self._info)
data = data.addDays(1)
if data == self._dataOut:
# print("giorno stabilito")
infoRedux = self.buildInfoRed()
a3, m3, g3 = self.amg(data)
database[a3][m3][g3]['checkOut'] = deepc(infoRedux)
break
database[a1][m1][g1]['checkIn'] = deepc(notedict)
# database[a1][m1][m1]['checkIn']['note'] = note
self.DataBase = deepc(database)
self.salvaDatabase(database)
def addNote(self):
try:
# dialog = DialogInfo('Spese',table=True)
# data = self.calendario.selectedDate()
data = self.calendario.currentDate
a, m, g = self.amg(data)
database = self.getDatabase(a)
# text = self.database[a][m][g]['checkIn']['note']
text = database[a][m][g]['checkIn']['note']
dialog = DialogInfo(testo=text, showBool=True)
icona = QtGui.QIcon('./Icons/iconaNote.ico')
dialog.setWindowIcon(icona)
# tempDict = deepc(self.database[a][m][g]['checkIn'])
tempDict = deepc(database[a][m][g]['checkIn'])
dialog.guiText.textBrowser_dialog_info.setText(text)
if dialog.exec_():
nuovoTesto = dialog.guiText.textBrowser_dialog_info.toPlainText(
)
if nuovoTesto != text:
tempDict['note'] = nuovoTesto
# self.database[a][m][g]['checkIn'] = tempDict
database[a][m][g]['checkIn'] = tempDict
dbm.salvaDatabase(database)
self.database = deepc(database)
self.bot_note.setState(True)
if nuovoTesto == '':
self.bot_note.setState(False)
if self.calendario.currentDate in self.calendario.dateNote:
self.calendario.dateNote.remove(
self.calendario.currentDate)
else:
if self.calendario.currentDate not in self.calendario.dateNote:
self.calendario.dateNote.append(
self.calendario.currentDate)
self.calendario.updateIconsAndBooked()
# info = self.getInfo(a,m,g)
# self.setInfoTemp(info)
except:
print(fex())
def __init__(self, info=None, shortcut=0):
# self._dataIn = dataIn
# self._domani = dataIn.addDays(1)
# self._nome = nome
# self._cognome = cognome
# opzione per correggere il percorso durante i tests
self.shortcut = shortcut
self._info = info
# if self._info is not None:
manageErr = False
try:
self.info = self.getInfo
self._dataIn = self.info['data arrivo']
self._dataOut = self.info['data partenza']
self._domani = self._dataIn.addDays(1)
self._nome = self.info['nome']
self._cognome = self.info['cognome']
except AttributeError:
manageErr = True
except TypeError:
manageErr = True
if manageErr:
self._dataIn = QtCore.QDate().currentDate()
self._domani = self._dataIn.addDays(1)
self._dataOut = self._domani
self._nome = None
self._cognome = None
self.occupate = []
# old
# self.DataBase = deepc(self.getDb(self._dataIn))
self.DataBase = deepc(self.getDb())
self.counter = 0
# self.DataBase = Od()
datePren = {'platforms': {}}
self.datePrenotazioni = Od(datePren)
self.dateBooking = []
self.dateAirbb = []
self.datePrivati = []
self.datePulizie = []
self.dateSpese = []
self.dateNote = []
self.platformDict = {
'Booking': self.dateBooking,
'AirB&B': self.dateAirbb,
'Privati': self.datePrivati,
'pulizie': self.datePulizie
}
def loadConfig(self):
numeroOspiti = self.config['numero letti']
self.spinBox_ospiti.setMaximum(numeroOspiti)
self.spinBox_bambini.setMaximum(numeroOspiti - 1)
self.buildListeIPT()
self.colors = deepc(self.config['colori settati'])
# database = self.getDatabase()
# self.leggiDatabase(database)
# self.infoModel
plats = self.config['platforms']
self.combo_platformPrenotazioni.clear()
for platform in plats.keys():
if platform != '' and self.combo_platformPrenotazioni.findText(
platform, QtCore.Qt.MatchExactly) == -1:
self.combo_platformPrenotazioni.addItem(platform)
self.lineEdit_tax.setText(str(self.config['tasse']))
def __init__(self, spese: dict, parent=None):
print('dialog spese')
super(DialogInfoSpese, self).__init__(parent)
self.setupUi(self)
# self.setModal(True)
self.listaTipi = []
self.spese = spese
self.vecchieSpese = deepc(self.spese)
self.tableWidget.setRowCount(0)
self.riempiTable()
# self.setWindowModality(QtCore.Qt.WindowModal)
self.tableWidget.itemChanged.connect(lambda x: self.gotoLine(x.row()))
self.bot_addLine.clicked.connect(self.addNewLine)
self.bot_removeLine.clicked.connect(self.cancellaSpesa)
self.bot_ok.clicked.connect(self.accept)
self.bot_esci.clicked.connect(self.close)
self.tableWidget.EDITFINISHED.connect(self.returnPressed)
def gestisciSpese(self, datat):
try:
# dialog = DialogInfo('Spese',table=True)
a, m, g = self.amg(datat)
spesetot = deepc(self.spese)
spese = spesetot[a][m].get(datat, {})
dialog = DialogSpese(spese)
dialog.setWindowIcon(QtGui.QIcon('./Icons/iconaSpese.png'))
dialog.SPESEPRONTE.connect(lambda x: print('spese pronte', x))
# dialog.setModal(True)
if dialog.exec_():
spese = dialog.ottieniSpese()
if len(spese) != 0:
self.spese[a][m][datat] = spese
self.bot_spese.setState(True)
tot = self.totaleSpeseG(datat)
print('totale spese giornaliere: ', tot)
self.calendario.dateSpese.append(datat)
self.calendario.datesIndicatorsChanged.emit()
else:
if datat in self.spese[a][m].keys():
del self.spese[a][m][datat]
if datat in self.calendario.dateSpese:
self.calendario.dateSpese.remove(datat)
self.calendario.datesIndicatorsChanged.emit()
self.bot_spese.setState(False)
tot = 0
self.calendario.datesIndicatorsChanged.emit()
self.calendario.updateIconsAndBooked()
totSpeseMensili = 0
try:
for giornoData in self.spese[a][m].keys():
for spesaperitem in self.spese[a][m][giornoData].values():
totSpeseMensili += spesaperitem
finale = float(totSpeseMensili)
except TypeError:
print(' TYPEERR *****************', self.spese[a][m].values())
dbm.salvaDatabase(self.spese, tipodatabase='spese')
return finale
except:
print(fex())
def setDatesIndicators(self, prenotazioni, pulizie, colors, spese, note):
"""sets the object datePrenotazioni, datePulizie and colors"""
if len(colors) != 0:
self.colors = colors
self.datePrenotazioni = deepc(prenotazioni)
# if len(prenotazioni) != 0:
# self.datePrenotazioni = deepc(prenotazioni)
# print('prenotazioni setted')
if len(pulizie) != 0:
self.datePulizie = pulizie
# print('pulizie setted')
if len(spese) > 0:
# print('spese setted ')
self.dateSpese = spese
# self.dateSpese = deepc(spese)
# print('spese setted ')
if len(note) > 0:
# print('note setted')
self.dateNote = list(set(note))
self.datesIndicatorsChanged.emit()
def ottieniSpese(self):
rows = self.tableWidget.rowCount()
spese = {}
for row in range(rows):
itemR = self.tableWidget.cellWidget(row, 1)
valore = itemR.text()
try:
valRow = float(valore)
except ValueError:
if ',' in itemR.text():
valore = valore.replace(',','.')
valRow = float(valore)
if valRow == 0:
continue
itemC = self.tableWidget.item(row, 0)
chiaveCol = itemC.text()
spese[chiaveCol] = spese.get(chiaveCol, 0.0) + valRow
# spese[chiaveCol] = valRow
self.spese = deepc(spese)
self.SPESEPRONTE.emit(self.spese)
return self.spese
def setDatesIndicators(self, prenotazioni, pulizie, colors, spese, note):
"""sets the object datePrenotazioni, datePulizie and colors"""
if len(colors) != 0:
self.colors = colors
if len(prenotazioni) != 0:
self.datePrenotazioni = deepc(prenotazioni)
# print('prenotazioni setted')
if len(pulizie) != 0:
self.datePulizie = pulizie
# print('pulizie setted')
if len(spese) > 0:
# print('spese setted ')
for anno in spese.keys():
for mese in spese[anno].keys():
for data in spese[anno][mese].keys():
self.dateSpese.append(data)
# self.dateSpese = deepc(spese)
# print('spese setted ')
if len(note) > 0:
# print('note setted')
self.dateNote = note
self.datesIndicatorsChanged.emit()
def run(alg,
alg_kwargs,
task,
task_kwargs,
wrappers_kwargs,
expl_params,
rollout,
num_trials,
folder,
n_thrds,
n_lstm,
rerun=False,
test_kwargs={},
num_retrains=10,
seed=0,
train_mode=None,
sl_kwargs=None):
train_mode = train_mode or 'RL'
env = test_env(task, kwargs=task_kwargs, num_steps=1000)
num_timesteps = int(1000 * num_trials / (env.num_tr))
files = glob.glob(folder + '/*model*')
vars_ = {
'alg': alg,
'alg_kwargs': alg_kwargs,
'task': task,
'task_kwargs': task_kwargs,
'wrappers_kwargs': wrappers_kwargs,
'expl_params': expl_params,
'rollout': rollout,
'folder': folder,
'num_trials': num_trials,
'n_thrds': n_thrds,
'n_lstm': n_lstm
}
np.savez(folder + '/params.npz', **vars_)
if len(files) == 0 or rerun:
if train_mode == 'RL':
if alg == "A2C":
from stable_baselines import A2C as algo
elif alg == "ACER":
from stable_baselines import ACER as algo
elif alg == "ACKTR":
from stable_baselines import ACKTR as algo
elif alg == "PPO2":
from stable_baselines import PPO2 as algo
env = SubprocVecEnv([
make_env(env_id=task,
rank=i,
seed=seed,
wrapps=wrappers_kwargs,
**task_kwargs) for i in range(n_thrds)
])
model = algo(LstmPolicy,
env,
verbose=0,
n_steps=rollout,
n_cpu_tf_sess=n_thrds,
tensorboard_log=None,
policy_kwargs={
"feature_extraction": "mlp",
"n_lstm": n_lstm
},
**alg_kwargs)
# this assumes 1 trial ~ 10 steps
sv_freq = 5 * wrappers_kwargs['MonitorExtended-v0']['sv_per']
chckpnt_cllbck = CheckpointCallback(save_freq=sv_freq,
save_path=folder,
name_prefix='model')
model.learn(total_timesteps=num_timesteps, callback=chckpnt_cllbck)
model.save(f"{folder}/model_{num_timesteps}_steps.zip")
plotting.plot_rew_across_training(folder=folder)
elif train_mode == 'SL':
stps_ep = sl_kwargs['steps_per_epoch']
wraps_sl = deepc(wrappers_kwargs)
del wraps_sl['PassAction-v0']
del wraps_sl['PassReward-v0']
del wraps_sl['MonitorExtended-v0']
env = make_env(env_id=task,
rank=0,
seed=seed,
wrapps=wraps_sl,
**task_kwargs)()
dataset = ngym.Dataset(env,
batch_size=sl_kwargs['btch_s'],
seq_len=rollout,
batch_first=True)
obs_size = env.observation_space.shape[0]
act_size = env.action_space.n
model = define_model(seq_len=rollout,
num_h=n_lstm,
obs_size=obs_size,
act_size=act_size,
batch_size=sl_kwargs['btch_s'],
stateful=sl_kwargs['stateful'],
loss=sl_kwargs['loss'])
# Train network
data_generator = (dataset() for i in range(stps_ep))
model.fit(data_generator, verbose=1, steps_per_epoch=stps_ep)
model.save(f"{folder}/model_{stps_ep}_steps")
if len(test_kwargs) != 0:
for key in test_kwargs.keys():
sv_folder = folder + key
test_kwargs[key]['seed'] = seed
if train_mode == 'RL':
if '_all' not in key:
ga.get_activity(folder, alg, sv_folder, **test_kwargs[key])
else:
files = glob.glob(folder + '/model_*_steps.zip')
for f in files:
model_name = os.path.basename(f)
sv_f = folder + key + '_' + model_name[:-4]
ga.get_activity(folder,
alg,
sv_folder=sv_f,
model_name=model_name,
**test_kwargs[key])
elif train_mode == 'SL':
stps_ep = sl_kwargs['steps_per_epoch']
wraps_sl = deepc(wrappers_kwargs)
wraps_sl.update(test_kwargs[key]['wrappers'])
del wraps_sl['PassAction-v0']
del wraps_sl['PassReward-v0']
env = make_env(env_id=task,
rank=0,
seed=seed,
wrapps=wraps_sl,
**task_kwargs)()
obs_size = env.observation_space.shape[0]
act_size = env.action_space.n
model_test = define_model(seq_len=1,
batch_size=1,
obs_size=obs_size,
act_size=act_size,
stateful=sl_kwargs['stateful'],
num_h=n_lstm,
loss=sl_kwargs['loss'])
ld_f = folder + 'model_' + str(stps_ep) + '_steps'.replace(
'//', '/')
model_test.load_weights(ld_f)
env.reset()
for ind_stp in range(sl_kwargs['test_steps']):
obs = env.ob_now
obs = obs[np.newaxis]
obs = obs[np.newaxis]
action = model_test.predict(obs)
action = np.argmax(action, axis=-1)[0]
_, _, _, _ = env.step(action)
def checkAval(self, dal, al, nomePassato='', cognomePassato=''):
# todo aggiungere (self,INFO, dal, al) per verificare che il nome sia lo stesso
# todo invece che semplicemente vuoto ( serve per fare il controllo nelle modifiche)
"""
controlla la disponibilità delle prenotazioni
nell'intervallo delle date fornite
:param dal:
:param al:
:param nomePassato:str
:param cognomePassato:str
:return: list
"""
giorniPermanenza = dal.daysTo(al)
print("giorni di permanenza: ", giorniPermanenza)
arrivo = dal
partenza = al
database = deepc(self.DataBase)
aval = True
listaDisponibili = []
oggi = arrivo
while oggi < partenza:
a, m, g = self.amg(oggi)
try:
nome = database[a][m][g]['checkIn']['nome']
cognome = database[a][m][g]['checkIn']['cognome']
except KeyError:
database = self.getDb()
nome = database[a][m][g]['checkIn']['nome']
cognome = database[a][m][g]['checkIn']['cognome']
print('nome CheckAval ', nome, ' nomepassato: ', nomePassato)
if nome != nomePassato or cognome != cognomePassato:
if nome != '' and cognome != '':
aval = False
print(
"spiacente, casa non disponibile in questa data",
oggi.toString("dd MMM yyyy"),
)
else:
listaDisponibili.append(oggi)
else:
listaDisponibili.append(oggi)
oggi = oggi.addDays(1)
if giorniPermanenza == len(listaDisponibili):
print("casa libera tutti i giorni disponibili")
else:
print(" casa libera nei giorni:")
# todo ripristinare la funzionalità qui sotto
# if len(listaDisponibili) > 0:
# self.dateEdit_dal.setDate(listaDisponibili[0])
# self.dateEdit_dal.update()
# for d in listaDisponibili:
# print(d)
# cancellare quella qui sotto
if len(listaDisponibili) > 0:
for d in listaDisponibili:
print(d.toString("dd MMM yyyy"))
else:
print("nessuna data disponibile")
return listaDisponibili
def riempi_campi_prenotazioni(self):
""" prende le info da inserire nei campi
della prenotazione a partire dalle info
nel box nella pagina
del calendario"""
# todo aggiungere segnale alle mylineEdit perché si sblocchi il tasto salva o modifica
try:
info = deepc(self.infoTemp)
print('infoTemp in riempi_campi_prenotazioni', self.infoTemp)
if (info['nome'] and info['cognome'] and info['telefono']) == '':
self.modificaOsalva()
else:
self.modificaOsalva(modifica=True)
self.lineEdit_nome.setText(info['nome'])
self.lineEdit_cognome.setText(info['cognome'])
self.lineEdit_telefono.setText(info['telefono'])
self.lineEdit_email.setText(info['email'])
self.spinBox_ospiti.setValue(int(info['numero ospiti']))
self.spinBox_bambini.setValue(int(info['bambini']))
platform = info['platform']
if platform != '':
indiceCombo = self.combo_platformPrenotazioni.findText(
platform)
else:
indiceCombo = 0
self.combo_platformPrenotazioni.setCurrentIndex(indiceCombo)
print('indice Combo: ', indiceCombo)
print('platform: ', platform)
# try:
#
# except:
# print(fex())
self.plainTextEdit_note.clear()
try:
infoNote = self.getInfoFromDate(info['data arrivo'])
except AttributeError:
infoNote = info
self.plainTextEdit_note.insertPlainText(infoNote['note'])
self.radio_colazione.setChecked(info['colazione'] == 'Si')
# self.importAdj(self.spinBox_bambini.value() + self.spinBox_ospiti.value())
stagione = info['stagione']
indiceComboStagione = self.combo_stagionePrenotazioni.findText(
stagione)
if indiceComboStagione == -1:
indiceComboStagione = self.combo_stagionePrenotazioni.findText(
self.config['stagione preferita'])
self.combo_stagionePrenotazioni.setCurrentIndex(
indiceComboStagione)
self.importAdj()
dataArrivo = info['data arrivo']
dataPartenza = info['data partenza']
if (dataArrivo or dataPartenza) is not None:
self.dateEdit_dal.blockSignals(True)
self.dateEdit_al.blockSignals(True)
self.dateEdit_dal.setDate(dataArrivo)
self.dateEdit_al.setMinimumDate(dataArrivo.addDays(1))
self.dateEdit_al.setDate(dataPartenza)
self.dateEdit_dal.blockSignals(False)
self.dateEdit_al.blockSignals(False)
self.lineEdit_numeroGiorni.setText(info['totale notti'])
else:
# print("else: setDateEdit_dal")
self.setDateEdit_dal()
# self.dateEdit_al.setDate(dataPartenza)
except:
print(fex())