def save(self, info_file):
"""
Save data into given file.
:param info_file: an opened file to write data in
"""
info_file.write('Total Unique States:{}\n'.format(len(self.state_desc.keys())))
if not self.minimized:
info_file.write('Total Unique Observations:{}\n'.format(len(self.obs_space)))
else:
info_file.write('Total Unique Observations:{}\n'.format(len(self.minobs_obs_map.keys())))
info_file.write('\n\nStart State: {}\n'.format(self.start_state))
if not self.minimized:
info_file.write('\n\nObservation Description:\n')
t1 = PrettyTable(["Index", "Features"])
for i, o in enumerate(self.obs_space):
t1.add_row([i, o.__str__()])
info_file.write(t1.__str__() + '\n')
else:
info_file.write('\n\nMin-Observation Space Description:\n')
t1 = PrettyTable(["obs-tag", "Sub-Observation Space"])
for k in sorted(self.minobs_obs_map.keys()):
t1.add_row([k, self.minobs_obs_map[k]])
info_file.write(t1.__str__() + '\n')
info_file.write('\n\nStates Description:\n')
t1 = PrettyTable(["Name", "Action", "Description" if not self.minimized else 'Sub States'])
for k in sorted(self.state_desc.keys()):
_state_info = self.state_desc[k]['description' if not self.minimized else 'sub_states']
t1.add_row([k, self.state_desc[k]['action'], _state_info])
info_file.write(t1.__str__() + '\n')
if not self.minimized:
column_names = [""] + [str(_) for _ in range(len(self.obs_space))]
t = PrettyTable(column_names)
for key in sorted(self.transaction.keys()):
t.add_row([key] +
[(self.transaction[key][int(c)] if int(c) in self.transaction[key] else None) for c in
column_names[1:]])
else:
column_names = [""] + sorted(self.transaction[list(self.transaction.keys())[0]].keys())
t = PrettyTable(column_names)
for key in sorted(self.transaction.keys()):
t.add_row([key] + [self.transaction[key][c] for c in column_names[1:]])
info_file.write('\n\nTransaction Matrix: (StateIndex_ObservationIndex x StateIndex)' + '\n')
info_file.write(t.__str__())
if self.frequency is not None:
column_names = [""] + [str(_) for _ in sorted(self.frequency.keys())]
t = PrettyTable(column_names)
for key in sorted(self.frequency.keys()):
t.add_row([key] + [self.frequency[key][c] for c in sorted(self.frequency.keys())])
info_file.write('\n\nState Transaction Frequency Matrix: (From x To)' + '\n')
info_file.write(t.__str__())
if self.trajectory is not None:
info_file.write('\n\nTrajectory info:' + '\n')
info_file.write(self.trajectory.__str__())
info_file.close()
def __str__(self):
table = PrettyTable()
table.field_names = [
dict(OrderTicketsMapping).get(v) for v in self.__slots__
]
table.add_row([getattr(self, v) for v in self.__slots__])
return table.__str__()
def __str__(self):
saida = PrettyTable()
saida.field_names = ["", "Negativo", "Positivo"]
saida.add_row(
["Negativo", self.negativoNegativo, self.negativoPositivo])
saida.add_row(
["Positivo", self.positivoNegativo, self.positivoPositivo])
return saida.__str__()
def totext(self):
msg = ''
msg = msg + '\n--------XRP ARBITRAGES--------\n'
tab = PrettyTable(['Market', 'Price'])
for i in range(0, 4):
tab.add_row([str(self.names[i]), str(self.prices[i])])
msg = msg + tab.__str__()
return msg
def __str__(self):
tb = PrettyTable(["Num of CPTs", "Estiamted CPTs", "MSE", "Rank"])
if self.finalRes is None:
print("Run main function fisrt!")
tb.add_row([None, None, None, self.paras.r])
else:
MSE = self.GetCurMSE()
tb.add_row([len(self.ecpts), self.ecpts, MSE, self.paras.r])
return tb.__str__()
def __str__(self):
allocation_table = PrettyTable()
allocation_table.field_names = ['Campaign'
] + [g.id for g in self.market.goods]
allocation_table.align['Campaign'] = "l"
for c in self.allocation:
allocation_table.add_row(
[c] + [self.allocation[c][g] for g in self.allocation[c]])
# return allocation_str
return allocation_table.__str__()
def __str__(self):
saida = PrettyTable()
campos = [""]
for classe in self.classes:
campos.append(classe)
saida.field_names = campos
itens = campos[1:]
for classe in itens:
linha = [classe]
for sub_classe in itens:
linha.append(self.matriz[classe][sub_classe])
saida.add_row(linha)
saidaComLabels = PrettyTable()
saidaComLabels.field_names = ["", "Predição"]
saidaComLabels.add_row(["\n\n\nVerdadeiro", saida.__str__()])
return saidaComLabels.__str__()
def __str__(self):
table = PrettyTable(["variable", "value"])
table.add_row(['username', self.username])
table.add_row(['tenant_name', self.tenant_name])
table.add_row(['auth_url', self.auth_url])
table.add_row(['password', self.password])
table.add_row(['tenant_id', self.tenant_id])
table.add_row(['region_name', self.region_name])
table.add_row(['endpoint', self.endpoint])
return table.__str__()
def __str__(self):
x = PrettyTable()
board = self.get_board()
x.field_names = [' '] + [str(i + 1) for i in range(len(board))]
def change(c):
if c == 0:
return ''
if c == 1:
return 'X'
return 'O'
for i, row in enumerate(board):
x.add_row([i + 1] + list(map(change, row)))
return x.__str__()
class Table:
def __init__(self, fieldNames=[]):
self.Rows = []
self.Columns = []
self.Field_Names = fieldNames
self.Table = PrettyTable(fieldNames)
def Set_Field_Names(self, filedNames):
self.Table.field_names = filedNames
def Add_Row(self, row):
self.Rows += [row]
self.Table.add_row(row)
def __repr__(self):
return self.Table.__repr__()
def __str__(self):
return self.Table.__str__()
def giveStr(Cat):
x = PrettyTable(Cat.dtype.names)
for row in Cat: x.add_row(row)
return x.__str__()
def __repr__(self):
from prettytable import PrettyTable
table = PrettyTable(self._column_names)
for row in self.rows():
table.add_row(row)
return table.__str__()
