Dmitry Kirsanov commited on
Commit
5530b65
·
1 Parent(s): decdef2

add timestamps, tests ensure that you must be newer than what you ref to

Browse files
Files changed (2) hide show
  1. bidict.py +18 -0
  2. fad.py +71 -35
bidict.py ADDED
@@ -0,0 +1,18 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ class bidict(dict):
2
+ def __init__(self, *args, **kwargs):
3
+ super(bidict, self).__init__(*args, **kwargs)
4
+ self.inverse = {}
5
+ for key, value in self.items():
6
+ self.inverse.setdefault(value, []).append(key)
7
+
8
+ def __setitem__(self, key, value):
9
+ if key in self:
10
+ self.inverse[self[key]].remove(key)
11
+ super(bidict, self).__setitem__(key, value)
12
+ self.inverse.setdefault(value, []).append(key)
13
+
14
+ def __delitem__(self, key):
15
+ self.inverse.setdefault(self[key], []).remove(key)
16
+ if self[key] in self.inverse and not self.inverse[self[key]]:
17
+ del self.inverse[self[key]]
18
+ super(bidict, self).__delitem__(key)
fad.py CHANGED
@@ -1,23 +1,27 @@
1
- import re
 
2
 
3
- class Fad:
 
 
 
 
 
4
 
5
- idlength = 8
6
 
7
- notetypes = {
8
- # generic
9
- "span": 1,
10
- "point": 2,
 
 
 
11
 
12
- "sentence": 3,
13
 
14
- "concept": 4,
15
- "actor": 5,
16
- "audience": 6,
17
-
18
- "document type": 7,
19
- "document summary": 8,
20
- }
21
 
22
  notes = {}
23
 
@@ -26,14 +30,20 @@ class Fad:
26
  highest_note_id = 0
27
 
28
  class Note:
29
- def __init__(self, parentfad, id, type, value=None) -> None:
30
  self.id = id
31
- self.type = type
 
 
32
  self.parentfad = parentfad
33
  self.properties = {}
34
  if value is not None:
35
  self.properties["value"] = value
36
 
 
 
 
 
37
  def get(self, name=None):
38
  value = self.properties[name if name is not None else "value"] # "value" is default property
39
  if isinstance(value, int): # any int value is supposed to be a ref to id; if you need to store numbers, use floats
@@ -47,21 +57,31 @@ class Fad:
47
  if isinstance(value, int): # any int value is supposed to be a ref to id
48
  assert(value in self.parentfad.notes.keys()) # so we ensure this id exists
49
  self.properties["value"] = value
 
 
 
50
 
51
  def set(self, name, value):
52
  if isinstance(value, int): # any int value is supposed to be a ref to id
53
  assert(value in self.parentfad.notes.keys()) # so we ensure this id exists
54
  self.properties[name] = value
 
 
55
 
56
  def add(self, name, value):
57
  if isinstance(value, int): # any int value is supposed to be a ref to id
58
- assert(value in self.parentfad.notes.keys()) # so we ensure this id exists
59
- if not name in self.properties.keys() or self.properties[name] is None:
 
60
  self.properties[name] = [value] if value is not None else []
61
- elif isinstance(self.properties[name], list):
 
62
  self.properties[name].append(value)
 
63
  else:
64
- raise("Note: add: trying to add to list (properties) but the existing value is not a list")
 
 
65
 
66
  def get_refs(self):
67
  refs = []
@@ -72,16 +92,28 @@ class Fad:
72
  refs.append(key)
73
  return refs
74
 
 
 
 
 
 
 
 
 
 
 
 
 
75
  def delete(self):
76
  if self.get_refs():
77
- raise("Note: cannot delete a note that has references to it")
78
  else:
79
  self.parentfad.notes.pop(self.id)
80
 
81
 
82
  def newnote(self, type, value=None):
83
  id = self.highest_note_id + 1
84
- type_code = self.notetypes[type]
85
  self.highest_note_id += 1
86
  self.notes[id] = self.Note(self, id, type_code, value)
