def pystellen(indices, settings, format="svg"):
delta = const._asdict()[settings['delta'].strip()]
mfwmin = int(settings['mfwmin'])
cullmin = int(settings['culmin'])
sel_liste = [app.namen[x] for x in indices]
sel_liste.sort()
#corpus=Corpus(subdir='corpus')
list_of_wordlists = []
for text in sel_liste:
all_words = collections.defaultdict(int)
#print("processing " + text)
for w in app.texte[text].split():
all_words[w] += 1
wordlist = pd.Series(all_words, name=text)
list_of_wordlists.append(wordlist)
df = pd.DataFrame(list_of_wordlists).fillna(0).T
df = df.ix[(-df.sum(axis=1)).argsort()]
corpus = Corpus(corpus=df)
cul = 1 / cullmin
corpus = corpus.cull(ratio=cul)
mfw_corpus = corpus.get_mfw_table(mfwmin)
deltas = Delta(mfw_corpus, delta, None)
fig = Figure(deltas.get_linkage('ward'), deltas.index, 'left', 8,
'Latin translations', mfwmin, delta, False)
#svg = fig.gensvg()
dendro_dat, plot = fig.show()
#TEST!!!
image = fig.genimage(plot, format=format)
session["lastplot"] = (indices, settings)
#svg = repr(settings)
return (image)
def string_to_delta(text):
temp_text = text[7:]
delta_text = temp_text[:-2]
delta_list = delta_text.split(',')
if len(delta_list) == 1:
ops = delta_list[0][2:8]
if ops == 'insert':
value = delta_list[0][12:-2]
print(value)
return Delta().insert(value)
elif ops == 'delete':
value = int(delta_list[0][11:-1])
return Delta().delete(value)
elif len(delta_list) == 2:
for i in range(2):
if i == 0:
ops_1 = delta_list[0][2:8]
value_1 = int(delta_list[0][11:12])
elif i == 1:
ops_2 = delta_list[1][3:9]
if ops_2 == 'insert':
value_2 = delta_list[1][13:-2]
return Delta().retain(value_1).insert(value_2)
elif ops_2 == 'delete':
value_2 = int(delta_list[1][12:-1])
return Delta().retain(value_1).delete(value_2)
return Delta()
def test_insert_embed():
a = Delta().insert(1, src='http://quilljs.com/image.png')
b = Delta().retain(1, alt='logo')
expected = Delta().insert(1,
src='http://quilljs.com/image.png',
alt='logo')
assert a.compose(b) == expected
def test_retain():
a = Delta()
a.insert('A')
b = Delta()
b.insert('A')
expected = Delta()
assert a.diff(b) == expected
def test_format():
a = Delta()
a.insert('A')
b = Delta()
b.insert('A', bold=True)
expected = Delta().retain(1, bold=True)
assert a.diff(b) == expected
def test_insert():
a = Delta()
a.insert('A')
b = Delta()
b.insert('AB')
expected = Delta().retain(1).insert('B')
assert a.diff(b) == expected
def test_delete():
a = Delta()
a.insert('AB')
b = Delta()
b.insert('A')
expected = Delta().retain(1).delete(1)
assert a.diff(b) == expected
def test_conflicting_appends():
a1 = Delta().retain(3).insert('aa')
b1 = Delta().retain(3).insert('bb')
a2 = Delta(a1)
b2 = Delta(b1)
expected1 = Delta().retain(5).insert('bb')
expected2 = Delta().retain(3).insert('aa')
assert a1.transform(b1, True) == expected1
assert b2.transform(a2, False) == expected2
def test_retain_and_retain():
a1 = Delta().retain(1, color='blue')
b1 = Delta().retain(1, bold=True, color='red')
a2 = Delta().retain(1, color='blue')
b2 = Delta().retain(1, bold=True, color='red')
expected1 = Delta().retain(1, bold=True)
expected2 = Delta()
assert a1.transform(b1, True) == expected1
assert b2.transform(a2, True) == expected2
def test_retain_and_retain_without_priority():
a1 = Delta().retain(1, color='blue')
b1 = Delta().retain(1, bold=True, color='red')
a2 = Delta().retain(1, color='blue')
b2 = Delta().retain(1, bold=True, color='red')
expected1 = Delta().retain(1, bold=True, color='red')
expected2 = Delta().retain(1, color='blue')
assert a1.transform(b1, False) == expected1
assert b2.transform(a2, False) == expected2
def test_alternating_edits():
a1 = Delta().retain(2).insert('si').delete(5)
b1 = Delta().retain(1).insert('e').delete(5).retain(1).insert('ow')
a2 = Delta(a1)
b2 = Delta(b1)
expected1 = Delta().retain(1).insert('e').delete(1).retain(2).insert('ow')
expected2 = Delta().retain(2).insert('si').delete(1)
assert a1.transform(b1, False) == expected1
assert b2.transform(a2, False) == expected2
def test_prepend_and_append():
a1 = Delta().insert('aa')
b1 = Delta().retain(3).insert('bb')
expected1 = Delta().retain(5).insert('bb')
a2 = Delta(a1)
b2 = Delta(b1)
expected2 = Delta().insert('aa')
assert a1.transform(b1, False) == expected1
assert b2.transform(a2, False) == expected2
def test_trailing_deletes_with_differing_lengths():
a1 = Delta().retain(2).delete(1)
b1 = Delta().delete(3)
expected1 = Delta().delete(2)
a2 = Delta(a1)
b2 = Delta(b1)
expected2 = Delta()
assert a1.transform(b1, False) == expected1
assert b2.transform(a2, False) == expected2
def multi_threaded_client(connection):
global delta_object
connection.send(str.encode('Server is working:'))
while True:
operation = ''
retain = ''
retain = input("Input position value to retain: ")
operation = input("Input Operation (insert/delete): ")
value = input("Input value for operation (insert: text | delete: position value): ")
if retain == '':
if operation == 'insert':
server_delta = Delta().insert(value)
elif operation == 'delete':
server_delta = Delta().delete(int(value))
else:
if operation == 'insert':
server_delta = Delta().retain(int(retain)).insert(value)
elif operation == 'delete':
server_delta = Delta().retain(int(retain)).delete(int(value))
print("\n")
print("[Initial State]:", delta_object)
print("[Server Operation]:", server_delta)
server_local = delta_object.compose(server_delta)
print("[State after Server Operation]:", server_local)
print("\n")
data = connection.recv(2048)
client_message = data.decode('utf-8')
print(client_message)
client_delta = utils.string_to_delta(client_message)
print("[Client Operation]:", client_delta)
client_transform = server_delta.transform(client_delta)
print("[Transformed Client Operation]:", client_transform)
server_result = server_local.compose(client_transform)
print("\n")
print("[Eventual State in Server]:", server_result)
response = str(server_delta)
if not data:
break
connection.sendall(str.encode(response))
connection.close()
def test_insert_and_insert():
a1 = Delta().insert('A')
b1 = Delta().insert('B')
a2 = Delta(a1)
b2 = Delta(b1)
expected1 = Delta().retain(1).insert('B')
expected2 = Delta().insert('B')
assert a1.transform(b1, True) == expected1
assert a1.transform(b2, False) == expected2
def test_combination():
a = Delta().insert('Bad', color='red').insert('cat', color='blue')
b = Delta().insert('Good', bold=True).insert('dog', italic=True)
expected = Delta() \
.insert('Good', bold=True) \
.delete(2) \
.retain(1, italic=True, color=None) \
.delete(3) \
.insert('og', italic=True)
print(a.document(), b.document(), expected)
assert a.diff(b) == expected
def test_immutability():
a1 = Delta().insert('A')
a2 = Delta().insert('A')
b1 = Delta().insert('B')
b2 = Delta().insert('B')
expected = Delta().retain(1).insert('B')
assert a1.transform(b1, True) == expected
assert a1 == a2
assert b1 == b2
def test_insert_and_delete_ordering():
a = Delta().insert('Hello')
b = Delta().insert('Hello')
insertFirst = Delta().retain(3).insert('X').delete(1)
deleteFirst = Delta().retain(3).delete(1).insert('X')
expected = Delta().insert('HelXo')
assert a.compose(insertFirst) == expected
assert a.compose(deleteFirst) == expected
def test_immutability():
attr1 = {
'bold': True
}
attr2 = {
'bold': True
}
a1 = Delta().insert('Test', **attr1)
a2 = Delta().insert('Test', **attr1)
b1 = Delta().retain(1, color='red').delete(2)
b2 = Delta().retain(1, color='red').delete(2)
expected = Delta().insert('T', color='red', bold=True).insert('t', **attr1)
assert a1.compose(b1) == expected
assert a1 == a2
assert b1 == b2
assert attr1 == attr2
def test_immutability():
attr1 = { 'color': 'red' };
attr2 = { 'color': 'red' };
a1 = Delta().insert('A', **attr1);
a2 = Delta().insert('A', **attr1);
b1 = Delta().insert('A', bold=True).insert('B');
b2 = Delta().insert('A', bold=True).insert('B');
expected = Delta().retain(1, bold=True, color=None).insert('B');
assert a1.diff(b1) == expected;
assert a1 == a2
assert b2 == b2
assert attr1 == attr2
def transform(delta1_ops, delta2_ops, side): delta1 = Delta(delta1_ops) delta2 = Delta(delta2_ops) # fuzzer specs is in opposite order of delta interface return delta2.transform(delta1, True if side == 'left' else False)
def test_retain_and_insert():
a = Delta().retain(1, color='blue')
b = Delta().insert('B')
expected = Delta().insert('B')
assert a.transform(b, True) == expected
def test_delete_and_delete():
a = Delta().delete(1)
b = Delta().delete(1)
expected = Delta()
assert a.transform(b, True) == expected
def append(snapshot, delta): # apply is reserved build-in symbol
snapshot = Delta(snapshot)
delta = Delta(delta)
return snapshot.compose(delta)
def compose(delta1, delta2):
delta1 = Delta(delta1)
delta2 = Delta(delta2)
return delta1.compose(delta2)
import os
from _thread import *
import sys
sys.path.append('../')
from delta import Delta
import utils
ServerSideSocket = socket.socket()
host = '127.0.0.1'
port = 2005
ThreadCount = 0
clients= set()
delta_object = Delta().insert('ABCD')
try:
ServerSideSocket.bind((host, port))
except socket.error as e:
print(str(e))
print('Socket is listening..')
ServerSideSocket.listen(5)
def multi_threaded_client(connection):
global delta_object
connection.send(str.encode('Server is working:'))
while True:
operation = ''
def compose(delta1_ops, delta2_ops): delta1 = Delta(delta1_ops) delta2 = Delta(delta2_ops) return delta1.compose(delta2)
def test_insert_before_and_delete_across_position():
delta = Delta().retain(2).insert('A').delete(4)
assert delta.transform(4) == 3
def test_delete_after_position():
delta = Delta().retain(4).delete(2)
assert delta.transform(2) == 2
def transform(delta1, delta2):
delta1 = Delta(delta1)
delta2 = Delta(delta2)
return delta1.diff(delta2)
def apply(snapshot_ops, delta_ops): snapshot = Delta(snapshot_ops) delta = Delta(delta_ops) return snapshot.compose(delta)
def test_retain_and_delete():
a = Delta().retain(1, color='blue')
b = Delta().delete(1)
expected = Delta().delete(1)
assert a.transform(b, True) == expected
def diff(delta1_ops, delta2_ops): delta1 = Delta(delta1_ops) delta2 = Delta(delta2_ops) return delta1.diff(delta2)
def test_delete_and_retain():
a = Delta().delete(1)
b = Delta().retain(1, bold=True, color='red')
expected = Delta()
assert a.transform(b, True) == expected
def test_delete_before_and_delete_across_position():
delta = Delta().delete(1).retain(1).delete(4)
assert delta.transform(4) == 1
def diff(delta1, delta2):
delta1 = Delta(delta1)
delta2 = Delta(delta2)
return delta1.diff(delta2)
def gen_boxplot(indices, settings):
anonym = 'unbekannt'
delta = const._asdict()[settings['delta'].strip()]
testtext = settings['testtext'].strip()
mfwmin = int(settings['mfwmin'])
cullmin = int(settings['culmin'])
sel_liste = [app.namen[x] for x in indices]
sel_liste.sort()
if testtext in sel_liste:
return ('Text already in selection!')
sel_liste.append(testtext)
#corpus=Corpus(subdir='corpus')
list_of_wordlists = []
for text in sel_liste:
all_words = collections.defaultdict(int)
#print("processing " + text)
for w in app.texte[text].split():
all_words[w] += 1
if text == testtext:
wordlist = pd.Series(all_words, name=anonym + '_unbekannt')
else:
wordlist = pd.Series(all_words, name=text)
list_of_wordlists.append(wordlist)
df = pd.DataFrame(list_of_wordlists).fillna(0).T
df = df.ix[(-df.sum(axis=1)).argsort()]
corpus = Corpus(corpus=df)
cul = 1 / cullmin
corpus = corpus.cull(ratio=cul)
mfw_corpus = corpus.get_mfw_table(mfwmin)
deltas = Delta(mfw_corpus, delta, None)
authors = list(
set([
a.split("_")[0] for a in deltas.columns
if not a.split("_")[0] == anonym
]))
ingroup_deltas = []
for i in range(0, len(authors)):
#alle Werke eines Autors ermitteln
works = [c for c in deltas.columns if authors[i] in c]
#alle ingroup-deltas ermitteln und Nullen entfernen
values = list(set(deltas.loc[works, works].values.flatten()))
values = [val for val in values if val != 0.0]
ingroup_deltas.append(values)
#unbekannten Text zu Ingroup-Werten dazunehmen
ingroup_deltas_anonym = []
for i in range(0, len(authors)):
works = [c for c in deltas.columns if authors[i] in c or anonym in c]
values = list(set(deltas.loc[works, works].values.flatten()))
values = [val for val in values if val != 0.0]
ingroup_deltas_anonym.append(values)
# #Positionen für die Boxen
plt.clf()
pos = list(range(1, len(authors) + 1))
params = ["boxes", "medians", "whiskers", "caps", "fliers", "means"]
box1 = plt.boxplot(ingroup_deltas,
widths=0.3,
positions=[p - 0.2 for p in pos])
box2 = plt.boxplot(ingroup_deltas_anonym,
widths=0.3,
positions=[p + 0.2 for p in pos])
# #Farben für die Boxen
for p in params:
plt.setp(box1[p], color="blue")
plt.setp(box2[p], color="red")
# #Achseneigenschaften
plt.xticks(np.arange(1, len(authors) + 1), authors)
plt.xlim(xmin=0.5)
output = io.StringIO()
plt.savefig(output, format='svg')
svg = output.getvalue()
output.close()
#fig = Figure(deltas.get_linkage('ward'), deltas.index, 'left', 8, 'Latin translations', mfwmin, delta, False)
#svg = fig.gensvg()
#dendro_dat, plot, svg= fig.show()
#svg = repr(settings)
return (svg)
def test_insert_and_delete():
a = Delta().insert('A')
b = Delta().delete(1)
expected = Delta().retain(1).delete(1)
assert a.transform(b, True) == expected
