-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathstateDB.py
213 lines (181 loc) · 9.81 KB
/
stateDB.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy import Column, Integer, String
from sqlalchemy import event
import pickle
import trindikit
from trindikit import set
from botserver import db
class ConversationState(db.Model):
__tablename__ = 'conversationStates'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer)
bk_is_private_agenda = db.Column(db.String)
bk_is_private_plan = db.Column(db.String)
bk_is_private_bel = db.Column(db.String)
bk_is_shared_com = db.Column(db.String)
bk_is_shared_qud = db.Column(db.String)
bk_is_shared_lu_speaker = db.Column(db.String)
bk_is_shared_lu_moves = db.Column(db.String)
bk_mivs_input = db.Column(db.String)
bk_mivs_latest_speaker = db.Column(db.String)
bk_mivs_latest_moves = db.Column(db.String)
bk_mivs_next_moves = db.Column(db.String)
bk_mivs_output = db.Column(db.String)
# bk_mivs_program_state = db.Column(db.String)
def __init__(self, user_id):
self.user_id = user_id
self.reset_MIVS()
self.reset_IS()
self.init_DB()
def init_IS_from_DB(self):
self.reset_IS()
if self.bk_is_private_agenda != "":
# for elem in self.bk_is_private_agenda.split(';'):
# self.IS.private.agenda.push(elem)
self.IS.private.agenda = trindikit.stack(pickle.loads(self.bk_is_private_agenda), fixedType=object)
if self.bk_is_private_plan != "":
# for elem in self.bk_is_private_plan.split(';'):
# self.IS.private.plan.push(elem)
self.IS.private.plan = trindikit.stack(pickle.loads(self.bk_is_private_plan), fixedType=object)
if self.bk_is_private_bel != "":
# self.IS.private.bel = set(self.bk_is_private_bel.split(';'))
self.IS.private.bel = set(pickle.loads(self.bk_is_private_bel))
if self.bk_is_shared_com != "":
# self.IS.shared.com = set(self.bk_is_shared_com.split(';'))
self.IS.shared.com = set(pickle.loads(self.bk_is_shared_com))
if self.bk_is_shared_qud != "":
self.IS.shared.qud = trindikit.stackset(pickle.loads(self.bk_is_shared_qud), fixedType=object)
# for elem in self.bk_is_shared_qud.split(';'):
# self.IS.shared.qud.push(elem)
self.IS.shared.lu.speaker = trindikit.Speaker.USR if self.bk_is_shared_lu_speaker == "USR" else trindikit.Speaker.SYS
if self.bk_is_shared_lu_moves != "":
self.IS.shared.lu.moves = set(pickle.loads(self.bk_is_shared_lu_moves))
# self.IS.shared.lu.moves = set(self.bk_is_shared_lu_moves.split(';'))
def save_IS_to_DB(self):
odict = self.IS.asdict(recursive=True)
self.bk_is_private_agenda = pickle.dumps(odict["private"]["agenda"])
self.bk_is_private_plan = pickle.dumps(odict["private"]["plan"])
self.bk_is_private_bel = pickle.dumps(odict["private"]["bel"])
self.bk_is_shared_com = pickle.dumps(odict["shared"]["com"])
self.bk_is_shared_qud = pickle.dumps(odict["shared"]["qud"])
self.bk_is_shared_lu_speaker = "USR" if odict["shared"]["lu"].get("speaker", trindikit.Speaker.SYS) == trindikit.Speaker.USR else "SYS"
self.bk_is_shared_lu_moves = pickle.dumps(odict["shared"]["lu"]["moves"])
def reset_IS(self):
self.IS = trindikit.record(private = trindikit.record(agenda = trindikit.stack(),
plan = trindikit.stack(),
bel = set()),
shared = trindikit.record(com = set(),
qud = trindikit.stackset(),
lu = trindikit.record(speaker = trindikit.Speaker,
moves = set())))
def print_IS(self, prefix):
self.IS.pprint(prefix)
def reset_MIVS(self):
"""Initialise the MIVS. To be called from self.init()."""
self.INPUT = trindikit.value(str)
self.LATEST_SPEAKER = trindikit.value(trindikit.Speaker) #initializing it with "Speaker" means that it can only take Speaker.USR or Speaker.SYS
self.LATEST_MOVES = set() #sind die NEXT_MOVES von einer Iteration vorher
self.NEXT_MOVES = trindikit.stack(trindikit.Move)
self.OUTPUT = trindikit.value(str)
self.PROGRAM_STATE = trindikit.value(trindikit.ProgramState) #see above
self.PROGRAM_STATE.set(trindikit.ProgramState.RUN)
def init_MIVS_from_DB(self):
self.reset_MIVS()
self.INPUT.set(self.bk_mivs_input)
self.LATEST_SPEAKER.set(trindikit.Speaker.USR if self.bk_mivs_latest_speaker == "USR" else trindikit.Speaker.SYS)
if self.bk_mivs_latest_moves != "":
# self.LATEST_MOVES = set(self.bk_mivs_latest_moves.split(';'))
self.LATEST_MOVES = trindikit.set(pickle.loads(self.bk_mivs_latest_moves))
if self.bk_mivs_next_moves != "":
self.NEXT_MOVES = trindikit.stack(pickle.loads(self.bk_mivs_next_moves), fixedType=trindikit.Move)
# for elem in self.bk_mivs_next_moves.split(';'):
# self.NEXT_MOVES.push(elem)
self.OUTPUT.set(self.bk_mivs_output)
self.PROGRAM_STATE.set(trindikit.ProgramState.RUN) #must run, other stuff would be bullshit
def save_MIVS_to_DB(self):
self.bk_mivs_input = self.INPUT.get()
self.bk_mivs_latest_speaker = "USR" if self.LATEST_SPEAKER.get() == trindikit.Speaker.USR else "SYS"
# self.bk_mivs_latest_moves = ';'.join([str(i) for i in list(self.LATEST_MOVES)])
self.bk_mivs_latest_moves = pickle.dumps(self.LATEST_MOVES)
# self.bk_mivs_next_moves = ';'.join([str(i) for i in list(self.NEXT_MOVES)])
self.bk_mivs_next_moves = pickle.dumps(self.NEXT_MOVES)
self.bk_mivs_output = self.OUTPUT.get()
# self.bk_mivs_program_state =
def print_MIVS(self, prefix=""):
"""Print the MIVS. To be called from self.print_state()."""
print(prefix + "INPUT: ", self.INPUT)
print(prefix + "LATEST_SPEAKER:", self.LATEST_SPEAKER)
print(prefix + "LATEST_MOVES: ", self.LATEST_MOVES)
print(prefix + "NEXT_MOVES: ", self.NEXT_MOVES)
print(prefix + "OUTPUT: ", self.OUTPUT)
print(prefix + "PROGRAM_STATE: ", self.PROGRAM_STATE)
def init_DB(self):
if self.bk_is_private_agenda is None: self.bk_is_private_agenda = ""
if self.bk_is_private_plan is None: self.bk_is_private_plan = ""
if self.bk_is_private_bel is None: self.bk_is_private_bel = ""
if self.bk_is_shared_com is None: self.bk_is_shared_com = ""
if self.bk_is_shared_qud is None: self.bk_is_shared_qud = ""
if self.bk_is_shared_lu_speaker is None: self.bk_is_shared_lu_speaker = ""
if self.bk_is_shared_lu_moves is None: self.bk_is_shared_lu_moves = ""
if self.bk_mivs_input is None: self.bk_mivs_input = ""
if self.bk_mivs_latest_speaker is None: self.bk_mivs_latest_speaker = ""
if self.bk_mivs_latest_moves is None: self.bk_mivs_latest_moves = ""
if self.bk_mivs_next_moves is None: self.bk_mivs_next_moves = ""
if self.bk_mivs_output is None: self.bk_mivs_output = ""
# wenn man den IS lädt anstatt neu created muss er IS laden statt resetten
# http://docs.sqlalchemy.org/en/latest/orm/events.html#sqlalchemy.orm.events.InstanceEvents.load,
# http://docs.sqlalchemy.org/en/latest/orm/session_events.html#loaded-as-persistent
@event.listens_for(ConversationState, 'load')
def receive_load(target, context):
target.init_DB()
target.init_MIVS_from_DB()
target.init_IS_from_DB()
########################################################################################################################
# def recStringDict(value):
# result = ""
# for key, value in list(value.items()):
# if result: result += '\n'
# result += prefix + key + ': '
# if isinstance(value, dict):
# result += '\n' + recStringDict(value)
# else:
# result += str(value)
# return result
#
# def tostring(dic):
# final = {}
# for key, value in list(dic.items()):
# if isinstance(value, dict):
# final[key] = tostring(value)
# elif isinstance(value, list):
# final[key] = ';'.join([str(i) for i in value])
# else:
# final[key] = str(value)
# return final
#
# ---------------------------------------- Nicht benötigt bei flask_sqlalchemy ----------------------------------------
#
# Base = declarative_base()
#
# class stateDB:
#
# def __init__(self, dbname=":memory:", dbtype="sqlite"):
# dbname = dbname+"."+dbtype if dbname != ":memory:" and "." not in dbname else dbname
# self.engine = create_engine(dbtype+':///'+dbname, echo=False)
# Session = sessionmaker(bind=self.engine)
# self.session = Session()
# Base.metadata.create_all(self.engine)
#
#
# def create_or_add(self, chatID):
# query = self.session.query(stateDBEntry)
# user = query.filter(stateDBEntry.chat_id==chatID).one_or_none()
# if user != None:
# return user, False
# else:
# user = stateDBEntry(chat_id=chatID)
# self.session.add(user)
# self.session.commit()
# return user, True