87
  return id
@@ -93,7 +125,7 @@ class Fad:
93
  def get_notes_by_type(self, valuetype):
94
  ids = []
95
  for id, note in self.notes.items():
96
- if note.type == self.notetypes[valuetype]:
97
  ids.append(id)
98
  return ids
99
 
@@ -105,20 +137,20 @@ class Fad:
105
  def get_values_by_type(self, valuetype):
106
  values = []
107
  for id, note in self.notes.items():
108
- if note.type == self.notetypes[valuetype]:
109
  values.append(note.properties["value"])
110
  return values
111
 
112
  def get_note_by_value(self, value, valuetype):
113
  for id, note in self.notes.items():
114
- if note.type == self.notetypes[valuetype] and note.properties["value"] == value:
115
  return id
116
  return None
117
 
118
  def get_notes_by_type_and_value(self, type, value):
119
  ret = []
120
  for id, m in self.notes.items():
121
- if self.notetypes[type] == m.type:
122
  if value == m.properties["value"]:
123
  ret.append(id)
124
  return ret
@@ -129,8 +161,8 @@ class Fad:
129
  new = self.pattern_marks.search(fad, start)
130
  if new != None:
131
  tend = new.start()
132
- id = int(fad[tend + 1:tend + self.idlength + 1])
133
- return fad[tstart:tend], fad[tend], id, tend + self.idlength + 1
134
  return fad[tstart:], None, None, None # no marks till the end
135
 
136
  def get_plaintext(self, fad):
@@ -150,13 +182,13 @@ class Fad:
150
  text, markchar, id, newi = self.get_next_mark(newfad, i)
151
  if newi == None:
152
  break
153
- if self.notes[id].type == self.notetypes[notetype]:
154
  id_s = f' id="{id}"' if show_id else ''
155
  properties_s = ''.join([(f' {name}="{str(self.notes[id].get(name))}"' if show_properties and self.notes[id].get(name) and (not(properties_to_show) or name in properties_to_show) else '') for name in self.notes[id].properties.keys()]) # show if a property's value is not [], None, or 0
156
  if markchar == '⌧':
157
- newfad = newfad[:newi - self.idlength - 1] + f'<{notetype}{id_s}{properties_s}/>' + newfad[newi:]
158
  else:
159
- newfad = newfad[:newi - self.idlength - 1] + f'<{"/" if markchar == "⌫" else ""}{notetype}{id_s}{properties_s if markchar == "⌦" else ""}>' + newfad[newi:]
160
  i = newi
161
  return self.get_plaintext(newfad)
162
 
@@ -167,7 +199,7 @@ class Fad:
167
  text, markchar, id, newi = self.get_next_mark(fad, i)
168
  if newi == None:
169
  break
170
- if self.notes[id].type == self.notetypes[notetype] and markchar == '⌦':
171
  close_i = fad.find(self.closemark(id), newi)
172
  if close_i != -1:
173
  spans.append(self.get_plaintext(fad[newi:close_i]))
@@ -228,7 +260,7 @@ class Fad:
228
  if markchar != '⌫':
229
  if newi == None:
230
  return None
231
- if self.notes[id].type == self.notetypes[notetype]:
232
  n += 1
233
  if n == mark_n:
234
  return id
@@ -245,7 +277,6 @@ class Fad:
245
 
246
  def add_property_to_mark(self, fad, notetype, mark_n, property, value, valuetype, startfrom=0):
247
  noteid = self.get_note_for_mark_n(fad, notetype, mark_n, startfrom)
248
- print(f"noteid = self.get_note_for_mark_n(fad, notetype, mark_n, startfrom): {noteid} = {fad} {notetype} {mark_n} {startfrom}")
249
  if valuetype != None: # we're setting value to ref to a note whose type is valuetype
250
  id = self.get_note_by_value(value, valuetype)
251
  self.notes[noteid].add(property, id)
@@ -335,3 +366,8 @@ if __name__ == "__main__":
335
 
336
  assert(f.get_spans_by_property_value(fad, "span", name="audience", values=['audience3']) == ['A123456789', 'C123456789'])
337
 
 
 
 
 
 
 
1
+ import re, time
2
+ import bidict
3
 
4
+ notetypes = bidict.bidict({
5
+ "document": 0,
6
+
7
+ # generic
8
+ "span": 1,
9
+ "point": 2,
10
 
11
+ "sentence": 3,
12
 
13
+ "concept": 4,
14
+ "actor": 5,
15
+ "audience": 6,
16
+
17
+ "document type": 7,
18
+ "document summary": 8,
19
+ })
20
 
21
+ idlength = 8
22
 
23
+
24
+ class Fad:
 
 
 
 
 
25
 
26
  notes = {}
27
 
 
30
  highest_note_id = 0
31
 
32
  class Note:
33
+ def __init__(self, parentfad, id, typeid, value=None) -> None:
34
  self.id = id
35
+ self.timestamp = time.time()
36
+ self.typeid = typeid
37
+ #print(f"constructor: {self.type()} id {id} timestamp {self.timestamp}")
38
  self.parentfad = parentfad
39
  self.properties = {}
40
  if value is not None:
41
  self.properties["value"] = value
42
 
43
+
44
+ def type(self):
45
+ return notetypes.inverse[self.typeid][0]
46
+
47
  def get(self, name=None):
48
  value = self.properties[name if name is not None else "value"] # "value" is default property
49
  if isinstance(value, int): # any int value is supposed to be a ref to id; if you need to store numbers, use floats
 
57
  if isinstance(value, int): # any int value is supposed to be a ref to id
58
  assert(value in self.parentfad.notes.keys()) # so we ensure this id exists
59
  self.properties["value"] = value
60
+ self.timestamp = time.time()
61
+ #print(f"set value: {self.type()} id {id} timestamp {self.timestamp}")
62
+
63
 
64
  def set(self, name, value):
65
  if isinstance(value, int): # any int value is supposed to be a ref to id
66
  assert(value in self.parentfad.notes.keys()) # so we ensure this id exists
67
  self.properties[name] = value
68
+ self.timestamp = time.time()
69
+ #print(f"set name value: {self.type()} id {id} timestamp {self.timestamp}")
70
 
71
  def add(self, name, value):
72
  if isinstance(value, int): # any int value is supposed to be a ref to id
73
+ if value not in self.parentfad.notes.keys(): # so we ensure this id exists
74
+ raise(Exception(f"Note: add: trying to add an id ({value}) which does not point to a Note"))
75
+ if not name in self.properties.keys() or self.properties[name] is None: # no such property yet, or it's None: create list
76
  self.properties[name] = [value] if value is not None else []
77
+ self.timestamp = time.time()
78
+ elif isinstance(self.properties[name], list): # already a list
79
  self.properties[name].append(value)
80
+ self.timestamp = time.time()
81
  else:
82
+ raise(Exception(f"Note: add: trying to add to list (properties[{name}]) but the existing value is not a list"))
83
+ #print(f"add: {self.type()} id {id} timestamp {self.timestamp}")
84
+
85
 
86
  def get_refs(self):
87
  refs = []
 
92
  refs.append(key)
93
  return refs
94
 
95
+ def touch(self):
96
+ self.timestamp = time.time()
97
+
98
+ def needs_updating_from(self):
99
+ refs_to_update = []
100
+ for key, value in self.properties.items():
101
+ if isinstance(value, int):
102
+ if not(self.timestamp >= self.parentfad.notes[value].timestamp): # + 0.01): #add margin
103
+ print(f"i refer to something newer than me! i need updating!\n me: {self.type()} at {self.timestamp}\n refer to: {self.parentfad.notes[value].type()} at {self.parentfad.notes[value].timestamp}")
104
+ refs_to_update.append(value)
105
+ return refs_to_update
106
+
107
  def delete(self):
108
  if self.get_refs():
109
+ raise(Exception(f"Note: cannot delete a note that has references to it: from {self.get_refs()}"))
110
  else:
111
  self.parentfad.notes.pop(self.id)
112
 
113
 
114
  def newnote(self, type, value=None):
115
  id = self.highest_note_id + 1
116
+ type_code = notetypes[type]
117
  self.highest_note_id += 1
118
  self.notes[id] = self.Note(self, id, type_code, value)
119
  return id
 
125
  def get_notes_by_type(self, valuetype):
126
  ids = []
127
  for id, note in self.notes.items():
128
+ if note.typeid == notetypes[valuetype]:
129
  ids.append(id)
130
  return ids
131
 
 
137
  def get_values_by_type(self, valuetype):
138
  values = []
139
  for id, note in self.notes.items():
140
+ if note.typeid == notetypes[valuetype]:
141
  values.append(note.properties["value"])
142
  return values
143
 
144
  def get_note_by_value(self, value, valuetype):
145
  for id, note in self.notes.items():
146
+ if note.typeid == notetypes[valuetype] and note.properties["value"] == value:
147
  return id
148
  return None
149
 
150
  def get_notes_by_type_and_value(self, type, value):
151
  ret = []
152
  for id, m in self.notes.items():
153
+ if notetypes[type] == m.typeid:
154
  if value == m.properties["value"]:
155
  ret.append(id)
156
  return ret
 
161
  new = self.pattern_marks.search(fad, start)
162
  if new != None:
163
  tend = new.start()
164
+ id = int(fad[tend + 1:tend + idlength + 1])
165
+ return fad[tstart:tend], fad[tend], id, tend + idlength + 1
166
  return fad[tstart:], None, None, None # no marks till the end
167
 
168
  def get_plaintext(self, fad):
 
182
  text, markchar, id, newi = self.get_next_mark(newfad, i)
183
  if newi == None:
184
  break
185
+ if self.notes[id].typeid == notetypes[notetype]:
186
  id_s = f' id="{id}"' if show_id else ''
187
  properties_s = ''.join([(f' {name}="{str(self.notes[id].get(name))}"' if show_properties and self.notes[id].get(name) and (not(properties_to_show) or name in properties_to_show) else '') for name in self.notes[id].properties.keys()]) # show if a property's value is not [], None, or 0
188
  if markchar == '⌧':
189
+ newfad = newfad[:newi - idlength - 1] + f'<{notetype}{id_s}{properties_s}/>' + newfad[newi:]
190
  else:
191
+ newfad = newfad[:newi - idlength - 1] + f'<{"/" if markchar == "⌫" else ""}{notetype}{id_s}{properties_s if markchar == "⌦" else ""}>' + newfad[newi:]
192
  i = newi
193
  return self.get_plaintext(newfad)
194
 
 
199
  text, markchar, id, newi = self.get_next_mark(fad, i)
200
  if newi == None:
201
  break
202
+ if self.notes[id].typeid == notetypes[notetype] and markchar == '⌦':
203
  close_i = fad.find(self.closemark(id), newi)
204
  if close_i != -1:
205
  spans.append(self.get_plaintext(fad[newi:close_i]))
 
260
  if markchar != '⌫':
261
  if newi == None:
262
  return None
263
+ if self.notes[id].typeid == notetypes[notetype]:
264
  n += 1
265
  if n == mark_n:
266
  return id
 
277
 
278
  def add_property_to_mark(self, fad, notetype, mark_n, property, value, valuetype, startfrom=0):
279
  noteid = self.get_note_for_mark_n(fad, notetype, mark_n, startfrom)
 
280
  if valuetype != None: # we're setting value to ref to a note whose type is valuetype
281
  id = self.get_note_by_value(value, valuetype)
282
  self.notes[noteid].add(property, id)
 
366
 
367
  assert(f.get_spans_by_property_value(fad, "span", name="audience", values=['audience3']) == ['A123456789', 'C123456789'])
368
 
369
+ for id, note in f.notes.items():
370
+ assert(note.needs_updating_from() == []) # in normal operation, there should be no contratemporal newer -> older refs
371
+
372
+
373
+